using System;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.IO;
using System.IO.Compression;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Cryptography;
using System.Security.Permissions;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using System.Threading.Tasks;
using AngryLevelLoader;
using AngryLevelLoader.Containers;
using AngryLevelLoader.DataTypes;
using AngryLevelLoader.DataTypes.MapVarHandlers;
using AngryLevelLoader.Extensions;
using AngryLevelLoader.Fields;
using AngryLevelLoader.Managers;
using AngryLevelLoader.Managers.BannedMods;
using AngryLevelLoader.Managers.LegacyPatches;
using AngryLevelLoader.Managers.ServerManager;
using AngryLevelLoader.Notifications;
using AngryLevelLoader.Patches;
using AngryLevelLoader.UserInterface;
using AngryLevelLoader.Utils;
using AngryUiComponents;
using BananaDifficulty;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Logging;
using BillionDifficulty;
using Configgy;
using FasterPunch;
using HarmonyLib;
using Logic;
using LucasMeshCombine;
using Newtonsoft.Json;
using Notiffy.API;
using PluginConfig;
using PluginConfig.API;
using PluginConfig.API.Decorators;
using PluginConfig.API.Fields;
using PluginConfig.API.Functionals;
using ProjectProphet;
using RudeLevelScript;
using RudeLevelScripts;
using RudeLevelScripts.Essentials;
using Steamworks;
using Steamworks.Data;
using TMPro;
using The_Timestopper;
using TimeStop;
using ULTRAKILL.Portal;
using Ultracoins;
using Ultrapain;
using UnityEngine;
using UnityEngine.AddressableAssets;
using UnityEngine.AddressableAssets.ResourceLocators;
using UnityEngine.EventSystems;
using UnityEngine.Events;
using UnityEngine.InputSystem;
using UnityEngine.InputSystem.Utilities;
using UnityEngine.Networking;
using UnityEngine.ResourceManagement.AsyncOperations;
using UnityEngine.SceneManagement;
using UnityEngine.UI;
using UnityExplorer.ObjectExplorer;
using UnityExplorer.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("AngryLevelLoader")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyDescription("Loads level made with Rude level editor")]
[assembly: AssemblyFileVersion("4.0.3.0")]
[assembly: AssemblyInformationalVersion("4.0.3+a99074082a13f68eee4cc1fec63497b76654ee28")]
[assembly: AssemblyProduct("AngryLevelLoader")]
[assembly: AssemblyTitle("AngryLevelLoader")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("4.0.3.0")]
[module: UnverifiableCode]
internal class CrossThreadInvoker : ISynchronizeInvoke
{
	private class BackgroundUpdater : MonoBehaviour
	{
		public void Update()
		{
			ProcessQueue();
		}
	}

	private class AsyncResult : IAsyncResult
	{
		public Delegate method;

		public object[] args;

		public ManualResetEvent manualResetEvent;

		public Thread invokingThread;

		public bool IsCompleted { get; set; }

		public WaitHandle AsyncWaitHandle => manualResetEvent;

		public object AsyncState { get; set; }

		public bool CompletedSynchronously { get; set; }

		public void Invoke()
		{
			AsyncState = method.DynamicInvoke(args);
			IsCompleted = true;
			manualResetEvent.Set();
		}
	}

	private static CrossThreadInvoker instance;

	private static Thread mainThread;

	private static readonly Queue<AsyncResult> ToExecute = new Queue<AsyncResult>();

	public static CrossThreadInvoker Instance => instance;

	public bool InvokeRequired => mainThread.ManagedThreadId != Thread.CurrentThread.ManagedThreadId;

	public static void Init()
	{
		if (instance == null)
		{
			mainThread = Thread.CurrentThread;
			instance = new CrossThreadInvoker();
			((Component)Plugin.instance).gameObject.AddComponent<BackgroundUpdater>();
		}
	}

	private static void ProcessQueue()
	{
		if (Thread.CurrentThread != mainThread)
		{
			throw new Exception("must be called from the same thread it was created on (created on thread id: " + mainThread.ManagedThreadId + ", called from thread id: " + Thread.CurrentThread.ManagedThreadId);
		}
		AsyncResult asyncResult = null;
		while (true)
		{
			lock (ToExecute)
			{
				if (ToExecute.Count == 0)
				{
					break;
				}
				asyncResult = ToExecute.Dequeue();
			}
			asyncResult.Invoke();
		}
	}

	public IAsyncResult BeginInvoke(Delegate method, object[] args)
	{
		AsyncResult asyncResult = new AsyncResult
		{
			method = method,
			args = args,
			IsCompleted = false,
			manualResetEvent = new ManualResetEvent(initialState: false),
			invokingThread = Thread.CurrentThread
		};
		if (mainThread.ManagedThreadId != asyncResult.invokingThread.ManagedThreadId)
		{
			lock (ToExecute)
			{
				ToExecute.Enqueue(asyncResult);
			}
		}
		else
		{
			asyncResult.Invoke();
			asyncResult.CompletedSynchronously = true;
		}
		return asyncResult;
	}

	public object EndInvoke(IAsyncResult result)
	{
		if (!result.IsCompleted)
		{
			result.AsyncWaitHandle.WaitOne();
		}
		return result.AsyncState;
	}

	public object Invoke(Delegate method, object[] args)
	{
		if (InvokeRequired)
		{
			IAsyncResult result = BeginInvoke(method, args);
			return EndInvoke(result);
		}
		return method.DynamicInvoke(args);
	}
}
namespace AngryLevelLoader
{
	public static class AngryPaths
	{
		internal enum Repo
		{
			AngryLevelLoader,
			AngryLevels
		}

		public const string SERVER_ROOT_GLOBAL = "https://angry.dnzsoft.com";

		public const string SERVER_ROOT_LOCAL = "http://localhost:3000";

		public static string SERVER_ROOT
		{
			get
			{
				if (!ConfigManager.useLocalServer.value)
				{
					return "https://angry.dnzsoft.com";
				}
				return "http://localhost:3000";
			}
		}

		public static string ConfigFolderPath => Path.Combine(Paths.ConfigPath, "AngryLevelLoader");

		public static string OnlineCacheFolderPath => Path.Combine(ConfigFolderPath, "OnlineCache");

		public static string ThumbnailCachePath => Path.Combine(OnlineCacheFolderPath, "thumbnailCacheHashes.txt");

		public static string LevelCatalogCachePath => Path.Combine(OnlineCacheFolderPath, "V2", "LevelCatalog.json");

		public static string ScriptsPath => Path.Combine(Plugin.workingDir, "Scripts");

		public static string ScriptCatalogCachePath => Path.Combine(OnlineCacheFolderPath, "ScriptCatalog.json");

		public static string ThumbnailCacheFolderPath => Path.Combine(OnlineCacheFolderPath, "ThumbnailCache");

		public static string LastPlayedMapPath => Path.Combine(ConfigFolderPath, "lastPlayedMap.txt");

		public static string LastUpdateMapPath => Path.Combine(ConfigFolderPath, "lastUpdateMap.txt");

		internal static string GetGithubURL(Repo repo, string path)
		{
			string text = "release";
			if (ConfigManager.useDevelopmentBranch.value)
			{
				text = "dev";
			}
			string text2 = "AngryLevels";
			switch (repo)
			{
			case Repo.AngryLevels:
				text2 = "AngryLevels";
				break;
			case Repo.AngryLevelLoader:
				text2 = "AngryLevelLoader";
				break;
			}
			return "https://raw.githubusercontent.com/eternalUnion/" + text2 + "/" + text + "/" + path;
		}

		internal static void TryCreateAllPaths()
		{
			AngryIOUtils.TryCreateDirectory(ConfigFolderPath);
			AngryIOUtils.TryCreateDirectory(OnlineCacheFolderPath);
			AngryIOUtils.TryCreateDirectory(ThumbnailCacheFolderPath);
			AngryIOUtils.TryCreateDirectory(ScriptsPath);
		}
	}
	internal class SpaceField : CustomConfigField
	{
		public SpaceField(ConfigPanel parentPanel, float space)
			: base(parentPanel, 60f, space)
		{
		}
	}
	[BepInPlugin("com.eternalUnion.angryLevelLoader", "AngryLevelLoader", "4.0.3")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class Plugin : BaseUnityPlugin
	{
		[CompilerGenerated]
		private sealed class <<InitializeFileWatcher>g__LoadLevelInstantly|26_5>d : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			private <>c__DisplayClass26_0 <>8__1;

			private BundleContainer <bundle>5__2;

			private LevelContainer <level>5__3;

			private Transform <optionsMenu>5__4;

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

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

			[DebuggerHidden]
			public <<InitializeFileWatcher>g__LoadLevelInstantly|26_5>d(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

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

			private bool MoveNext()
			{
				//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00bc: Expected O, but got Unknown
				//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
				//IL_0322: Unknown result type (might be due to invalid IL or missing references)
				//IL_032c: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>8__1 = new <>c__DisplayClass26_0();
					<>2__current = null;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					if (!TryGetAngryBundleByGuid(InternalConfigManager.instantLoadLevelGuid.value, out <bundle>5__2))
					{
						logger.LogInfo((object)"Bundle not found");
						return false;
					}
					<>8__1.handler = <bundle>5__2.ReloadBundle(forceReload: false, lazyLoad: false);
					<>2__current = (object)new WaitUntil((Func<bool>)(() => <>8__1.handler.IsCompleted));
					<>1__state = 2;
					return true;
				case 2:
				{
					<>1__state = -1;
					if (!<bundle>5__2.TryGetLevelContainer(InternalConfigManager.instantLoadLevelId.value, out <level>5__3))
					{
						logger.LogInfo((object)"Level not found");
						return false;
					}
					Scene activeScene = SceneManager.GetActiveScene();
					GameObject val = (from obj in ((Scene)(ref activeScene)).GetRootGameObjects()
						where ((Object)obj).name == "Canvas"
						select obj).FirstOrDefault();
					if ((Object)(object)val == (Object)null)
					{
						logger.LogWarning((object)"Angry tried to create main menu buttons, but root canvas was not found!");
						return false;
					}
					<optionsMenu>5__4 = val.transform.Find("OptionsMenu");
					if ((Object)(object)<optionsMenu>5__4 == (Object)null)
					{
						logger.LogError((object)"Angry tried to find the options menu but failed!");
						return false;
					}
					((Component)<optionsMenu>5__4).gameObject.SetActive(true);
					<>2__current = null;
					<>1__state = 3;
					return true;
				}
				case 3:
				{
					<>1__state = -1;
					Transform val2 = ((Component)<optionsMenu>5__4).transform.Find("Navigation Rail/PluginConfiguratorButton(Clone)");
					if ((Object)(object)val2 == (Object)null)
					{
						val2 = ((Component)<optionsMenu>5__4).transform.Find("Navigation Rail/PluginConfiguratorButton");
					}
					if ((Object)(object)val2 == (Object)null)
					{
						logger.LogError((object)"Angry tried to find the plugin configurator button but failed!");
						return false;
					}
					Transform val3 = <optionsMenu>5__4.Find("Navigation Rail");
					ButtonHighlightParent val4 = default(ButtonHighlightParent);
					if ((Object)(object)val3 != (Object)null && ((Component)val3).gameObject.TryGetComponent<ButtonHighlightParent>(ref val4) && (val4.buttons == null || val4.buttons.Length == 0))
					{
						val4.Start();
						val4.targetOnStart = null;
					}
					((UnityEvent)((Component)val2).gameObject.GetComponent<Button>().onClick).Invoke();
					<>2__current = null;
					<>1__state = 4;
					return true;
				}
				case 4:
					<>1__state = -1;
					if ((Object)(object)PluginConfiguratorController.activePanel != (Object)null)
					{
						PluginConfiguratorController.activePanel.SetActive(false);
					}
					<>2__current = null;
					<>1__state = 5;
					return true;
				case 5:
					<>1__state = -1;
					((Component)PluginConfiguratorController.mainPanel).gameObject.SetActive(false);
					<>2__current = null;
					<>1__state = 6;
					return true;
				case 6:
					<>1__state = -1;
					ConfigManager.config.rootPanel.OpenPanelInternally(false);
					<>2__current = null;
					<>1__state = 7;
					return true;
				case 7:
					<>1__state = -1;
					if (!<bundle>5__2.Loaded)
					{
						<>2__current = (object)new WaitUntil((Func<bool>)new <>c__DisplayClass26_1
						{
							reloadTask = <bundle>5__2.ReloadBundle(forceReload: false, lazyLoad: false)
						}.<InitializeFileWatcher>b__9);
						<>1__state = 8;
						return true;
					}
					goto IL_033c;
				case 8:
					<>1__state = -1;
					goto IL_033c;
				case 9:
					{
						<>1__state = -1;
						AngrySceneManager.LevelButtonPressed(<level>5__3);
						return false;
					}
					IL_033c:
					<>2__current = null;
					<>1__state = 9;
					return true;
				}
			}

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

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

		[CompilerGenerated]
		private sealed class <>c__DisplayClass26_0
		{
			public Task<bool> handler;

			internal bool <InitializeFileWatcher>b__7()
			{
				return handler.IsCompleted;
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass26_1
		{
			public Task reloadTask;

			internal bool <InitializeFileWatcher>b__9()
			{
				return reloadTask.IsCompleted;
			}
		}

		public const string PLUGIN_NAME = "AngryLevelLoader";

		public const string PLUGIN_GUID = "com.eternalUnion.angryLevelLoader";

		public const string PLUGIN_VERSION = "4.0.3";

		public const string PLUGIN_CONFIG_MIN_VERSION = "1.8.0";

		internal static string workingDir;

		public static string tempFolderPath;

		internal static string dataPath;

		internal static string levelsPath;

		internal static string mapVarsFolderPath;

		public static string angryCatalogPath;

		internal static Plugin instance;

		internal static Harmony harmony;

		internal static ManualLogSource logger;

		private static readonly Dictionary<string, BundleContainer> angryBundles = new Dictionary<string, BundleContainer>();

		private static int numOfOldBundles = 0;

		internal static FileSystemWatcher levelsWatcher;

		internal static FileSystemWatcher scriptsWatcher;

		private float lastPress;

		public static IEnumerable<BundleContainer> GetAllBundleContainers()
		{
			return angryBundles.Values;
		}

		public static bool TryGetAngryBundleByGuid(string guid, out BundleContainer bundleContainer)
		{
			bundleContainer = angryBundles.Values.Where((BundleContainer bundle) => bundle.bundleGuid == guid).FirstOrDefault();
			return bundleContainer != null;
		}

		public static bool TryGetAngryLevel(string id, out LevelContainer level)
		{
			level = null;
			foreach (BundleContainer allBundleContainer in GetAllBundleContainers())
			{
				foreach (LevelContainer allLevelContainer in allBundleContainer.GetAllLevelContainers())
				{
					if (allLevelContainer.levelId == id)
					{
						level = allLevelContainer;
						return true;
					}
				}
			}
			return false;
		}

		private static void ProcessPath(string path, FolderButtonField folder)
		{
			if (AngryFileUtils.TryGetAngryBundleData(path, out var data, out var error))
			{
				if (angryBundles.TryGetValue(data.bundleGuid, out var value))
				{
					if (value.HasValidAngryFile && !AngryIOUtils.PathEquals(path, value.pathToAngryBundle))
					{
						logger.LogError((object)("Duplicate angry files. Original: " + Path.GetFileName(value.pathToAngryBundle) + ". Duplicate: " + Path.GetFileName(path)));
						if (!string.IsNullOrEmpty(ConfigManager.errorText.text))
						{
							ConfigHeader errorText = ConfigManager.errorText;
							errorText.text += "\n";
						}
						ConfigHeader errorText2 = ConfigManager.errorText;
						errorText2.text = errorText2.text + "<color=red>Error loading " + Path.GetFileName(path) + "</color> Duplicate file, original is " + Path.GetFileName(value.pathToAngryBundle);
						return;
					}
					folder.bundles.Add(value);
					if (data.bundleVersion < 6)
					{
						numOfOldBundles++;
					}
					value.pathToAngryBundle = path;
					if (value.LazyLoaded && value.BuildHash != data.buildHash)
					{
						if (value.Loaded && AngrySceneManager.isInCustomLevel && AngrySceneManager.currentBundleContainer == value)
						{
							value.FileChanged();
						}
						else
						{
							value.ReloadBundle(forceReload: false, lazyLoad: true);
						}
					}
					return;
				}
				value = new BundleContainer(path, data);
				angryBundles[data.bundleGuid] = value;
				folder.bundles.Add(value);
				try
				{
					value.ReloadBundle(forceReload: false, lazyLoad: true);
				}
				catch (Exception arg)
				{
					logger.LogWarning((object)$"Exception thrown while loading level bundle: {arg}");
					if (!string.IsNullOrEmpty(ConfigManager.errorText.text))
					{
						ConfigHeader errorText3 = ConfigManager.errorText;
						errorText3.text += "\n";
					}
					ConfigHeader errorText4 = ConfigManager.errorText;
					errorText4.text = errorText4.text + "<color=red>Error loading " + Path.GetFileNameWithoutExtension(path) + "</color>. Check the logs for more information";
				}
				if (data.bundleVersion < 6)
				{
					numOfOldBundles++;
				}
			}
			else if (AngryFileUtils.IsV1LegacyFile(path))
			{
				if (!string.IsNullOrEmpty(ConfigManager.errorText.text))
				{
					ConfigHeader errorText5 = ConfigManager.errorText;
					errorText5.text += "\n";
				}
				ConfigHeader errorText6 = ConfigManager.errorText;
				errorText6.text = errorText6.text + "<color=yellow>" + Path.GetFileName(path) + " is a V1 legacy file. Support for legacy files were dropped after 2.5.0</color>";
			}
			else
			{
				logger.LogError((object)$"Could not load the bundle at {path}\n{error}");
				if (!string.IsNullOrEmpty(ConfigManager.errorText.text))
				{
					ConfigHeader errorText7 = ConfigManager.errorText;
					errorText7.text += "\n";
				}
				ConfigHeader errorText8 = ConfigManager.errorText;
				errorText8.text = errorText8.text + "<color=yellow>Failed to load " + Path.GetFileNameWithoutExtension(path) + "</color>";
			}
		}

		private static void ScanForLevelsRecursive(string folderPath, FolderButtonField folder)
		{
			string[] files = Directory.GetFiles(folderPath);
			foreach (string text in files)
			{
				if (text.EndsWith(".angry"))
				{
					ProcessPath(Path.Combine(folderPath, text), folder);
				}
			}
			files = Directory.GetDirectories(folderPath);
			foreach (string obj in files)
			{
				string fileName = Path.GetFileName(obj);
				ScanForLevelsRecursive(obj, folder.GetOrCreateFolder(fileName));
			}
		}

		public static void ScanForLevels()
		{
			numOfOldBundles = 0;
			ConfigManager.errorText.text = "";
			ConfigManager.searchBar.value = "";
			if (!Directory.Exists(levelsPath))
			{
				logger.LogWarning((object)("Could not find the Levels folder at " + levelsPath));
				ConfigManager.errorText.text = "<color=red>Error: </color>Levels folder not found";
				return;
			}
			AngryBundleList.ResetFolders();
			ScanForLevelsRecursive(levelsPath, AngryBundleList.rootFolder);
			AngryBundleList.SortBundles();
			AngryBundleList.UpdateFolderIcons();
			if (numOfOldBundles != 0)
			{
				if (!string.IsNullOrEmpty(ConfigManager.errorText.text))
				{
					ConfigHeader errorText = ConfigManager.errorText;
					errorText.text += "\n";
				}
				ConfigHeader errorText2 = ConfigManager.errorText;
				errorText2.text += $"<color=yellow>Hidden {numOfOldBundles} old angry file(s). These files can be deleted at the bottom of the settings page.</color>";
			}
			AngryBundleList.DisplayFolder(AngryBundleList.rootFolder);
			OnlineLevelsList.UpdateUI();
		}

		private static bool LoadEssentialScripts()
		{
			bool result = true;
			switch (ScriptManager.AttemptLoadScriptWithCertificate("AngryLoaderAPI.dll"))
			{
			case ScriptManager.LoadScriptResult.NotFound:
				logger.LogError((object)"Required script AngryLoaderAPI.dll not found");
				result = false;
				break;
			case ScriptManager.LoadScriptResult.NoCertificate:
				logger.LogError((object)"Required script AngryLoaderAPI.dll is not signed");
				result = false;
				break;
			case ScriptManager.LoadScriptResult.InvalidCertificate:
				logger.LogError((object)"Required script AngryLoaderAPI.dll signature is invalid");
				result = false;
				break;
			default:
				logger.LogError((object)"Required script AngryLoaderAPI.dll could not be loaded");
				result = false;
				break;
			case ScriptManager.LoadScriptResult.Loaded:
				break;
			}
			switch (ScriptManager.AttemptLoadScriptWithCertificate("RudeLevelScripts.dll"))
			{
			case ScriptManager.LoadScriptResult.NotFound:
				logger.LogError((object)"Required script RudeLevelScripts.dll not found");
				result = false;
				break;
			case ScriptManager.LoadScriptResult.NoCertificate:
				logger.LogError((object)"Required script RudeLevelScripts.dll is not signed");
				result = false;
				break;
			case ScriptManager.LoadScriptResult.InvalidCertificate:
				logger.LogError((object)"Required script RudeLevelScripts.dll signature is invalid");
				result = false;
				break;
			default:
				logger.LogError((object)"Required script RudeLevelScripts.dll could not be loaded");
				result = false;
				break;
			case ScriptManager.LoadScriptResult.Loaded:
				break;
			}
			return result;
		}

		private void ForceLoadAddressableDependencies()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			Addressables.LoadAssetAsync<GameObject>((object)"Assets/Prefabs/Attacks and Projectiles/Projectile Decorative.prefab").WaitForCompletion();
			Addressables.LoadAssetAsync<GameObject>((object)"FirstRoom").WaitForCompletion();
			Addressables.LoadAssetAsync<GameObject>((object)"FirstRoom Secret").WaitForCompletion();
			Addressables.LoadAssetAsync<GameObject>((object)"FirstRoom Prime").WaitForCompletion();
			Addressables.LoadAssetAsync<GameObject>((object)"Assets/Prefabs/Levels/Special Rooms/FirstRoom Encore.prefab").WaitForCompletion();
			Addressables.LoadAssetAsync<Font>((object)"Assets/Fonts/VCR_OSD_MONO_1.001.ttf").WaitForCompletion();
			Addressables.LoadAssetAsync<Sprite>((object)"Assets/Textures/UI/meter.png").WaitForCompletion();
			Addressables.LoadAssetAsync<Sprite>((object)"Assets/Textures/UI/arrow.png").WaitForCompletion();
			Addressables.LoadAssetAsync<Material>((object)"Assets/Materials/Environment/Metal/Metal Decoration 20.mat").WaitForCompletion();
		}

		private static void RefreshCatalogOnMainMenu(Scene newScene, LoadSceneMode mode)
		{
			if (!(SceneHelper.CurrentScene != "Main Menu"))
			{
				if (ConfigManager.refreshCatalogOnBoot.value)
				{
					OnlineLevelsList.RefreshAsync();
				}
				SceneManager.sceneLoaded -= RefreshCatalogOnMainMenu;
			}
		}

		private static void InitializeFileWatcher()
		{
			if (levelsWatcher != null)
			{
				return;
			}
			levelsWatcher = new FileSystemWatcher(levelsPath);
			levelsWatcher.SynchronizingObject = CrossThreadInvoker.Instance;
			levelsWatcher.Changed += delegate(object sender, FileSystemEventArgs e)
			{
				string fullPath4 = e.FullPath;
				foreach (BundleContainer value2 in angryBundles.Values)
				{
					if (AngryIOUtils.PathEquals(fullPath4, value2.pathToAngryBundle))
					{
						logger.LogWarning((object)("Bundle " + fullPath4 + " was updated, container notified"));
						value2.FileChanged();
						break;
					}
				}
			};
			levelsWatcher.Renamed += delegate(object sender, RenamedEventArgs e)
			{
				string oldFullPath = e.OldFullPath;
				foreach (BundleContainer value3 in angryBundles.Values)
				{
					if (AngryIOUtils.PathEquals(oldFullPath, value3.pathToAngryBundle))
					{
						logger.LogWarning((object)("Bundle " + oldFullPath + " was renamed, path updated"));
						value3.pathToAngryBundle = e.FullPath;
						break;
					}
				}
			};
			levelsWatcher.Deleted += delegate(object sender, FileSystemEventArgs e)
			{
				string fullPath3 = e.FullPath;
				foreach (BundleContainer value4 in angryBundles.Values)
				{
					if (AngryIOUtils.PathEquals(fullPath3, value4.pathToAngryBundle))
					{
						logger.LogWarning((object)("Bundle " + fullPath3 + " was deleted, unlinked"));
						value4.pathToAngryBundle = "";
						break;
					}
				}
			};
			levelsWatcher.Created += delegate(object sender, FileSystemEventArgs e)
			{
				string fullPath2 = e.FullPath;
				if (AngryFileUtils.TryGetAngryBundleData(fullPath2, out var data, out var _) && angryBundles.TryGetValue(data.bundleGuid, out var value) && value.bundleGuid == data.bundleGuid && !value.HasValidAngryFile)
				{
					logger.LogWarning((object)("Bundle " + fullPath2 + " was just added, and a container with the same guid had no file linked. Linked, container notified"));
					value.pathToAngryBundle = fullPath2;
					value.FileChanged();
				}
			};
			levelsWatcher.Filter = "*";
			levelsWatcher.IncludeSubdirectories = true;
			levelsWatcher.EnableRaisingEvents = true;
			scriptsWatcher = new FileSystemWatcher(AngryPaths.ScriptsPath);
			scriptsWatcher.SynchronizingObject = CrossThreadInvoker.Instance;
			scriptsWatcher.Changed += delegate(object sender, FileSystemEventArgs e)
			{
				string fullPath = e.FullPath;
				if (fullPath.EndsWith(".dll") && ScriptManager.ScriptChanged(Path.GetFileName(fullPath)))
				{
					logger.LogMessage((object)("Detected script change " + Path.GetFileName(fullPath)));
					AngryUI.UpdatedScript = Path.GetFileName(fullPath);
				}
			};
			scriptsWatcher.Filter = "*";
			scriptsWatcher.IncludeSubdirectories = false;
			scriptsWatcher.EnableRaisingEvents = true;
			SceneManager.sceneLoaded += CheckForInstantLoad;
			static void CheckForInstantLoad(Scene scene, LoadSceneMode mode)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_0002: Invalid comparison between Unknown and I4
				if ((int)mode != 1 && !AngrySceneManager.isInCustomLevel && !(SceneHelper.CurrentScene != "Main Menu"))
				{
					if (!InternalConfigManager.instantLoadLevel.value)
					{
						SceneManager.sceneLoaded -= CheckForInstantLoad;
					}
					else
					{
						InternalConfigManager.instantLoadLevel.value = false;
						logger.LogInfo((object)"Starting custom level instantly");
						((MonoBehaviour)instance).StartCoroutine(LoadLevelInstantly());
					}
				}
			}
			[IteratorStateMachine(typeof(<<InitializeFileWatcher>g__LoadLevelInstantly|26_5>d))]
			static IEnumerator LoadLevelInstantly()
			{
				//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
				return new <<InitializeFileWatcher>g__LoadLevelInstantly|26_5>d(0);
			}
		}

		private void DisplayPluginConfigVersionError()
		{
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			PluginConfigurator obj = PluginConfigurator.Create("Angry Level Loader", "com.eternalUnion.angryLevelLoader");
			obj.SetIconWithURL("file://" + Path.Combine(workingDir, "plugin-icon.png"));
			new ConfigHeader(obj.rootPanel, "<color=red>Plugin config version too low, 1.8.0 or above needed</color>", 24);
		}

		private void Start()
		{
			instance = this;
			logger = ((BaseUnityPlugin)this).Logger;
			workingDir = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
			if (Chainloader.PluginInfos.TryGetValue("com.eternalUnion.pluginConfigurator", out var value))
			{
				if (!(value.Metadata.Version < new Version("1.8.0")))
				{
					try
					{
						PostAwake();
						return;
					}
					catch (Exception ex)
					{
						logger.LogError((object)ex);
						ConfigManager.InitializeErrorConfig("Encountered an unknown error, cannot recover!", ex);
						((Behaviour)this).enabled = false;
						return;
					}
				}
				logger.LogError((object)"Angry level loader needs Plugin Configurator minimum version 1.8.0 to work properly. Disabled.");
				DisplayPluginConfigVersionError();
				((Behaviour)this).enabled = false;
			}
			else
			{
				logger.LogError((object)"Angry level loader needs Plugin Configurator minimum version 1.8.0 to work properly. Disabled.");
				((Behaviour)this).enabled = false;
			}
		}

		private void PostAwake()
		{
			//IL_016b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0170: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f8: Expected O, but got Unknown
			InternalConfigManager.InitializeInternalConfig();
			if (!InternalConfigManager.askedPermissionForLeaderboards.value)
			{
				NotificationPanel.Open((Notification)(object)new LeaderboardPermissionNotification());
			}
			dataPath = InternalConfigManager.configDataPath.value;
			try
			{
				AngryIOUtils.TryCreateDirectory(dataPath);
			}
			catch (IOException ex)
			{
				logger.LogError((object)("Failed to create data path at '" + dataPath + "'! Overwriting with the default value '" + InternalConfigManager.configDataPath.defaultValue + "'"));
				logger.LogError((object)ex);
				InternalConfigManager.configDataPath.value = InternalConfigManager.configDataPath.defaultValue;
				dataPath = InternalConfigManager.configDataPath.defaultValue;
				try
				{
					AngryIOUtils.TryCreateDirectory(dataPath);
				}
				catch (IOException ex2)
				{
					logger.LogError((object)("Failed to create data path at '" + dataPath + "'! Cannot recover, disabling plugin."));
					ConfigManager.InitializeErrorConfig("Error! Failed to create plugin's data folder at '" + dataPath + "'", ex2);
					((Behaviour)this).enabled = false;
					return;
				}
			}
			levelsPath = Path.Combine(dataPath, "Levels");
			AngryIOUtils.TryCreateDirectory(levelsPath);
			tempFolderPath = Path.Combine(dataPath, "LevelsUnpacked");
			AngryIOUtils.TryCreateDirectory(tempFolderPath);
			mapVarsFolderPath = Path.Combine(dataPath, "MapVars");
			AngryIOUtils.TryCreateDirectory(mapVarsFolderPath);
			AngryPaths.TryCreateAllPaths();
			CrossThreadInvoker.Init();
			InitializeFileWatcher();
			Addressables.InitializeAsync().WaitForCompletion();
			ForceLoadAddressableDependencies();
			angryCatalogPath = Path.Combine(workingDir, "Assets");
			Addressables.LoadContentCatalogAsync(Path.Combine(angryCatalogPath, "catalog.json"), true, (string)null).WaitForCompletion();
			AssetManager.Init();
			AngryUser.Init();
			LegacyPatchManager.Init();
			if (!LoadEssentialScripts())
			{
				logger.LogError((object)"Disabling AngryLevelLoader because one or more of its dependencies have failed to load");
				((Behaviour)this).enabled = false;
				return;
			}
			LastPlayedMapManager.LoadLastPlayedMap();
			LastPlayedMapManager.LoadLastUpdateMap();
			harmony = new Harmony("com.eternalUnion.angryLevelLoader");
			harmony.PatchAll();
			AngrySceneManager.Init();
			SceneManager.sceneLoaded += RefreshCatalogOnMainMenu;
			ConfigManager.InitializeConfig();
			BannedModsManager.Init();
			MeshCombineManagerPatches.Initialize();
			PluginUpdateHandler.Check();
			ScanForLevels();
			AngryUser.GetPermissionsTask().ContinueWith(delegate(Task<AngryUser.GetPermissionsResult> res)
			{
				if (!res.IsCompletedSuccessfully || !res.Result.completedSuccessfully)
				{
					logger.LogError((object)"Could not obtain user permissions");
				}
				else
				{
					AngryUser.GetPermissionsResult result = res.Result;
					if (result.status != 0)
					{
						logger.LogError((object)("Could not obtain user permissions: " + result.message));
					}
					else
					{
						AngryUser.hasLeaderboardPermissions = result.response.hasLeaderboardModificationPermission;
					}
				}
			}, TaskScheduler.FromCurrentSynchronizationContext());
			AngryCustomLevelButton.Init();
			AngryUI.Init();
			AngryBundleList.Init();
			((BaseUnityPlugin)this).Logger.LogInfo((object)"Plugin com.eternalUnion.angryLevelLoader is loaded!");
		}

		private void OnGUI()
		{
			//IL_0005: 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_0028: 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_0031: Invalid comparison between Unknown and I4
			//IL_005e: 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_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0157: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_015b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0161: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a2: 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_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_0144: Unknown result type (might be due to invalid IL or missing references)
			//IL_0156: Unknown result type (might be due to invalid IL or missing references)
			if (((int)ConfigManager.reloadFileKeybind.value == 0 && (int)ConfigManager.reloadScriptKeybind.value == 0) || !AngrySceneManager.isInCustomLevel)
			{
				return;
			}
			Event current = Event.current;
			KeyCode val = (KeyCode)0;
			if ((int)current.keyCode == 27)
			{
				return;
			}
			if (current.isKey || current.isMouse || current.button > 2 || current.shift)
			{
				if (current.isKey)
				{
					val = current.keyCode;
				}
				else if (Input.GetKey((KeyCode)304))
				{
					val = (KeyCode)304;
				}
				else if (Input.GetKey((KeyCode)303))
				{
					val = (KeyCode)303;
				}
				else if (current.button <= 6)
				{
					val = (KeyCode)(323 + current.button);
				}
			}
			else if (Input.GetKey((KeyCode)326) || Input.GetKey((KeyCode)327) || Input.GetKey((KeyCode)328) || Input.GetKey((KeyCode)329))
			{
				val = (KeyCode)326;
				if (Input.GetKey((KeyCode)327))
				{
					val = (KeyCode)327;
				}
				else if (Input.GetKey((KeyCode)328))
				{
					val = (KeyCode)328;
				}
				else if (Input.GetKey((KeyCode)329))
				{
					val = (KeyCode)329;
				}
			}
			else if (Input.GetKey((KeyCode)304) || Input.GetKey((KeyCode)303))
			{
				val = (KeyCode)304;
				if (Input.GetKey((KeyCode)303))
				{
					val = (KeyCode)303;
				}
			}
			if ((int)val == 0)
			{
				return;
			}
			if (val == ConfigManager.reloadFileKeybind.value)
			{
				if (Time.time - lastPress < 3f)
				{
					return;
				}
				lastPress = Time.time;
				if (NotificationPanel.CurrentNotificationCount() == 0 && AngrySceneManager.currentBundleContainer != null)
				{
					AngrySceneManager.currentBundleContainer.ReloadBundle(forceReload: false, lazyLoad: false);
				}
			}
			if (val == ConfigManager.reloadScriptKeybind.value)
			{
				AngryUI.ReloadScript();
			}
		}
	}
	public static class RudeLevelInterface
	{
		public static char INCOMPLETE_LEVEL_CHAR = '-';

		public static char GetLevelRank(string levelId)
		{
			if (Plugin.TryGetAngryLevel(levelId, out var level))
			{
				return level.FinalRank;
			}
			return INCOMPLETE_LEVEL_CHAR;
		}

		public static bool GetLevelChallenge(string levelId)
		{
			if (Plugin.TryGetAngryLevel(levelId, out var level))
			{
				return level.ChallengeDone;
			}
			return false;
		}

		public static bool GetLevelSecret(string levelId, int secretIndex)
		{
			if (secretIndex < 0)
			{
				return false;
			}
			if (Plugin.TryGetAngryLevel(levelId, out var level))
			{
				return level.SecretDiscovered(secretIndex);
			}
			return false;
		}

		public static string GetCurrentLevelId()
		{
			if (!AngrySceneManager.isInCustomLevel)
			{
				return "";
			}
			return AngrySceneManager.currentLevelData.uniqueIdentifier;
		}
	}
	public static class RudeBundleInterface
	{
		public static bool BundleExists(string bundleGuid)
		{
			return (from bundle in Plugin.GetAllBundleContainers()
				where bundle.bundleGuid == bundleGuid
				select bundle).FirstOrDefault() != null;
		}

		public static string GetBundleBuildHash(string bundleGuid)
		{
			BundleContainer bundleContainer = (from bundle in Plugin.GetAllBundleContainers()
				where bundle.bundleGuid == bundleGuid
				select bundle).FirstOrDefault();
			if (bundleContainer != null)
			{
				return bundleContainer.BuildHash;
			}
			return "";
		}
	}
	public static class RudeGamemodeInterface
	{
		public static AngryGamemodeManager.Gamemode GetCurrentGamemode()
		{
			return AngryGamemodeManager.SelectedGamemode;
		}
	}
	internal static class PluginUpdateHandler
	{
		private static async Task PauseAndShowChangelog(PluginInfoJson json)
		{
			Scene activeScene = SceneManager.GetActiveScene();
			GameObject val = (from obj in ((Scene)(ref activeScene)).GetRootGameObjects()
				where ((Object)obj).name == "Canvas"
				select obj).FirstOrDefault();
			if ((Object)(object)val == (Object)null)
			{
				Plugin.logger.LogWarning((object)"Angry tried to find canvas, but failed");
				return;
			}
			if ((Object)(object)val.transform.Find("OptionsMenu") == (Object)null)
			{
				Plugin.logger.LogError((object)"Angry tried to find the options menu but failed!");
				return;
			}
			if (SceneHelper.CurrentScene != "Main Menu" && !MonoSingleton<OptionsManager>.Instance.paused)
			{
				MonoSingleton<OptionsManager>.Instance.Pause();
				await Task.Yield();
			}
			MonoSingleton<OptionsManager>.Instance.OpenOptions();
			await Task.Yield();
			NotificationPanel.Open((Notification)(object)new PluginUpdateNotification(json));
		}

		public static async Task CheckForUpdate()
		{
			UnityWebRequest infoReq = new UnityWebRequest(AngryPaths.GetGithubURL(AngryPaths.Repo.AngryLevelLoader, "AngryLevelLoader/PluginInfo.json"));
			infoReq.downloadHandler = (DownloadHandler)new DownloadHandlerBuffer();
			await (AsyncOperation)(object)infoReq.SendWebRequest();
			if ((int)infoReq.result != 1)
			{
				Plugin.logger.LogError((object)"Could not download plugin data");
				infoReq.Dispose();
				ConfigManager.openButtons.SetButtonInteractable(1, true);
				return;
			}
			string text = infoReq.downloadHandler.text;
			int num = text.IndexOf('{');
			if (num > 0)
			{
				text = text.Substring(num);
			}
			PluginInfoJson json = JsonConvert.DeserializeObject<PluginInfoJson>(text);
			uint notification_id;
			if (!Version.TryParse(json.latestVersion, out Version result) || (!(result <= new Version("4.0.3")) && (!Version.TryParse(InternalConfigManager.ignoreUpdateVersion.value, out Version result2) || !(result == result2))))
			{
				await AngryAsyncUtils.WaitUntilSceneLoaded("Main Menu");
				Plugin.logger.LogWarning((object)"Update available, notifying user...");
				Dictionary<string, string> dictionary = new Dictionary<string, string>
				{
					{ "changelog", "View Changelog" },
					{ "remind", "Remind Me Later" },
					{ "ignore", "Ignore" }
				};
				string text2 = "Current: 4.0.3, Latest: " + json.latestVersion;
				Dictionary<string, string> dictionary2 = dictionary;
				notification_id = NotificationSystem.NotifySend("AngryLevelLoader updated!", text2, (Sprite)null, Path.Combine(Plugin.workingDir, "plugin-icon.png"), (Urgency)1, "NotifySend", 0u, dictionary2, -1);
				NotificationSystem.ActionInvoked += OnAction;
				NotificationSystem.NotificationDeleted += OnDeleted;
			}
			void OnAction(uint id, string actionIdentifier)
			{
				if (id == notification_id)
				{
					if (actionIdentifier == "ignore")
					{
						InternalConfigManager.ignoreUpdateVersion.value = json.latestVersion;
					}
					else if (actionIdentifier == "changelog")
					{
						PauseAndShowChangelog(json);
					}
					NotificationSystem.ActionInvoked -= OnAction;
					NotificationSystem.NotificationDeleted -= OnDeleted;
				}
			}
			void OnDeleted(uint id)
			{
				if (id == notification_id)
				{
					NotificationSystem.ActionInvoked -= OnAction;
					NotificationSystem.NotificationDeleted -= OnDeleted;
				}
			}
		}

		public static async Task ShowChangelog()
		{
			UnityWebRequest infoReq = new UnityWebRequest(AngryPaths.GetGithubURL(AngryPaths.Repo.AngryLevelLoader, "AngryLevelLoader/PluginInfo.json"));
			infoReq.downloadHandler = (DownloadHandler)new DownloadHandlerBuffer();
			await (AsyncOperation)(object)infoReq.SendWebRequest();
			if ((int)infoReq.result != 1)
			{
				Plugin.logger.LogError((object)"Could not download plugin data");
				infoReq.Dispose();
				ConfigManager.openButtons.SetButtonInteractable(1, true);
				return;
			}
			string text = infoReq.downloadHandler.text;
			int num = text.IndexOf('{');
			if (num > 0)
			{
				text = text.Substring(num);
			}
			PluginInfoJson json = JsonConvert.DeserializeObject<PluginInfoJson>(text);
			ConfigManager.openButtons.SetButtonInteractable(1, true);
			infoReq.Dispose();
			NotificationPanel.Open((Notification)(object)new PluginUpdateNotification(json));
		}

		public static void Check()
		{
			string path = Path.Combine(Plugin.workingDir, "Levels");
			if (Directory.Exists(path) && !Path.GetFullPath(InternalConfigManager.configDataPath.value).StartsWith(Path.GetFullPath(Plugin.workingDir)))
			{
				Plugin.logger.LogWarning((object)"Version 2.3.0 migration: Moving levels from working dir to data folder");
				string[] files = Directory.GetFiles(path);
				foreach (string text in files)
				{
					string text2 = Path.Combine(Plugin.levelsPath, Path.GetFileName(text));
					if (File.Exists(text2))
					{
						File.Delete(text);
						continue;
					}
					Plugin.logger.LogInfo((object)(text + " => " + text2));
					File.Move(text, text2);
				}
				Directory.Delete(path, recursive: true);
				string path2 = Path.Combine(Plugin.workingDir, "LevelsUnpacked");
				if (Directory.Exists(path2))
				{
					files = Directory.GetDirectories(path2);
					foreach (string text3 in files)
					{
						string text4 = Path.Combine(Plugin.tempFolderPath, Path.GetFileName(text3));
						if (Directory.Exists(text4))
						{
							Directory.Delete(text3, recursive: true);
							continue;
						}
						Plugin.logger.LogInfo((object)(text3 + " => " + text4));
						AngryIOUtils.DirectoryCopy(text3, text4, copySubDirs: true, deleteSource: true);
					}
					Directory.Delete(path2, recursive: true);
				}
			}
			string text5 = Path.Combine(Plugin.workingDir, "OnlineCache");
			if (Directory.Exists(text5))
			{
				Plugin.logger.LogWarning((object)"Moving online cache folder to config (update 2.5.x)");
				string onlineCacheFolderPath = AngryPaths.OnlineCacheFolderPath;
				if (!Directory.Exists(onlineCacheFolderPath))
				{
					AngryIOUtils.TryCreateDirectoryForFile(onlineCacheFolderPath);
					AngryIOUtils.DirectoryCopy(text5, onlineCacheFolderPath, copySubDirs: true, deleteSource: true);
				}
				else
				{
					Directory.Delete(text5, recursive: true);
				}
			}
			string text6 = Path.Combine(Plugin.workingDir, "lastPlayedMap.txt");
			if (File.Exists(text6))
			{
				Plugin.logger.LogWarning((object)"Moving last played map to config (update 2.5.x)");
				string lastPlayedMapPath = AngryPaths.LastPlayedMapPath;
				if (!File.Exists(lastPlayedMapPath))
				{
					AngryIOUtils.TryCreateDirectoryForFile(lastPlayedMapPath);
					File.Move(text6, lastPlayedMapPath);
				}
				else
				{
					File.Delete(text6);
				}
				LastPlayedMapManager.LoadLastPlayedMap();
			}
			if (Version.TryParse(InternalConfigManager.lastVersion.value, out Version result) && result <= new Version("2.7.3"))
			{
				ConfigManager.defaultLeaderboardDifficulty.value = ConfigManager.DefaultLeaderboardDifficulty.Any;
			}
			CheckForUpdate();
			InternalConfigManager.lastVersion.value = "4.0.3";
		}
	}
	public static class PluginInfo
	{
		public const string PLUGIN_GUID = "AngryLevelLoader";

		public const string PLUGIN_NAME = "AngryLevelLoader";

		public const string PLUGIN_VERSION = "4.0.3";
	}
}
namespace AngryLevelLoader.Utils
{
	internal static class AngryAsyncUtils
	{
		public static async Task WaitUntilSceneLoaded(string sceneName)
		{
			TaskCompletionSource<bool> source;
			if (!(SceneHelper.CurrentScene == sceneName))
			{
				source = new TaskCompletionSource<bool>();
				SceneManager.sceneLoaded += ListenSceneEvent;
				await source.Task;
			}
			void ListenSceneEvent(Scene scene, LoadSceneMode mode)
			{
				if (!(SceneHelper.CurrentScene != sceneName))
				{
					source.SetResult(result: true);
					SceneManager.sceneLoaded -= ListenSceneEvent;
				}
			}
		}

		public static async Task LoadSceneAsync(string sceneName, bool noBlocker = false)
		{
			TaskCompletionSource<bool> completionSource = new TaskCompletionSource<bool>();
			CoroutineExtensions.ContinueWith(SceneHelper.LoadSceneAsync(sceneName, noBlocker), (MonoBehaviour)(object)MonoSingleton<SceneHelper>.Instance, (Action)delegate
			{
				completionSource.SetResult(result: true);
			});
			await completionSource.Task;
		}
	}
	internal static class AngryCryptographyUtils
	{
		public static byte[] Encrypt(string data, string keyXml)
		{
			RSA rSA = RSA.Create();
			rSA.FromXmlString(keyXml);
			return rSA.Encrypt(Encoding.UTF8.GetBytes(data), RSAEncryptionPadding.Pkcs1);
		}

		public static byte[] Encrypt(byte[] data, string keyXml)
		{
			RSA rSA = RSA.Create();
			rSA.FromXmlString(keyXml);
			return rSA.Encrypt(data, RSAEncryptionPadding.Pkcs1);
		}

		public static bool VerifyFileCertificate(string filePath, string certificatePath)
		{
			RSA rSA = RSA.Create();
			rSA.FromXmlString("<RSAKeyValue><Modulus>+/ueeOpso05dA+5GjKbjQ0VpM+JAHmRRgYRw36G4dXqmpCGfVDNVdjjBBkVWO+6lJoSNaaG4Yprn4uQVslUQ7OYWAw6Y+9E0Ezvr1quWE7i0KGxG6weplRTsu9aO0/9gJgP/gWQxC0Cf83NwyvMPsThtCruAQFT+cW0LGghtFgrBr++aknI06SJI5ydrbZgEtU5i4FfjrV1ms4CRRojhydJglfGQfG8W3pTDge4jVdND+RGB6F01QGi0+Bnq5DfKdjvb3/Zh1ko7WocWgavDaIgLYj88AgbGdC0lidLMIgzdnGxkLyxbTzsgi/mvUpB2foy4uHoV22EaWMj+6H+oXQ==</Modulus><Exponent>AQAB</Exponent></RSAKeyValue>");
			return rSA.VerifyData(signature: File.ReadAllBytes(certificatePath), data: File.ReadAllBytes(filePath), hashAlgorithm: HashAlgorithmName.SHA256, padding: RSASignaturePadding.Pkcs1);
		}

		private static string ByteArrayToString(byte[] ba)
		{
			return BitConverter.ToString(ba).Replace("-", "");
		}

		public static string GetSHA256Hash(string filePath)
		{
			SHA256 sHA = SHA256.Create();
			sHA.Initialize();
			return ByteArrayToString(sHA.ComputeHash(File.ReadAllBytes(filePath))).ToLower();
		}

		public static string GetMD5String(string text)
		{
			return ByteArrayToString(MD5.Create().ComputeHash(Encoding.ASCII.GetBytes(text))).ToLower();
		}

		public static string GetMD5String(byte[] data)
		{
			return ByteArrayToString(MD5.Create().ComputeHash(data)).ToLower();
		}
	}
	public static class AngryFileUtils
	{
		public static bool TryGetAngryBundleData(string filePath, out AngryBundleData data, out Exception error)
		{
			error = null;
			data = null;
			try
			{
				data = GetAngryBundleData(filePath);
				return true;
			}
			catch (Exception ex)
			{
				error = ex;
			}
			return false;
		}

		private static AngryBundleData GetAngryBundleData(string filePath)
		{
			using FileStream stream = File.Open(filePath, FileMode.Open, FileAccess.Read);
			using ZipArchive zipArchive = new ZipArchive(stream);
			ZipArchiveEntry entry = zipArchive.GetEntry("data.json");
			if (entry == null)
			{
				return null;
			}
			using StreamReader streamReader = new StreamReader(entry.Open());
			return JsonConvert.DeserializeObject<AngryBundleData>(streamReader.ReadToEnd());
		}

		public static bool IsV1LegacyFile(string pathToAngryBundle)
		{
			try
			{
				using FileStream fileStream = File.Open(pathToAngryBundle, FileMode.Open, FileAccess.Read);
				try
				{
					BinaryReader binaryReader = new BinaryReader(fileStream);
					fileStream.Seek(0L, SeekOrigin.Begin);
					int num = binaryReader.ReadInt32();
					if (num * 4 + 4 >= fileStream.Length)
					{
						return false;
					}
					int num2 = 4 + num * 4;
					for (int i = 0; i < num; i++)
					{
						if (num2 >= fileStream.Length)
						{
							break;
						}
						num2 += binaryReader.ReadInt32();
					}
					if (num2 == fileStream.Length)
					{
						return true;
					}
				}
				catch (Exception)
				{
					return false;
				}
			}
			catch (Exception ex2)
			{
				Plugin.logger.LogError((object)ex2);
				return false;
			}
			return false;
		}
	}
	internal static class AngryIOUtils
	{
		private static string _AppData;

		public static string AppData
		{
			get
			{
				if (_AppData != null)
				{
					return _AppData;
				}
				_AppData = Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData);
				Regex regex = new Regex("^[^:]+:\\\\Users\\\\User\\\\AppData\\\\Roaming");
				if (regex.IsMatch(_AppData))
				{
					Plugin.logger.LogWarning((object)("Bad username for AppData (got '" + _AppData + "', expected user '" + Environment.UserName + "'), falling back to local AppData"));
					_AppData = Path.Combine(Directory.GetParent(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData)).FullName, "Roaming");
					if (regex.IsMatch(_AppData) && Environment.UserName != "User")
					{
						Plugin.logger.LogWarning((object)("Bad username for local AppData (got '" + Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData) + "', expected user '" + Environment.UserName + "'), falling back to absolute path"));
						char c = ((_AppData.Length > 0) ? _AppData[0] : 'C');
						_AppData = $"{c}:\\Users\\{Environment.UserName}\\AppData\\Roaming";
					}
				}
				return _AppData;
			}
		}

		public static string GetUniqueFileName(string folder, string name)
		{
			string fileNameWithoutExtension = Path.GetFileNameWithoutExtension(name);
			string text = fileNameWithoutExtension;
			string extension = Path.GetExtension(name);
			int num = 0;
			while (File.Exists(Path.Combine(folder, text + extension)))
			{
				text = $"{fileNameWithoutExtension}_{num++}";
			}
			return text + extension;
		}

		public static string GetUniqueFileName(string path)
		{
			return Path.Combine(Path.GetDirectoryName(path), GetUniqueFileName(Path.GetDirectoryName(path), Path.GetFileName(path)));
		}

		public static string GetPathSafeName(string name)
		{
			StringBuilder stringBuilder = new StringBuilder();
			for (int i = 0; i < name.Length; i++)
			{
				char c = name[i];
				if (!char.IsLetterOrDigit(c))
				{
					switch (c)
					{
					case '-':
					case '_':
						break;
					case ' ':
						if (i > 0 && name[i - 1] != ' ')
						{
							stringBuilder.Append('_');
						}
						continue;
					default:
						continue;
					}
				}
				stringBuilder.Append(c);
			}
			string text = stringBuilder.ToString();
			if (string.IsNullOrEmpty(text))
			{
				return "file";
			}
			return text;
		}

		public static bool TryCreateDirectory(string path)
		{
			if (Directory.Exists(path))
			{
				return false;
			}
			Directory.CreateDirectory(path);
			return true;
		}

		public static bool TryCreateDirectoryForFile(string path)
		{
			return TryCreateDirectory(Path.GetDirectoryName(path));
		}

		public static void DirectoryCopy(string sourceDirName, string destDirName, bool copySubDirs, bool deleteSource)
		{
			DirectoryInfo directoryInfo = new DirectoryInfo(sourceDirName);
			DirectoryInfo[] directories = directoryInfo.GetDirectories();
			if (!directoryInfo.Exists)
			{
				throw new DirectoryNotFoundException("Source directory does not exist or could not be found: " + sourceDirName);
			}
			if (!Directory.Exists(destDirName))
			{
				Directory.CreateDirectory(destDirName);
			}
			FileInfo[] files = directoryInfo.GetFiles();
			foreach (FileInfo fileInfo in files)
			{
				string destFileName = Path.Combine(destDirName, fileInfo.Name);
				if (deleteSource)
				{
					fileInfo.MoveTo(destFileName);
				}
				else
				{
					fileInfo.CopyTo(destFileName, overwrite: false);
				}
			}
			if (copySubDirs)
			{
				DirectoryInfo[] array = directories;
				foreach (DirectoryInfo directoryInfo2 in array)
				{
					string destDirName2 = Path.Combine(destDirName, directoryInfo2.Name);
					DirectoryCopy(directoryInfo2.FullName, destDirName2, copySubDirs, deleteSource);
				}
			}
		}

		public static bool PathEquals(string path1, string path2)
		{
			if (string.IsNullOrEmpty(path1))
			{
				return string.IsNullOrEmpty(path2);
			}
			if (string.IsNullOrEmpty(path2))
			{
				return false;
			}
			return Path.GetFullPath(path1) == Path.GetFullPath(path2);
		}
	}
	public static class AngryRankUtils
	{
		private static Dictionary<char, Color> rankColors = new Dictionary<char, Color>
		{
			{
				'D',
				new Color(0f, 0.5803922f, 1f)
			},
			{
				'C',
				new Color(0.29803923f, 1f, 0f)
			},
			{
				'B',
				new Color(1f, 72f / 85f, 0f)
			},
			{
				'A',
				new Color(1f, 0.41568628f, 0f)
			},
			{
				'S',
				Color.red
			},
			{
				'P',
				Color.white
			},
			{
				'-',
				Color.gray
			},
			{
				' ',
				Color.gray
			}
		};

		public static int GetRankScore(char rank)
		{
			return rank switch
			{
				'D' => 1, 
				'C' => 2, 
				'B' => 3, 
				'A' => 4, 
				'S' => 5, 
				'P' => 6, 
				'-' => -1, 
				' ' => 0, 
				_ => -1, 
			};
		}

		public static char GetRankChar(int score)
		{
			return score switch
			{
				1 => 'D', 
				2 => 'C', 
				3 => 'B', 
				4 => 'A', 
				5 => 'S', 
				6 => 'P', 
				-1 => '-', 
				0 => ' ', 
				_ => '-', 
			};
		}

		public static Color GetRankColor(char rank, Color fallback)
		{
			//IL_0011: 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 (rankColors.TryGetValue(rank, out var value))
			{
				return value;
			}
			return fallback;
		}

		public static string GetFormattedRankText(char rank)
		{
			//IL_001a: 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)
			if (!rankColors.TryGetValue(rank, out var value))
			{
				value = Color.gray;
			}
			return $"<color=#{ColorUtility.ToHtmlStringRGB(value)}>{rank}</color>";
		}
	}
	internal static class AngryUIUtils
	{
		public static void AddMouseEvents(GameObject field, Button btn, Action<BaseEventData> mouseOnEvent, Action<BaseEventData> mouseOffEvent)
		{
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Expected O, but got Unknown
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Expected O, but got Unknown
			EventTrigger val = field.GetComponent<EventTrigger>();
			if ((Object)(object)val == (Object)null)
			{
				val = field.AddComponent<EventTrigger>();
				Utils.AddScrollEvents(val, Utils.GetComponentInParent<ScrollRect>(((Component)btn).transform));
			}
			Entry val2 = new Entry
			{
				eventID = (EventTriggerType)0
			};
			((UnityEvent<BaseEventData>)(object)val2.callback).AddListener((UnityAction<BaseEventData>)delegate(BaseEventData e)
			{
				mouseOnEvent(e);
			});
			Entry val3 = new Entry
			{
				eventID = (EventTriggerType)1
			};
			((UnityEvent<BaseEventData>)(object)val3.callback).AddListener((UnityAction<BaseEventData>)delegate(BaseEventData e)
			{
				mouseOffEvent(e);
			});
			val.triggers.Add(val2);
			val.triggers.Add(val3);
		}
	}
	internal class CachedTask
	{
		private Func<Task> task;

		private Task currentTask;

		public bool Running
		{
			get
			{
				if (currentTask != null)
				{
					return !currentTask.IsCompleted;
				}
				return false;
			}
		}

		public CachedTask(Func<Task> task)
		{
			this.task = task;
		}

		public async Task GetTask(CancellationToken cancellationToken = default(CancellationToken))
		{
			if (!Running)
			{
				currentTask = task();
			}
			await Task.Run(async delegate
			{
				await currentTask;
			}, cancellationToken);
		}
	}
	internal class CachedTask<T>
	{
		private Func<Task<T>> task;

		private Task<T> currentTask;

		public bool Running
		{
			get
			{
				if (currentTask != null)
				{
					return !currentTask.IsCompleted;
				}
				return false;
			}
		}

		public CachedTask(Func<Task<T>> task)
		{
			this.task = task;
		}

		public async Task<T> GetTask(CancellationToken cancellationToken = default(CancellationToken))
		{
			if (!Running)
			{
				currentTask = task();
			}
			return await Task.Run(async () => await currentTask, cancellationToken);
		}
	}
	internal class WordHighlighter
	{
		public List<(int, int)> highlights = new List<(int, int)>();

		public string rawText { get; private set; }

		public WordHighlighter(string text)
		{
			rawText = text;
		}

		public void Highlight(int index, int endIndex)
		{
			int i;
			for (i = 0; i < highlights.Count && index > highlights[i].Item1; i++)
			{
			}
			bool flag = false;
			if (i > 0 && highlights[i - 1].Item2 >= index - 1)
			{
				if (highlights[i - 1].Item2 >= endIndex)
				{
					return;
				}
				index = highlights[i - 1].Item1;
				flag = true;
			}
			int j;
			for (j = 0; i < highlights.Count - j && endIndex >= highlights[i + j].Item1 - 1; j++)
			{
				endIndex = Mathf.Max(endIndex, highlights[i + j].Item2);
			}
			highlights.Insert(i, (index, endIndex));
			for (int k = 0; k < j; k++)
			{
				highlights.RemoveAt(i + 1);
			}
			if (flag)
			{
				highlights.RemoveAt(i - 1);
			}
		}

		public string GenerateFormattedText(string prefix, string postfix)
		{
			if (rawText.Length == 0)
			{
				return string.Empty;
			}
			StringBuilder stringBuilder = new StringBuilder();
			string text = rawText;
			int num = 0;
			foreach (var (num2, num3) in highlights)
			{
				if (num < num2)
				{
					stringBuilder.Append(text.Substring(num, num2 - num));
				}
				stringBuilder.Append(prefix);
				stringBuilder.Append(text.Substring(num2, num3 - num2 + 1));
				stringBuilder.Append(postfix);
				num = num3 + 1;
			}
			if (num < text.Length)
			{
				stringBuilder.Append(text.Substring(num));
			}
			return stringBuilder.ToString();
		}
	}
}
namespace AngryLevelLoader.UserInterface
{
	internal static class AngryBundleList
	{
		private class BundleNameComparer : IComparer<BundleContainer>
		{
			public static readonly BundleNameComparer Instance = new BundleNameComparer();

			public int Compare(BundleContainer b1, BundleContainer b2)
			{
				if (b1 == b2)
				{
					return 0;
				}
				if (b1 == null)
				{
					return 1;
				}
				if (b2 == null)
				{
					return -1;
				}
				if (ConfigManager.bundleFavSort.value)
				{
					if (b1.Favourite && !b2.Favourite)
					{
						return -1;
					}
					if (!b1.Favourite && b2.Favourite)
					{
						return 1;
					}
				}
				return StringComparer.OrdinalIgnoreCase.Compare(richText.Replace(b1.BundleName ?? string.Empty, string.Empty), richText.Replace(b2.BundleName ?? string.Empty, string.Empty));
			}
		}

		private class BundleAuthorComparer : IComparer<BundleContainer>
		{
			public static readonly BundleAuthorComparer Instance = new BundleAuthorComparer();

			public int Compare(BundleContainer b1, BundleContainer b2)
			{
				if (b1 == b2)
				{
					return 0;
				}
				if (b1 == null)
				{
					return 1;
				}
				if (b2 == null)
				{
					return -1;
				}
				if (ConfigManager.bundleFavSort.value)
				{
					if (b1.Favourite && !b2.Favourite)
					{
						return -1;
					}
					if (!b1.Favourite && b2.Favourite)
					{
						return 1;
					}
				}
				return StringComparer.OrdinalIgnoreCase.Compare(richText.Replace(b1.BundleAuthor ?? string.Empty, string.Empty), richText.Replace(b2.BundleAuthor ?? string.Empty, string.Empty));
			}
		}

		private class BundleLastUpdateComparer : IComparer<BundleContainer>
		{
			public static readonly BundleLastUpdateComparer Instance = new BundleLastUpdateComparer();

			public int Compare(BundleContainer b1, BundleContainer b2)
			{
				if (b1 == b2)
				{
					return 0;
				}
				if (b1 == null)
				{
					return 1;
				}
				if (b2 == null)
				{
					return -1;
				}
				if (ConfigManager.bundleFavSort.value)
				{
					if (b1.Favourite && !b2.Favourite)
					{
						return -1;
					}
					if (!b1.Favourite && b2.Favourite)
					{
						return 1;
					}
				}
				if (!LastPlayedMapManager.lastUpdate.TryGetValue(b1.bundleGuid, out var value))
				{
					value = 0L;
				}
				if (!LastPlayedMapManager.lastUpdate.TryGetValue(b2.bundleGuid, out var value2))
				{
					value2 = 0L;
				}
				return -Comparer<long>.Default.Compare(value, value2);
			}
		}

		private class BundleLastPlayedComparer : IComparer<BundleContainer>
		{
			public static readonly BundleLastPlayedComparer Instance = new BundleLastPlayedComparer();

			public int Compare(BundleContainer b1, BundleContainer b2)
			{
				if (b1 == b2)
				{
					return 0;
				}
				if (b1 == null)
				{
					return 1;
				}
				if (b2 == null)
				{
					return -1;
				}
				if (ConfigManager.bundleFavSort.value)
				{
					if (b1.Favourite && !b2.Favourite)
					{
						return -1;
					}
					if (!b1.Favourite && b2.Favourite)
					{
						return 1;
					}
				}
				if (!LastPlayedMapManager.lastPlayed.TryGetValue(b1.bundleGuid, out var value))
				{
					value = 0L;
				}
				if (!LastPlayedMapManager.lastPlayed.TryGetValue(b2.bundleGuid, out var value2))
				{
					value2 = 0L;
				}
				return -Comparer<long>.Default.Compare(value, value2);
			}
		}

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

			public static Func<BundleContainer, BundleContainer> <>9__5_0;

			public static Func<string, bool> <>9__17_0;

			public static Func<string, string> <>9__20_0;

			public static OpenPanelEventDelegate <>9__21_0;

			public static Action <>9__21_2;

			public static Action<bool> <>9__21_3;

			internal BundleContainer <SortBundles>b__5_0(BundleContainer b)
			{
				return b;
			}

			internal bool <UpdateFolderIcons>b__17_0(string path)
			{
				return validImageExts.Contains<string>(Path.GetExtension(path));
			}

			internal string <UpdateBundleSearch>b__20_0(string keyword)
			{
				return keyword.ToLower();
			}

			internal void <Init>b__21_0(bool externally)
			{
				//IL_001b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0025: Expected O, but got Unknown
				//IL_0036: Unknown result type (might be due to invalid IL or missing references)
				//IL_0040: Expected O, but got Unknown
				<>c__DisplayClass21_0 CS$<>8__locals0 = new <>c__DisplayClass21_0
				{
					backButtonEvent = PluginConfiguratorController.backButton.onClick
				};
				PluginConfiguratorController.backButton.onClick = new ButtonClickedEvent();
				((UnityEvent)PluginConfiguratorController.backButton.onClick).AddListener((UnityAction)delegate
				{
					if (displayedFolder == null || displayedFolder == rootFolder || !string.IsNullOrEmpty(ConfigManager.searchBar.value))
					{
						((UnityEvent)CS$<>8__locals0.backButtonEvent).Invoke();
					}
					else
					{
						PopFolder();
					}
				});
			}

			internal void <Init>b__21_2()
			{
				ConfigManager.searchBar.value = "";
			}

			internal void <Init>b__21_3(bool wasCanceled)
			{
				if (wasCanceled)
				{
					if (!string.IsNullOrWhiteSpace(ConfigManager.searchBar.value))
					{
						ConfigManager.searchBar.value = "";
					}
					else if (displayedFolder == null || displayedFolder == rootFolder)
					{
						ConfigManager.config.rootPanel.ClosePanel();
					}
				}
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass21_0
		{
			public ButtonClickedEvent backButtonEvent;

			internal void <Init>b__1()
			{
				if (displayedFolder == null || displayedFolder == rootFolder || !string.IsNullOrEmpty(ConfigManager.searchBar.value))
				{
					((UnityEvent)backButtonEvent).Invoke();
				}
				else
				{
					PopFolder();
				}
			}
		}

		[CompilerGenerated]
		private sealed class <GetAllFolders>d__12 : IEnumerable<FolderButtonField>, IEnumerable, IEnumerator<FolderButtonField>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private FolderButtonField <>2__current;

			private int <>l__initialThreadId;

			private Stack<FolderButtonField> <folders>5__2;

			private FolderButtonField <folder>5__3;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<folders>5__2 = new Stack<FolderButtonField>();
					<folders>5__2.Push(rootFolder);
					break;
				case 1:
					<>1__state = -1;
					foreach (FolderButtonField allSubfolder in <folder>5__3.GetAllSubfolders())
					{
						<folders>5__2.Push(allSubfolder);
					}
					<folder>5__3 = null;
					break;
				}
				if (<folders>5__2.Count != 0)
				{
					<folder>5__3 = <folders>5__2.Pop();
					<>2__current = <folder>5__3;
					<>1__state = 1;
					return true;
				}
				return false;
			}

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

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

			[DebuggerHidden]
			IEnumerator<FolderButtonField> IEnumerable<FolderButtonField>.GetEnumerator()
			{
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					return this;
				}
				return new <GetAllFolders>d__12(0);
			}

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

		private static Regex richText;

		internal static readonly FolderButtonField rootFolder;

		private static string[] validImageExts;

		private static string[] currentSearchKeywords;

		private static char[] whitespaceSeparator;

		internal static FolderButtonField displayedFolder { get; private set; }

		internal static void SortBundles()
		{
			IComparer<BundleContainer> comparer = ConfigManager.bundleSortingMode.value switch
			{
				ConfigManager.BundleSorting.Author => BundleAuthorComparer.Instance, 
				ConfigManager.BundleSorting.LastUpdate => BundleLastUpdateComparer.Instance, 
				ConfigManager.BundleSorting.LastPlayed => BundleLastPlayedComparer.Instance, 
				_ => BundleNameComparer.Instance, 
			};
			int num = 0;
			foreach (BundleContainer item in Plugin.GetAllBundleContainers().OrderBy((BundleContainer b) => b, comparer))
			{
				item.SiblingIndex = num++;
			}
		}

		static AngryBundleList()
		{
			richText = new Regex("<[^>]*>");
			displayedFolder = null;
			validImageExts = new string[3] { ".jpg", ".jpeg", ".png" };
			currentSearchKeywords = new string[0];
			whitespaceSeparator = new char[1] { ' ' };
			ConfigManager.InitializeConfig();
			rootFolder = new FolderButtonField(string.Empty, null);
			((ConfigField)rootFolder).hidden = true;
		}

		[IteratorStateMachine(typeof(<GetAllFolders>d__12))]
		private static IEnumerable<FolderButtonField> GetAllFolders()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <GetAllFolders>d__12(-2);
		}

		internal static void DisplayFolder(FolderButtonField folderField)
		{
			if (folderField == null)
			{
				folderField = rootFolder;
			}
			foreach (BundleContainer allBundleContainer in Plugin.GetAllBundleContainers())
			{
				allBundleContainer.Hidden = true;
			}
			foreach (FolderButtonField allFolder in GetAllFolders())
			{
				((ConfigField)allFolder).hidden = true;
			}
			foreach (BundleContainer bundle in folderField.bundles)
			{
				if (bundle.LazyLoaded)
				{
					bundle.Hidden = false;
				}
			}
			foreach (FolderButtonField allSubfolder in folderField.GetAllSubfolders())
			{
				if (allSubfolder.Any())
				{
					((ConfigField)allSubfolder).hidden = false;
				}
			}
			if (folderField == rootFolder)
			{
				ConfigManager.levelBundlesHeader.text = "Level Bundles";
			}
			else
			{
				ConfigManager.levelBundlesHeader.text = "Level Bundles <color=grey>" + folderField.GetRelativeFolderPath() + "</color>";
			}
			displayedFolder = folderField;
		}

		internal static void ResetFolders()
		{
			foreach (FolderButtonField allFolder in GetAllFolders())
			{
				allFolder.bundles.Clear();
			}
		}

		internal static bool PopFolder()
		{
			if (displayedFolder == null || displayedFolder == rootFolder)
			{
				return false;
			}
			DisplayFolder(displayedFolder.parent ?? rootFolder);
			return true;
		}

		internal static void UpdateFolderIcons()
		{
			foreach (FolderButtonField allFolder in GetAllFolders())
			{
				if (allFolder == rootFolder)
				{
					continue;
				}
				string absoluteFolderPath = allFolder.GetAbsoluteFolderPath(Plugin.levelsPath);
				if (Directory.Exists(absoluteFolderPath))
				{
					string text = (from path in Directory.GetFiles(absoluteFolderPath)
						where validImageExts.Contains<string>(Path.GetExtension(path))
						select path).FirstOrDefault();
					if (!string.IsNullOrEmpty(text))
					{
						allFolder.CreateIcon(text);
						continue;
					}
				}
				allFolder.CreateIcon(allFolder);
			}
		}

		private static void UpdateBundleSearch(string newVal)
		{
			string[] array = (from keyword in newVal.Split(whitespaceSeparator, StringSplitOptions.RemoveEmptyEntries)
				select keyword.ToLower()).ToArray();
			if (array.Length == currentSearchKeywords.Length && array.SequenceEqual(currentSearchKeywords))
			{
				return;
			}
			currentSearchKeywords = array;
			if (currentSearchKeywords.Length == 0)
			{
				((ConfigField)ConfigManager.folderDivision).hidden = false;
				((ConfigField)ConfigManager.searchInfo).hidden = true;
				foreach (BundleContainer allBundleContainer in Plugin.GetAllBundleContainers())
				{
					allBundleContainer.SearchKeywords = new string[0];
				}
				DisplayFolder(displayedFolder);
				return;
			}
			((ConfigField)ConfigManager.folderDivision).hidden = true;
			((ConfigField)ConfigManager.searchInfo).hidden = false;
			int num = 0;
			int num2 = 0;
			foreach (BundleContainer allBundleContainer2 in Plugin.GetAllBundleContainers())
			{
				allBundleContainer2.SearchKeywords = currentSearchKeywords;
				if (allBundleContainer2.HasValidAngryFile)
				{
					num2++;
					if (allBundleContainer2.SearchMatch)
					{
						num++;
					}
				}
			}
			ConfigManager.levelBundlesHeader.text = "Level Bundles";
			ConfigManager.searchInfo.text = $"Showing {num} of {num2} bundles";
		}

		internal static void Init()
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Expected O, but got Unknown
			ConfigManager.InitializeConfig();
			ConfigPanel rootPanel = ConfigManager.config.rootPanel;
			object obj = <>c.<>9__21_0;
			if (obj == null)
			{
				OpenPanelEventDelegate val = delegate
				{
					//IL_001b: Unknown result type (might be due to invalid IL or missing references)
					//IL_0025: Expected O, but got Unknown
					//IL_0036: Unknown result type (might be due to invalid IL or missing references)
					//IL_0040: Expected O, but got Unknown
					ButtonClickedEvent backButtonEvent = PluginConfiguratorController.backButton.onClick;
					PluginConfiguratorController.backButton.onClick = new ButtonClickedEvent();
					((UnityEvent)PluginConfiguratorController.backButton.onClick).AddListener((UnityAction)delegate
					{
						if (displayedFolder == null || displayedFolder == rootFolder || !string.IsNullOrEmpty(ConfigManager.searchBar.value))
						{
							((UnityEvent)backButtonEvent).Invoke();
						}
						else
						{
							PopFolder();
						}
					});
				};
				<>c.<>9__21_0 = val;
				obj = (object)val;
			}
			rootPanel.onPannelOpenEvent += (OpenPanelEventDelegate)obj;
			SearchBarField searchBar = ConfigManager.searchBar;
			searchBar.onValueChange = (Action<string>)Delegate.Combine(searchBar.onValueChange, new Action<string>(UpdateBundleSearch));
			SearchBarField searchBar2 = ConfigManager.searchBar;
			searchBar2.onReset = (Action)Delegate.Combine(searchBar2.onReset, (Action)delegate
			{
				ConfigManager.searchBar.value = "";
			});
			SearchBarField searchBar3 = ConfigManager.searchBar;
			searchBar3.onEndEdit = (Action<bool>)Delegate.Combine(searchBar3.onEndEdit, (Action<bool>)delegate(bool wasCanceled)
			{
				if (wasCanceled)
				{
					if (!string.IsNullOrWhiteSpace(ConfigManager.searchBar.value))
					{
						ConfigManager.searchBar.value = "";
					}
					else if (displayedFolder == null || displayedFolder == rootFolder)
					{
						ConfigManager.config.rootPanel.ClosePanel();
					}
				}
			});
		}
	}
	internal static class AngryCustomLevelButton
	{
		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static Func<GameObject, bool> <>9__4_0;

			public static UnityAction<Scene, LoadSceneMode> <>9__5_0;

			public static PostEnumValueChangeEvent<ConfigManager.CustomLevelButtonPosition> <>9__5_1;

			public static PostColorValueChangeEvent <>9__5_2;

			public static PostColorValueChangeEvent <>9__5_3;

			internal bool <CreateCustomLevelButtonOnMainMenuAsync>b__4_0(GameObject obj)
			{
				return ((Object)obj).name == "Canvas";
			}

			internal void <Init>b__5_0(Scene scene, LoadSceneMode mode)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_0002: Invalid comparison between Unknown and I4
				if ((int)mode != 1 && SceneHelper.CurrentScene == "Main Menu")
				{
					CreateCustomLevelButtonOnMainMenu();
				}
			}

			internal void <Init>b__5_1(ConfigManager.CustomLevelButtonPosition pos)
			{
				//IL_00a1: 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_00c4: Unknown result type (might be due to invalid IL or missing references)
				//IL_005e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0077: Unknown result type (might be due to invalid IL or missing references)
				//IL_0081: Unknown result type (might be due to invalid IL or missing references)
				//IL_0195: Unknown result type (might be due to invalid IL or missing references)
				//IL_01b8: Unknown result type (might be due to invalid IL or missing references)
				//IL_01cc: Unknown result type (might be due to invalid IL or missing references)
				//IL_01d6: Unknown result type (might be due to invalid IL or missing references)
				//IL_01ef: Unknown result type (might be due to invalid IL or missing references)
				//IL_0212: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
				//IL_011c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0130: Unknown result type (might be due to invalid IL or missing references)
				//IL_013a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0153: Unknown result type (might be due to invalid IL or missing references)
				//IL_0176: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)currentCustomLevelButton == (Object)null)
				{
					return;
				}
				((Component)currentCustomLevelButton).gameObject.SetActive(true);
				switch (pos)
				{
				case ConfigManager.CustomLevelButtonPosition.Disabled:
					((Component)currentCustomLevelButton).gameObject.SetActive(false);
					break;
				case ConfigManager.CustomLevelButtonPosition.Bottom:
					((Component)currentCustomLevelButton).transform.localPosition = new Vector3(((Component)currentCustomLevelButton).transform.localPosition.x, -303f, ((Component)currentCustomLevelButton).transform.localPosition.z);
					break;
				case ConfigManager.CustomLevelButtonPosition.Top:
					((Component)currentCustomLevelButton).transform.localPosition = new Vector3(((Component)currentCustomLevelButton).transform.localPosition.x, 192f, ((Component)currentCustomLevelButton).transform.localPosition.z);
					break;
				}
				if ((Object)(object)bossRushButton != (Object)null)
				{
					if (pos == ConfigManager.CustomLevelButtonPosition.Bottom)
					{
						currentCustomLevelButton.rect.sizeDelta = new Vector2(187.5f, 50f);
						((Component)currentCustomLevelButton).transform.localPosition = new Vector3(-96.25f, ((Component)currentCustomLevelButton).transform.localPosition.y, ((Component)currentCustomLevelButton).transform.localPosition.z);
						bossRushButton.sizeDelta = new Vector2(187.5f, 50f);
						((Component)bossRushButton).transform.localPosition = new Vector3(96.25f, -303f, 0f);
					}
					else
					{
						currentCustomLevelButton.rect.sizeDelta = new Vector2(380f, 50f);
						((Component)currentCustomLevelButton).transform.localPosition = new Vector3(0f, ((Component)currentCustomLevelButton).transform.localPosition.y, ((Component)currentCustomLevelButton).transform.localPosition.z);
						bossRushButton.sizeDelta = new Vector2(380f, 50f);
						((Component)bossRushButton).transform.localPosition = new Vector3(0f, -303f, 0f);
					}
				}
			}

			internal void <Init>b__5_2(Color clr)
			{
				//IL_0010: Unknown result type (might be due to invalid IL or missing references)
				//IL_0030: Unknown result type (might be due to invalid IL or missing references)
				//IL_0038: Unknown result type (might be due to invalid IL or missing references)
				//IL_003e: Unknown result type (might be due to invalid IL or missing references)
				//IL_004a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0050: Unknown result type (might be due to invalid IL or missing references)
				//IL_005c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0062: Unknown result type (might be due to invalid IL or missing references)
				//IL_006e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0082: Unknown result type (might be due to invalid IL or missing references)
				if (!((Object)(object)currentCustomLevelButton == (Object)null))
				{
					ColorBlock colors = default(ColorBlock);
					((ColorBlock)(ref colors)).colorMultiplier = 1f;
					((ColorBlock)(ref colors)).fadeDuration = 0.1f;
					((ColorBlock)(ref colors)).normalColor = clr;
					((ColorBlock)(ref colors)).selectedColor = clr * 0.8f;
					((ColorBlock)(ref colors)).highlightedColor = clr * 0.8f;
					((ColorBlock)(ref colors)).pressedColor = clr * 0.5f;
					((ColorBlock)(ref colors)).disabledColor = Color.gray;
					((Selectable)currentCustomLevelButton.button).colors = colors;
				}
			}

			internal void <Init>b__5_3(Color clr)
			{
				//IL_0018: Unknown result type (might be due to invalid IL or missing references)
				if (!((Object)(object)currentCustomLevelButton == (Object)null))
				{
					((Graphic)currentCustomLevelButton.text).color = clr;
				}
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass4_0
		{
			public GameObject canvasObj;

			public Transform chapterSelect;

			internal void <CreateCustomLevelButtonOnMainMenuAsync>b__1()
			{
				//IL_013d: Unknown result type (might be due to invalid IL or missing references)
				Transform val = canvasObj.transform.Find("OptionsMenu");
				if ((Object)(object)val == (Object)null)
				{
					Plugin.logger.LogError((object)"Angry tried to find the options menu but failed!");
					return;
				}
				((Component)chapterSelect).gameObject.SetActive(false);
				((Component)val).gameObject.SetActive(true);
				Transform val2 = ((Component)val).transform.Find("Navigation Rail/PluginConfiguratorButton(Clone)");
				if ((Object)(object)val2 == (Object)null)
				{
					val2 = ((Component)val).transform.Find("Navigation Rail/PluginConfiguratorButton");
				}
				if ((Object)(object)val2 == (Object)null)
				{
					Plugin.logger.LogError((object)"Angry tried to find the plugin configurator button but failed!");
					return;
				}
				Transform val3 = val.Find("Navigation Rail");
				ButtonHighlightParent val4 = default(ButtonHighlightParent);
				if ((Object)(object)val3 != (Object)null && ((Component)val3).gameObject.TryGetComponent<ButtonHighlightParent>(ref val4) && (val4.buttons == null || val4.buttons.Length == 0))
				{
					val4.Start();
					val4.targetOnStart = null;
				}
				((UnityEvent)((Component)val2).gameObject.GetComponent<Button>().onClick).Invoke();
				if ((Object)(object)PluginConfiguratorController.activePanel != (Object)null)
				{
					PluginConfiguratorController.activePanel.SetActive(false);
				}
				((Component)PluginConfiguratorController.mainPanel).gameObject.SetActive(false);
				ConfigManager.config.rootPanel.OpenPanelInternally(false);
				ConfigManager.config.rootPanel.currentPanel.rect.normalizedPosition = new Vector2(0f, 1f);
				AngryDifficultyManager.SetDifficultyFromPrefs();
			}
		}

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

			private object <>2__current;

			private <>c__DisplayClass4_0 <>8__1;

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

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

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

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

			private bool MoveNext()
			{
				//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_00f2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
				//IL_0139: Unknown result type (might be due to invalid IL or missing references)
				//IL_0143: Expected O, but got Unknown
				//IL_015e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0168: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>8__1 = new <>c__DisplayClass4_0();
					<>2__current = null;
					<>1__state = 1;
					return true;
				case 1:
				{
					<>1__state = -1;
					<>c__DisplayClass4_0 <>c__DisplayClass4_ = <>8__1;
					Scene activeScene = SceneManager.GetActiveScene();
					<>c__DisplayClass4_.canvasObj = (from obj in ((Scene)(ref activeScene)).GetRootGameObjects()
						where ((Object)obj).name == "Canvas"
						select obj).FirstOrDefault();
					if ((Object)(object)<>8__1.canvasObj == (Object)null)
					{
						Plugin.logger.LogWarning((object)"Angry tried to create main menu buttons, but root canvas was not found!");
						return false;
					}
					Transform val = <>8__1.canvasObj.transform.Find("Chapter Select/Chapters");
					if ((Object)(object)val != (Object)null)
					{
						<>8__1.chapterSelect = <>8__1.canvasObj.transform.Find("Chapter Select");
						GameObject obj2 = Addressables.InstantiateAsync((object)"AngryLevelLoader/UI/CustomLevels.prefab", val, false, true).WaitForCompletion();
						Transform val2 = val.Find("Boss Rush Button");
						if ((Object)(object)val2 != (Object)null)
						{
							bossRushButton = ((Component)val2).gameObject.GetComponent<RectTransform>();
						}
						currentCustomLevelButton = obj2.GetComponent<AngryCustomLevelButtonComponent>();
						currentCustomLevelButton.button.onClick = new ButtonClickedEvent();
						((UnityEvent)currentCustomLevelButton.button.onClick).AddListener((UnityAction)delegate
						{
							//IL_013d: Unknown result type (might be due to invalid IL or missing references)
							Transform val3 = <>8__1.canvasObj.transform.Find("OptionsMenu");
							if ((Object)(object)val3 == (Object)null)
							{
								Plugin.logger.LogError((object)"Angry tried to find the options menu but failed!");
							}
							else
							{
								((Component)<>8__1.chapterSelect).gameObject.SetActive(false);
								((Component)val3).gameObject.SetActive(true);
								Transform val4 = ((Component)val3).transform.Find("Navigation Rail/PluginConfiguratorButton(Clone)");
								if ((Object)(object)val4 == (Object)null)
								{
									val4 = ((Component)val3).transform.Find("Navigation Rail/PluginConfiguratorButton");
								}
								if ((Object)(object)val4 == (Object)null)
								{
									Plugin.logger.LogError((object)"Angry tried to find the plugin configurator button but failed!");
								}
								else
								{
									Transform val5 = val3.Find("Navigation Rail");
									ButtonHighlightParent val6 = default(ButtonHighlightParent);
									if ((Object)(object)val5 != (Object)null && ((Component)val5).gameObject.TryGetComponent<ButtonHighlightParent>(ref val6) && (val6.buttons == null || val6.buttons.Length == 0))
									{
										val6.Start();
										val6.targetOnStart = null;
									}
									((UnityEvent)((Component)val4).gameObject.GetComponent<Button>().onClick).Invoke();
									if ((Object)(object)PluginConfiguratorController.activePanel != (Object)null)
									{
										PluginConfiguratorController.activePanel.SetActive(false);
									}
									((Component)PluginConfiguratorController.mainPanel).gameObject.SetActive(false);
									ConfigManager.config.rootPanel.OpenPanelInternally(false);
									ConfigManager.config.rootPanel.currentPanel.rect.normalizedPosition = new Vector2(0f, 1f);
									AngryDifficultyManager.SetDifficultyFromPrefs();
								}
							}
						});
						ConfigManager.customLevelButtonPosition.TriggerPostValueChangeEvent();
						ConfigManager.customLevelButtonFrameColor.TriggerPostValueChangeEvent();
						ConfigManager.customLevelButtonTextColor.TriggerPostValueChangeEvent();
					}
					else
					{
						Plugin.logger.LogWarning((object)"Angry tried to find chapter select menu, but root canvas was not found!");
					}
					return false;
				}
				}
			}

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

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

		internal const string CUSTOM_LEVEL_BUTTON_ASSET_PATH = "AngryLevelLoader/UI/CustomLevels.prefab";

		internal static AngryCustomLevelButtonComponent currentCustomLevelButton;

		internal static RectTransform bossRushButton;

		private static void CreateCustomLevelButtonOnMainMenu()
		{
			((MonoBehaviour)Plugin.instance).StartCoroutine(CreateCustomLevelButtonOnMainMenuAsync());
		}

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

		internal static void Init()
		{
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Expected O, but got Unknown
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Expected O, but got Unknown
			SceneManager.sceneLoaded += delegate(Scene scene, LoadSceneMode mode)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_0002: Invalid comparison between Unknown and I4
				if ((int)mode != 1 && SceneHelper.CurrentScene == "Main Menu")
				{
					CreateCustomLevelButtonOnMainMenu();
				}
			};
			ConfigManager.InitializeConfig();
			ConfigManager.customLevelButtonPosition.postValueChangeEvent += delegate(ConfigManager.CustomLevelButtonPosition pos)
			{
				//IL_00a1: 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_00c4: Unknown result type (might be due to invalid IL or missing references)
				//IL_005e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0077: Unknown result type (might be due to invalid IL or missing references)
				//IL_0081: Unknown result type (might be due to invalid IL or missing references)
				//IL_0195: Unknown result type (might be due to invalid IL or missing references)
				//IL_01b8: Unknown result type (might be due to invalid IL or missing references)
				//IL_01cc: Unknown result type (might be due to invalid IL or missing references)
				//IL_01d6: Unknown result type (might be due to invalid IL or missing references)
				//IL_01ef: Unknown result type (might be due to invalid IL or missing references)
				//IL_0212: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
				//IL_011c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0130: Unknown result type (might be due to invalid IL or missing references)
				//IL_013a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0153: Unknown result type (might be due to invalid IL or missing references)
				//IL_0176: Unknown result type (might be due to invalid IL or missing references)
				if (!((Object)(object)currentCustomLevelButton == (Object)null))
				{
					((Component)currentCustomLevelButton).gameObject.SetActive(true);
					switch (pos)
					{
					case ConfigManager.CustomLevelButtonPosition.Disabled:
						((Component)currentCustomLevelButton).gameObject.SetActive(false);
						break;
					case ConfigManager.CustomLevelButtonPosition.Bottom:
						((Component)currentCustomLevelButton).transform.localPosition = new Vector3(((Component)currentCustomLevelButton).transform.localPosition.x, -303f, ((Component)currentCustomLevelButton).transform.localPosition.z);
						break;
					case ConfigManager.CustomLevelButtonPosition.Top:
						((Component)currentCustomLevelButton).transform.localPosition = new Vector3(((Component)currentCustomLevelButton).transform.localPosition.x, 192f, ((Component)currentCustomLevelButton).transform.localPosition.z);
						break;
					}
					if ((Object)(object)bossRushButton != (Object)null)
					{
						if (pos == ConfigManager.CustomLevelButtonPosition.Bottom)
						{
							currentCustomLevelButton.rect.sizeDelta = new Vector2(187.5f, 50f);
							((Component)currentCustomLevelButton).transform.localPosition = new Vector3(-96.25f, ((Component)currentCustomLevelButton).transform.localPosition.y, ((Component)currentCustomLevelButton).transform.localPosition.z);
							bossRushButton.sizeDelta = new Vector2(187.5f, 50f);
							((Component)bossRushButton).transform.localPosition = new Vector3(96.25f, -303f, 0f);
						}
						else
						{
							currentCustomLevelButton.rect.sizeDelta = new Vector2(380f, 50f);
							((Component)currentCustomLevelButton).transform.localPosition = new Vector3(0f, ((Component)currentCustomLevelButton).transform.localPosition.y, ((Component)currentCustomLevelButton).transform.localPosition.z);
							bossRushButton.sizeDelta = new Vector2(380f, 50f);
							((Component)bossRushButton).transform.localPosition = new Vector3(0f, -303f, 0f);
						}
					}
				}
			};
			ColorField customLevelButtonFrameColor = ConfigManager.customLevelButtonFrameColor;
			object obj = <>c.<>9__5_2;
			if (obj == null)
			{
				PostColorValueChangeEvent val = delegate(Color clr)
				{
					//IL_0010: Unknown result type (might be due to invalid IL or missing references)
					//IL_0030: Unknown result type (might be due to invalid IL or missing references)
					//IL_0038: Unknown result type (might be due to invalid IL or missing references)
					//IL_003e: Unknown result type (might be due to invalid IL or missing references)
					//IL_004a: Unknown result type (might be due to invalid IL or missing references)
					//IL_0050: Unknown result type (might be due to invalid IL or missing references)
					//IL_005c: Unknown result type (might be due to invalid IL or missing references)
					//IL_0062: Unknown result type (might be due to invalid IL or missing references)
					//IL_006e: Unknown result type (might be due to invalid IL or missing references)
					//IL_0082: Unknown result type (might be due to invalid IL or missing references)
					if (!((Object)(object)currentCustomLevelButton == (Object)null))
					{
						ColorBlock colors = default(ColorBlock);
						((ColorBlock)(ref colors)).colorMultiplier = 1f;
						((ColorBlock)(ref colors)).fadeDuration = 0.1f;
						((ColorBlock)(ref colors)).normalColor = clr;
						((ColorBlock)(ref colors)).selectedColor = clr * 0.8f;
						((ColorBlock)(ref colors)).highlightedColor = clr * 0.8f;
						((ColorBlock)(ref colors)).pressedColor = clr * 0.5f;
						((ColorBlock)(ref colors)).disabledColor = Color.gray;
						((Selectable)currentCustomLevelButton.button).colors = colors;
					}
				};
				<>c.<>9__5_2 = val;
				obj = (object)val;
			}
			customLevelButtonFrameColor.postValueChangeEvent += (PostColorValueChangeEvent)obj;
			ColorField customLevelButtonTextColor = ConfigManager.customLevelButtonTextColor;
			object obj2 = <>c.<>9__5_3;
			if (obj2 == null)
			{
				PostColorValueChangeEvent val2 = delegate(Color clr)
				{
					//IL_0018: Unknown result type (might be due to invalid IL or missing references)
					if (!((Object)(object)currentCustomLevelButton == (Object)null))
					{
						((Graphic)currentCustomLevelButton.text).color = clr;
					}
				};
				<>c.<>9__5_3 = val2;
				obj2 = (object)val2;
			}
			customLevelButtonTextColor.postValueChangeEvent += (PostColorValueChangeEvent)obj2;
		}
	}
	internal static class AngryUI
	{
		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static Func<GameObject, bool> <>9__3_0;

			public static UnityAction <>9__5_0;

			public static UnityAction <>9__5_1;

			public static UnityAction <>9__6_0;

			public static UnityAction <>9__6_1;

			public static UnityAction<Scene, LoadSceneMode> <>9__12_0;

			internal bool <CreateAngryUIAsync>b__3_0(GameObject obj)
			{
				return ((Object)obj).name == "Canvas";
			}

			internal void <ShowReloadScriptPrompt>b__5_0()
			{
				ReloadScript();
			}

			internal void <ShowReloadScriptPrompt>b__5_1()
			{
				//IL_000f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0019: Expected O, but got Unknown
				currentPanel.reloadScriptPrompt.reloadButton.onClick = new ButtonClickedEvent();
				((Component)currentPanel.reloadScriptPrompt).gameObject.SetActive(false);
				UpdatedScript = string.Empty;
			}

			internal void <ShowReloadBundlePrompt>b__6_0()
			{
				AngrySceneManager.currentBundleContainer.ReloadBundle(forceReload: false, lazyLoad: false);
			}

			internal void <ShowReloadBundlePrompt>b__6_1()
			{
				//IL_001a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0024: Expected O, but got Unknown
				AngrySceneManager.currentBundleContainer.IgnoreFileChange = true;
				currentPanel.reloadBundlePrompt.reloadButton.onClick = new ButtonClickedEvent();
				((Component)currentPanel.reloadBundlePrompt).gameObject.SetActive(false);
			}

			internal void <Init>b__12_0(Scene scene, LoadSceneMode mode)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_0002: Invalid comparison between Unknown and I4
				if ((int)mode != 1 && AngrySceneManager.isInCustomLevel)
				{
					Plugin.logger.LogInfo((object)"Creating UI panel");
					CreateAngryUI();
				}
			}
		}

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

			private object <>2__current;

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

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

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

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

			private bool MoveNext()
			{
				//IL_003d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0042: Unknown result type (might be due to invalid IL or missing references)
				//IL_009b: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = null;
					<>1__state = 1;
					return true;
				case 1:
				{
					<>1__state = -1;
					if ((Object)(object)currentPanel != (Object)null)
					{
						return false;
					}
					Scene activeScene = SceneManager.GetActiveScene();
					GameObject val = (from obj in ((Scene)(ref activeScene)).GetRootGameObjects()
						where ((Object)obj).name == "Canvas"
						select obj).FirstOrDefault();
					if ((Object)(object)val == (Object)null)
					{
						Plugin.logger.LogWarning((object)"Angry tried to create main menu buttons, but root canvas was not found!");
						return false;
					}
					currentPanel = Addressables.InstantiateAsync((object)"AngryLevelLoader/UI/AngryUIPanel.prefab", val.transform, false, true).WaitForCompletion().GetComponent<AngryUIPanelComponent>();
					currentPanel.reloadBundlePrompt.MakeTransparent(true);
					currentPanel.reloadScriptPrompt.MakeTransparent(true);
					if (AngrySceneManager.currentBundleContainer.FileChangeDetected && !AngrySceneManager.currentBundleContainer.IgnoreFileChange)
					{
						ShowReloadBundlePrompt();
						return false;
					}
					if (!string.IsNullOrEmpty(UpdatedScript))
					{
						ShowReloadScriptPrompt();
						return false;
					}
					return false;
				}
				}
			}

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

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

		private const string ANGRY_UI_PANEL_ASSET_PATH = "AngryLevelLoader/UI/AngryUIPanel.prefab";

		private static AngryUIPanelComponent currentPanel;

		private static string _updatedScript = string.Empty;

		internal static string UpdatedScript
		{
			get
			{
				return _updatedScript;
			}
			set
			{
				_updatedScript = value;
				if ((Object)(object)currentPanel != (Object)null && !string.IsNullOrEmpty(_updatedScript))
				{
					ShowReloadScriptPrompt();
				}
			}
		}

		private static void CreateAngryUI()
		{
			((MonoBehaviour)Plugin.instance).StartCoroutine(CreateAngryUIAsync());
		}

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

		internal static void ReloadScript()
		{
			if (string.IsNullOrEmpty(UpdatedScript))
			{
				return;
			}
			if (AngrySceneManager.isInCustomLevel)
			{
				InternalConfigManager.instantLoadLevel.value = true;
				InternalConfigManager.instantLoadLevelGuid.value = AngrySceneManager.currentBundleContainer.bundleGuid;
				InternalConfigManager.instantLoadLevelId.value = AngrySceneManager.currentLevelContainer.levelId;
			}
			PluginConfiguratorController.FlushAllConfigs();
			ProcessStartInfo processStartInfo = new ProcessStartInfo
			{
				FileName = Path.Combine(Directory.GetParent(Application.dataPath).FullName, "ULTRAKILL.exe"),
				WorkingDirectory = Directory.GetParent(Application.dataPath).FullName,
				UseShellExecute = false,
				RedirectStandardError = true,
				RedirectStandardOutput = true
			};
			foreach (string item in Environment.GetCommandLineArgs().Skip(1))
			{
				processStartInfo.ArgumentList.Add(item);
			}
			string[] array = new string[7] { "DOORSTOP_DISABLE", "DOORSTOP_DLL_SEARCH_DIRS", "DOORSTOP_INITIALIZED", "DOORSTOP_INVOKE_DLL_PATH", "DOORSTOP_MANAGED_FOLDER_DIR", "DOORSTOP_MONO_LIB_PATH", "DOORSTOP_PROCESS_PATH" };
			foreach (string key in array)
			{
				if (processStartInfo.EnvironmentVariables.ContainsKey(key))
				{
					processStartInfo.EnvironmentVariables.Remove(key);
				}
				if (processStartInfo.Environment.ContainsKey(key))
				{
					processStartInfo.Environment.Remove(key);
				}
			}
			Process.Start(processStartInfo);
			Application.Quit();
		}

		private static void ShowReloadScriptPrompt()
		{
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Expected O, but got Unknown
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Expected O, but got Unknown
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Expected O, but got Unknown
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Expected O, but got Unknown
			if ((Object)(object)currentPanel == (Object)null || !AngrySceneManager.isInCustomLevel || string.IsNullOrEmpty(UpdatedScript) || ((Component)currentPanel.reloadScriptPrompt).gameObject.activeSelf)
			{
				return;
			}
			((Component)currentPanel.reloadBundlePrompt).gameObject.SetActive(false);
			((Component)currentPanel.reloadScriptPrompt).gameObject.SetActive(true);
			currentPanel.reloadScriptPrompt.audio.Play();
			currentPanel.reloadScriptPrompt.text.text = $"Script update detected\nPress <color=orange>{ConfigManager.reloadScriptKeybind.value}</color> to reload\n(Can be binded in the settings)";
			currentPanel.reloadScriptPrompt.reloadButton.onClick = new ButtonClickedEvent();
			ButtonClickedEvent onClick = currentPanel.reloadScriptPrompt.reloadButton.onClick;
			object obj = <>c.<>9__5_0;
			if (obj == null)
			{
				UnityAction val = delegate
				{
					ReloadScript();
				};
				<>c.<>9__5_0 = val;
				obj = (object)val;
			}
			((UnityEvent)onClick).AddListener((UnityAction)obj);
			currentPanel.reloadScriptPrompt.ignoreButton.onClick = new ButtonClickedEvent();
			ButtonClickedEvent onClick2 = currentPanel.reloadScriptPrompt.ignoreButton.onClick;
			object obj2 = <>c.<>9__5_1;
			if (obj2 == null)
			{
				UnityAction val2 = delegate
				{
					//IL_000f: Unknown result type (might be due to invalid IL or missing references)
					//IL_0019: Expected O, but got Unknown
					currentPanel.reloadScriptPrompt.reloadButton.onClick = new ButtonClickedEvent();
					((Component)currentPanel.reloadScriptPrompt).gameObject.SetActive(false);
					UpdatedScript = string.Empty;
				};
				<>c.<>9__5_1 = val2;
				obj2 = (object)val2;
			}
			((UnityEvent)onClick2).AddListener((UnityAction)obj2);
		}

		internal static void ShowReloadBundlePrompt()
		{
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Expected O, but got Unknown
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Expected O, but got Unknown
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Expected O, but got Unknown
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			//IL_012d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0133: Expected O, but got Unknown
			if ((Object)(object)currentPanel == (Object)null || !AngrySceneManager.isInCustomLevel || ((Component)currentPanel.reloadBundlePrompt).gameObject.activeSelf)
			{
				return;
			}
			((Component)currentPanel.reloadScriptPrompt).gameObject.SetActive(false);
			((Component)currentPanel.reloadBundlePrompt).gameObject.SetActive(true);
			currentPanel.reloadBundlePrompt.audio.Play();
			currentPanel.reloadBundlePrompt.text.text = $"File update detected\nPress <color=orange>{ConfigManager.reloadFileKeybind.value}</color> to reload\n(Can be binded in the settings)";
			currentPanel.reloadBundlePrompt.reloadButton.onClick = new ButtonClickedEvent();
			ButtonClickedEvent onClick = currentPanel.reloadBundlePrompt.reloadButton.onClick;
			object obj = <>c.<>9__6_0;
			if (obj == null)
			{
				UnityAction val = delegate
				{
					AngrySceneManager.currentBundleContainer.ReloadBundle(forceReload: false, lazyLoad: false);
				};
				<>c.<>9__6_0 = val;
				obj = (object)val;
			}
			((UnityEvent)onClick).AddListener((UnityAction)obj);
			currentPanel.reloadBundlePrompt.ignoreButton.onClick = new ButtonClickedEvent();
			ButtonClickedEvent onClick2 = currentPanel.reloadBundlePrompt.ignoreButton.onClick;
			object obj2 = <>c.<>9__6_1;
			if (obj2 == null)
			{
				UnityAction val2 = delegate
				{
					//IL_001a: Unknown result type (might be due to invalid IL or missing references)
					//IL_0024: Expected O, but got Unknown
					AngrySceneManager.currentBundleContainer.IgnoreFileChange = true;
					currentPanel.reloadBundlePrompt.reloadButton.onClick = new ButtonClickedEvent();
					((Component)currentPanel.reloadBundlePrompt).gameObject.SetActive(false);
				};
				<>c.<>9__6_1 = val2;
				obj2 = (object)val2;
			}
			((UnityEvent)onClick2).AddListener((UnityAction)obj2);
		}

		internal static void MakeTransparent(bool transparent)
		{
			if ((Object)(object)currentPanel != (Object)null)
			{
				if (transparent)
				{
					currentPanel.reloadBundlePrompt.MakeTransparent(false);
					currentPanel.reloadScriptPrompt.MakeTransparent(false);
				}
				else
				{
					currentPanel.reloadBundlePrompt.MakeOpaque(false);
					currentPanel.reloadScriptPrompt.MakeOpaque(false);
				}
			}
		}

		internal static void Init()
		{
			SceneManager.sceneLoaded += delegate(Scene scene, LoadSceneMode mode)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_0002: Invalid comparison between Unknown and I4
				if ((int)mode != 1 && AngrySceneManager.isInCustomLevel)
				{
					Plugin.logger.LogInfo((object)"Creating UI panel");
					CreateAngryUI();
				}
			};
		}
	}
	public static class OnlineLevelsList
	{
		public enum SortFilter
		{
			Name,
			Author,
			Votes,
			LastUpdate,
			ReleaseDate
		}

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

			public static PostEnumValueChangeEvent<SortFilter> <>9__14_0;

			public static PostBoolValueChangeEvent <>9__14_1;

			public static PostBoolValueChangeEvent <>9__14_2;

			public static PostBoolValueChangeEvent <>9__14_3;

			public static Func<string, string> <>9__14_6;

			public static Func<OnlineLevelField, bool> <>9__14_7;

			public static Action<string> <>9__14_4;

			public static Action<bool> <>9__14_8;

			public static Action <>9__14_5;

			public static Func<OnlineLevelField, string> <>9__16_0;

			public static Func<OnlineLevelField, string> <>9__16_1;

			public static Func<OnlineLevelField, int> <>9__16_2;

			public static Func<OnlineLevelField, long> <>9__16_3;

			public static Action<Task<AngryUser.UserInfoResult>> <>9__26_1;

			public static Func<OnlineLevelField, bool> <>9__30_0;

			public static Func<BundleInfo, string> <>9__31_1;

			public static Func<string, bool> <>9__31_3;

			public static Func<string, string> <>9__31_4;

			internal void <Init>b__14_0(SortFilter val)
			{
				SortAll();
			}

			internal void <Init>b__14_1(bool val)
			{
				UpdateVisibility();
			}

			internal void <Init>b__14_2(bool val)
			{
				UpdateVisibility();
			}

			internal void <Init>b__14_3(bool val)
			{
				UpdateVisibility();
			}

			internal void <Init>b__14_4(string newVal)
			{
				string[] array = (from e in newVal.Split(new char[1] { ' ' }, StringSplitOptions.RemoveEmptyEntries)
					select e.ToLower()).ToArray();
				if (array.Length == searchKeywords.Length && array.SequenceEqual(searchKeywords))
				{
					return;
				}
				searchKeywords = array;
				foreach (OnlineLevelField value in onlineLevels.Values)
				{
					value.SearchKeywords = searchKeywords;
				}
				UpdateVisibility();
				if (searchKeywords.Length == 0)
				{
					((ConfigField)searchInfo).hidden = true;
					return;
				}
				((ConfigField)searchInfo).hidden = false;
				searchInfo.text = $"Showing {onlineLevels.Values.Where((OnlineLevelField e) => !((ConfigField)e).hidden).Count()} of {OnlineCatalogManager.Catalog.Levels.Count} bundles";
			}

			internal string <Init>b__14_6(string e)
			{
				return e.ToLower();
			}

			internal bool <Init>b__14_7(OnlineLevelField e)
			{
				return !((ConfigField)e).hidden;
			}

			internal void <Init>b__14_8(bool wasCanceled)
			{
				if (wasCanceled)
				{
					if (!string.IsNullOrWhiteSpace(searchBar.value))
					{
						searchBar.value = "";
					}
					else
					{
						ConfigManager.config.rootPanel.OpenPanel();
					}
				}
			}

			internal void <Init>b__14_5()
			{
				searchBar.value = "";
			}

			internal string <SortAll>b__16_0(OnlineLevelField b)
			{
				return richText.Replace(b.OnlineBundle.Name, string.Empty);
			}

			internal string <SortAll>b__16_1(OnlineLevelField b)
			{
				return richText.Replace(b.OnlineBundle.Author, string.Empty);
			}

			internal int <SortAll>b__16_2(OnlineLevelField b)
			{
				return b.VoteCount;
			}

			internal long <SortAll>b__16_3(OnlineLevelField b)
			{
				return b.OnlineBundle.LastUpdate;
			}

			internal void <RefreshTask>b__26_1(Task<AngryUser.UserInfoResult> task)
			{
				if (task.Result != null)
				{
					AngryUser.UserInfoResult result = task.Result;
					if (!result.completedSuccessfully || result.status != 0)
					{
						Plugin.logger.LogError((object)("Failed to get user info : " + (result.networkError ? "network error, check connection" : (result.httpError ? "http error, could be caused by internal server error" : $"{result.response.status} : {result.response.message}"))));
					}
					else
					{
						ProcessUserVotes(result);
					}
				}
			}

			internal bool <PostCatalogLoad>b__30_0(OnlineLevelField e)
			{
				return !((ConfigField)e).hidden;
			}

			internal string <CheckNewLevelText>b__31_1(BundleInfo level)
			{
				return level.Name;
			}

			internal bool <CheckNewLevelText>b__31_3(string level)
			{
				return !string.IsNullOrEmpty(level);
			}

			internal string <CheckNewLevelText>b__31_4(string name)
			{
				return "<color=#00FF00>New level: " + name + "</color>";
			}

			internal async Task<AngryVotes.GetAllVotesResult> <.cctor>b__33_0()
			{
				return await AngryVotes.GetAllVotesTask();
			}

			internal async Task<AngryUser.UserInfoResult> <.cctor>b__33_1()
			{
				return await AngryUser.GetUserInfo();
			}
		}

		internal static ConfigPanel onlineLevelsPanel;

		internal static ConfigDivision onlineLevelContainer;

		internal static LoadingCircleField loadingCircle;

		internal static BoolField showInstalledLevels;

		internal static BoolField showUpdateAvailableLevels;

		internal static BoolField showNotInstalledLevels;

		internal static EnumField<SortFilter> sortFilter;

		internal static SearchBarField searchBar;

		private static string[] searchKeywords = new string[0];

		internal static ConfigHeader searchInfo;

		internal static Dictionary<string, OnlineLevelField> onlineLevels = new Dictionary<string, OnlineLevelField>();

		private static bool _inited = false;

		private static Regex richText = new Regex("<[^>]*>");

		private static CachedTask currentRefreshTask = new CachedTask(RefreshTask);

		private static CachedTask<AngryVotes.GetAllVotesResult> currentGetVotesTask = new CachedTask<AngryVotes.GetAllVotesResult>(async () => await AngryVotes.GetAllVotesTask());

		private static CancellationTokenSource currentVoteCancellationToken = null;

		private static CachedTask<AngryUser.UserInfoResult> currentUserInfoRequestTask = new CachedTask<AngryUser.UserInfoResult>(async () => await AngryUser.GetUserInfo());

		private static CancellationTokenSource currentUserInfoRequestToken = null;

		public static bool Refreshing => currentRefreshTask.Running;

		public static bool TryGetOnlineLevel(string bundleGuid, out OnlineLevelField onlineLevel)
		{
			return onlineLevels.TryGetValue(bundleGuid, out onlineLevel);
		}

		internal static void Init()
		{
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Expected O, but got Unknown
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: 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_00e4: Expected O, but got Unknown
			//IL_0152: Unknown result type (might be due to invalid IL or missing references)
			//IL_015c: Expected O, but got Unknown
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0132: Expected O, but got Unknown
			//IL_01bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c9: Expected O, but got Unknown
			//IL_01d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01df: Expected O, but got Unknown
			//IL_01e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0175: Unknown result type (might be due to invalid IL or missing references)
			//IL_017a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0180: Expected O, but got Unknown
			if (_inited)
			{
				return;
			}
			_inited = true;
			_ = AngryPaths.LevelCatalogCachePath;
			OnlineCatalogManager.LoadCachedCatalog();
			OnlineScriptsManager.LoadCachedCatalog();
			searchBar = new SearchBarField(onlineLevelsPanel);
			sortFilter = new EnumField<SortFilter>(onlineLevelsPanel, "Sort type", "sf_o_sortType", SortFilter.LastUpdate);
			((ConfigField)sortFilter).hidden = true;
			sortFilter.SetEnumDisplayName(SortFilter.LastUpdate, "Last Update");
			sortFilter.SetEnumDisplayName(SortFilter.ReleaseDate, "Release Date");
			sortFilter.postValueChangeEvent += delegate
			{
				SortAll();
			};
			new OnlineSortField(onlineLevelsPanel);
			showInstalledLevels = new BoolField(onlineLevelsPanel, "Installed", "online_installedLevels", true);
			BoolField obj = showInstalledLevels;
			object obj2 = <>c.<>9__14_1;
			if (obj2 == null)
			{
				PostBoolValueChangeEvent val2 = delegate
				{
					UpdateVisibility();
				};
				<>c.<>9__14_1 = val2;
				obj2 = (object)val2;
			}
			obj.postValueChangeEvent += (PostBoolValueChangeEvent)obj2;
			((ConfigField)showInstalledLevels).hidden = true;
			showNotInstalledLevels = new BoolField(onlineLevelsPanel, "Not installed", "online_notInstalledLevels", true);
			BoolField obj3 = showNotInstalledLevels;
			object obj4 = <>c.<>9__14_2;
			if (obj4 == null)
			{
				PostBoolValueChangeEvent val3 = delegate
				{
					UpdateVisibility();
				};
				<>c.<>9__14_2 = val3;
				obj4 = (object)val3;
			}
			obj3.postValueChangeEvent += (PostBoolValueChangeEvent)obj4;
			((ConfigField)showNotInstalledLevels).hidden = true;
			showUpdateAvailableLevels = new BoolField(onlineLevelsPanel, "Update available", "online_updateAvailableLevels", true);
			BoolField obj5 = showUpdateAvailableLevels;
			object obj6 = <>c.<>9__14_3;
			if (obj6 == null)
			{
				PostBoolValueChangeEvent val4 = delegate
				{
					UpdateVisibility();
				};
				<>c.<>9__14_3 = val4;
				obj6 = (object)val4;
			}
			obj5.postValueChangeEvent += (PostBoolValueChangeEvent)obj6;
			((ConfigField)showUpdateAvailableLevels).hidden = true;
			new OnlineStatusFilterField(onlineLevelsPanel);
			loadingCircle = new LoadingCircleField(onlineLevelsPanel);
			((ConfigField)loadingCircle).hidden = true;
			onlineLevelContainer = new ConfigDivision(onlineLevelsPanel, "p_onlineLevelsDiv");
			searchInfo = new ConfigHeader((ConfigPanel)(object)onlineLevelContainer, "", 18);
			searchInfo.textColor = Color.gray;
			((ConfigField)searchInfo).hidden = true;
			searchBar.onValueChange = delegate(string newVal)
			{
				string[] array = (from e in newVal.Split(new char[1] { ' ' }, StringSplitOptions.RemoveEmptyEntries)
					select e.ToLower()).ToArray();
				if (array.Length != searchKeywords.Length || !array.SequenceEqual(searchKeywords))
				{
					searchKeywords = array;
					foreach (OnlineLevelField value in onlineLevels.Values)
					{
						value.SearchKeywords = searchKeywords;
					}
					UpdateVisibility();
					if (searchKeywords.Length == 0)
					{
						((ConfigField)searchInfo).hidden = true;
					}
					else
					{
						((ConfigField)searchInfo).hidden = false;
						searchInfo.text = $"Showing {onlineLevels.Values.Where((OnlineLevelField e) => !((ConfigField)e).hidden).Count()} of {OnlineCatalogManager.Catalog.Levels.Count} bundles";
					}
				}
			};
			SearchBarField searchBarField = searchBar;
			searchBarField.onEndEdit = (Action<bool>)Delegate.Combine(searchBarField.onEndEdit, (Action<bool>)delegate(bool wasCanceled)
			{
				if (wasCanceled)
				{
					if (!string.IsNullOrWhiteSpace(searchBar.value))
					{
						searchBar.value = "";
					}
					else
					{
						ConfigManager.config.rootPanel.OpenPanel();
					}
				}
			});
			searchBar.onReset = delegate
			{
				searchBar.value = "";
			};
		}

		private static void SortAll()
		{
			int num = 0;
			if (sortFilter.value == SortFilter.Name)
			{
				foreach (OnlineLevelField item in onlineLevels.Values.OrderBy((OnlineLevelField b) => richText.Replace(b.OnlineBundle.Name, string.Empty)))
				{
					((ConfigField)item).siblingIndex = num++;
				}
				return;
			}
			if (sortFilter.value == SortFilter.Author)
			{
				foreach (OnlineLevelField item2 in onlineLevels.Values.OrderBy((OnlineLevelField b) => richText.Replace(b.OnlineBundle.Author, string.Empty)))
				{
					((ConfigField)item2).siblingIndex = num++;
				}
				return;
			}
			if (sortFilter.value == SortFilter.Votes)
			{
				foreach (OnlineLevelField item3 in onlineLevels.Values.OrderByDescending((OnlineLevelField b) => b.VoteCount))
				{
					((ConfigField)item3).siblingIndex = num++;
				}
				return;
			}
			if (sortFilter.value == SortFilter.LastUpdate)
			{
				foreach (OnlineLevelField item4 in onlineLevels.Values.OrderByDescending((OnlineLevelField b) => b.OnlineBundle.LastUpdate))
				{
					((ConfigField)item4).siblingIndex = num++;
				}
				return;
			}
			if (sortFilter.value != SortFilter.ReleaseDate)
			{
				return;
			}
			LevelCatalog catalog = OnlineCatalogManager.Catalog;
			if (catalog == null)
			{
				return;
			}
			for (int i = 0; i < catalog.Levels.Count; i++)
			{
				if (onlineLevels.TryGetValue(catalog.Levels[i].Guid, out var value))
				{
					((ConfigField)value).siblingIndex = num++;
				}
			}
		}

		private static void UpdateVisibility()
		{
			foreach (OnlineLevelField value in onlineLevels.Values)
			{
				bool flag = false;
				switch (value.Status)
				{
				case OnlineLevelField.OnlineLevelStatus.Installed:
					flag = value.SearchMatch && showInstalledLevels.value;
					break;
				case OnlineLevelField.OnlineLevelStatus.NotInstalled:
					flag = value.SearchMatch && showNotInstalledLevels.value;
					break;
				case OnlineLevelField.OnlineLevelStatus.UpdateAvailable:
					flag = value.SearchMatch && showUpdateAvailableLevels.value;
					break;
				}
				((ConfigField)value).hidden = !flag;
			}
		}

		public static Task RefreshAsync(CancellationToken cancellationToken = default(CancellationToken))
		{
			return currentRefreshTask.GetTask();
		}

		private static async Task RefreshTask()
		{
			foreach (OnlineLevelField value in onlineLevels.Values)
			{
				((ConfigField)value).hidden = true;
				value.VoteStatus = OnlineLevelField.VoteStat.Disabled;
			}
			((ConfigField)onlineLevelContainer).hidden = true;
			((ConfigField)loadingCircle).hidden = false;
			LevelCatalog previousCatalog = OnlineCatalogManager.Catalog;
			LevelCatalog levelCatalog = await OnlineCatalogManager.DownloadCatalogAsync();
			await OnlineScriptsManager.DownloadCatalogAsync();
			PostCatalogLoad(levelCatalog, previousCatalog);
			if (currentVoteCancellationToken != null)
			{
				currentVoteCancellationToken.Cancel();
				currentVoteCancellationToken.Dispose();
			}
			currentVoteCancellationToken = new CancellationTokenSource();
			Task<AngryVotes.GetAllVotesResult> task2 = currentGetVotesTask.GetTask(currentVoteCancellationToken.Token);
			if (currentUserInfoRequestToken != null)
			{
				currentUserInfoRequestToken.Cancel();
				currentUserInfoRequestToken.Dispose();
			}
			currentUserInfoRequestToken = new CancellationTokenSource();
			Task<AngryUser.UserInfoResult> userInfoTask = currentUserInfoRequestTask.GetTask(currentUserInfoRequestToken.Token);
			task2.ContinueWith(delegate(Task<AngryVotes.GetAllVotesResult> task)
			{
				if (task.Result != null)
				{
					AngryVotes.GetAllVotesResult result = task.Result;
					if (!result.completedSuccessfully || result.status != 0)
					{
						Plugin.logger.LogError((object)("Failed to get all votes: " + (result.networkError ? "network error, check connection" : (result.httpError ? "http error, could be caused by internal server error" : $"{result.response.status} : {result.response.message}"))));
					}
					else
					{
						ProcessVotes(result);
						userInfoTask.ContinueWith(delegate(Task<AngryUser.UserInfoResult> task)
						{
							if (task.Result != null)
							{
								AngryUser.UserInfoResult result2 = task.Result;
								if (!result2.completedSuccessfully || result2.status != 0)
								{
									Plugin.logger.LogError((object)("Failed to get user info : " + (result2.networkError ? "network error, check connection" : (result2.httpError ? "http error, could be caused by internal server error" : $"{result2.response.status} : {result2.response.message}"))));
								}
								else
								{
									ProcessUserVotes(result2);
								}
							}
						}, TaskScheduler.FromCurrentSynchronizationContext());
					}
				}
			}, TaskScheduler.FromCurrentSynchronizationContext());
		}

		private static void ProcessVotes(AngryVotes.GetAllVotesResult votes)
		{
			foreach (KeyValuePair<string, AngryVotes.GetAllVotesBundleInfo> bundle in votes.response.bundles)
			{
				if (onlineLevels.TryGetValue(bundle.Key, out var value))
				{
					value.VoteCount = bundle.Value.upvotes - bundle.Value.downvotes;
				}
			}
			if (sortFilter.value == SortFilter.Votes)
			{
				SortAll();
			}
		}

		private static void ProcessUserVotes(AngryUser.UserInfoResult userInfoReq)
		{
			AngryUser.UserInfoData info = userInfoReq.response.info;
			foreach (KeyValuePair<string, OnlineLevelField> onlineLevel in onlineLevels)
			{
				if (info.upvotedBundles.Contains(onlineLevel.Key))
				{
					onlineLevel.Value.VoteStatus = OnlineLevelField.VoteStat.Upvoted;
				}
				else if (info.downvotedBundles.Contains(onlineLevel.Key))
				{
					onlineLevel.Value.VoteStatus = OnlineLevelField.VoteStat.Downvoted;
				}
				else
				{
					onlineLevel.Value.VoteStatus = OnlineLevelField.VoteStat.Cleared;
				}
			}
		}

		internal static void UpdateUI()
		{
			foreach (OnlineLevelField value in onlineLevels.Values)
			{
				value.UpdateStatus();
				if (value.Status == OnlineLevelField.OnlineLevelStatus.NotInstalled)
				{
					if (!showNotInstalledLevels.value)
					{
						((ConfigField)value).hidden = true;
					}
				}
				else if (value.Status == OnlineLevelField.OnlineLevelStatus.Installed)
				{
					if (!showInstalledLevels.value)
					{
						((ConfigField)value).hidden = true;
					}
				}
				else if (value.Status == OnlineLevelField.OnlineLevelStatus.UpdateAvailable && !showUpdateAvailableLevels.value)
				{
					((ConfigField)value).hidden = true;
				}
			}
			SortAll();
		}

		private static void PostCatalogLoad(LevelCatalog catalog, LevelCatalog previousCatalog)
		{
			((ConfigField)loadingCircle).hidden = true;
			((ConfigField)onlineLevelContainer).hidden = false;
			if (catalog == null)
			{
				((ConfigField)onlineLevelContainer).hidden = true;
				return;
			}
			foreach (BundleInfo level in catalog.Levels)
			{
				bool flag = false;
				if (!onlineLevels.TryGetValue(level.Guid, out var field))
				{
					flag = true;
					field = new OnlineLevelField((ConfigPanel)(object)onlineLevelContainer, level);
					field.SearchKeywords = searchKeywords;
					onlineLevels[level.Guid] = field;
				}
				if (!flag)
				{
					field.OnlineBundle = level;
					field.UpdateStatus();
				}
				AngryOnlineThumbnailCache.GetThumbnail(level.Guid).ContinueWith(delegate(Task<Texture2D> task)
				{
					if ((Object)(object)task.Result != (Object)null)
					{
						field.PreviewImage = task.Result;
					}
				}, TaskScheduler.FromCurrentSynchronizationContext());
			}
			CheckNewLevelText(previousCatalog);
			CheckLevelUpdateText();
			SortAll();
			UpdateVisibility();
			if (searchKeywords.Length == 0)
			{
				((ConfigField)searchInfo).hidden = true;
				return;
			}
			((ConfigField)searchInfo).hidden = false;
			searchInfo.text = $"Showing {onlineLevels.Values.Where((OnlineLevelField e) => !((ConfigField)e).hidden).Count()} of {catalog.Levels.Count} bundles";
		}

		internal static void CheckNewLevelText(LevelCatalog previousCatalog)
		{
			string header;
			string body;
			if (ConfigManager.newLevelNotifierToggle.value && previousCatalog != null)
			{
				List<string> list = (from level in OnlineCatalogManager.Catalog.Levels
					where previousCatalog.Levels.Where((BundleInfo l) => l.Guid == level.Guid).FirstOrDefault() == null
					select level.Name).ToList();
				if (list.Count != 0)
				{
					if (!string.IsNullOrEmpty(ConfigManager.newLevelNotifierLevels.value))
					{
						list.AddRange(ConfigManager.newLevelNotifierLevels.value.Split('`'));
					}
					list = list.Distinct().ToList();
					ConfigManager.newLevelNotifierLevels.value = string.Join("`", list);
					ConfigManager.newLevelNotifier.text = string.Join("\n", from level in list
						where !string.IsNullOrEmpty(level)
						select level into name
						select "<color=#00FF00>New level: " + name + "</color>");
					((ConfigField)ConfigManager.newLevelNotifier).hidden = false;
					ConfigManager.newLevelToggle.value = true;
					header = ((list.Count > 1) ? "New levels available!" : "New level available!");
					body = ((list.Count > 1) ? $"{list.Count} new online levels available!" : "A new online level is available!");
					if (SceneHelper.CurrentScene == "Main Menu")
					{
						NotificationSystem.NotifySend(header, body, (Sprite)null, Path.Combine(Plugin.workingDir, "plugin-icon.png"), (Urgency)1, "NotifySend", 0u, (Dictionary<string, string>)null, -1);
					}
					else
					{
						SceneManager.sceneLoaded += ShowNewLevelsOnMainMenu;
					}
				}
			}
			else
			{
				((ConfigField)ConfigManager.newLevelNotifier).hidden = true;
			}
			void ShowNewLevelsOnMainMenu(Scene scene, LoadSceneMode mode)
			{
				if (!(SceneHelper.CurrentScene != "Main Menu"))
				{
					NotificationSystem.NotifySend(header, body, (Sprite)null, Path.Combine(Plugin.workingDir, "plugin-icon.png"), (Urgency)1, "NotifySend", 0u, (Dictionary<string, string>)null, -1);
					SceneManager.sceneLoaded -= ShowNewLevelsOnMainMenu;
				}
			}
		}

		internal static void CheckLevelUpdateText()
		{
			if (!ConfigManager.levelUpdateNotifierToggle.value)
			{
				((ConfigField)ConfigManager.levelUpdateNotifier).hidden = true;
				return;
			}
			ConfigManager.levelUpdateNotifier.text = "";
			((ConfigField)ConfigManager.levelUpdateNotifier).hidden = true;
			foreach (OnlineLevelField field in onlineLevels.Values)
			{
				if (field.Status == OnlineLevelField.OnlineLevelStatus.UpdateAvailable && !field.OnlineBundle.Locked && (!ConfigManager.levelUpdateIgnoreCustomBuilds.value || field.Bundle == null || field.OnlineBundle.Updates == null || field.OnlineBundle.Updates.Any((BundleInfo.UpdateInfo u) => u.Hash == field.Bundle.BuildHash)))
				{
					if (ConfigManager.levelUpdateNotifier.text != "")
					{
						ConfigHeader levelUpdateNotifier = ConfigManager.levelUpdateNotifier;
						levelUpdateNotifier.text += "\n";
					}
					ConfigHeader levelUpdateNotifier2 = ConfigManager.levelUpdateNotifier;
					levelUpdateNotifier2.text = levelUpdateNotifier2.text + "<color=#00FFFF>Update available for " + field.OnlineBundle.Name + "</color>";
					((ConfigField)ConfigManager.levelUpdateNotifier).hidden = false;
				}
			}
		}
	}
}
namespace AngryLevelLoader.Patches
{
	[HarmonyPatch]
	internal static class AbrutptLevelChangerPatch
	{
		[HarmonyPatch(typeof(AbruptLevelChanger), "AbruptChangeLevel")]
		[HarmonyPrefix]
		public static bool OnAbruptChangeLevel(AbruptLevelChanger __instance, string __0)
		{
			return ChangeLevel(__instance, __0);
		}

		[HarmonyPatch(typeof(AbruptLevelChanger), "NormalChangeLevel")]
		[HarmonyPrefix]
		public static bool OnNormalChangeLevel(AbruptLevelChanger __instance, string __0)
		{
			return ChangeLevel(__instance, __0);
		}

		private static bool ChangeLevel(AbruptLevelChanger __instance, string levelName)
		{
			if (!AngrySceneManager.isInCustomLevel)
			{
				return true;
			}
			if (string.IsNullOrEmpty(levelName))
			{
				return false;
			}
			if (Plugin.TryGetAngryLevel(levelName, out var level))
			{
				AngrySceneManager.LoadLevel(level);
				return false;
			}
			Plugin.logger.LogWarning((object)("Could not find target level id " + levelName));
			if (__instance.saveMission)
			{
				__instance.saveMission = false;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(Bonus))]
	internal class BonusPatches
	{
		internal static Bonus lastCaller;

		[HarmonyPatch("OnTriggerEnter")]
		[HarmonyPrefix]
		private static void OnTriggerEnter(Bonus __instance)
		{
			lastCaller = __instance;
		}
	}
	[HarmonyPatch(typeof(ButtonHighlightParent))]
	internal class ButtonHighlightParentPatches
	{
		[HarmonyPatch("Start")]
		[HarmonyPrefix]
		private static bool PreventDoubleStart(ButtonHighlightParent __instance)
		{
			if (__instance.buttons != null && __instance.buttons.Length != 0)
			{
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(ChallengeManager))]
	internal static class ChallengeManagerPatch
	{
		[HarmonyPatch("OnEnable")]
		[HarmonyPrefix]
		public static bool CancelOnEnable()
		{
			if (AngrySceneManager.isInCustomLevel)
			{
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(CutsceneSkip))]
	internal class CutsceneSkipPatches
	{
		[HarmonyPatch("Start")]
		[HarmonyPrefix]
		private static bool StartPatch(CutsceneSkip __instance)
		{
			if (!AngrySceneManager.isInCustomLevel)
			{
				return true;
			}
			return AngrySceneManager.currentLevelContainer.FinalRank != '-';
		}
	}
	[HarmonyPatch(typeof(DiscordController))]
	internal static class DiscordControllerPatches
	{
		[HarmonyPatch("FetchSceneActivity")]
		[HarmonyPrefix]
		public static bool FetchSceneActivityOverwrite()
		{
			SceneHelperPatches.forceDisableIsInCustomLevel = true;
			return true;
		}

		[HarmonyPatch("FetchSceneActivity")]
		[HarmonyPostfix]
		public static void PostFetchSceneActivityOverwrite()
		{
			SceneHelperPatches.forceDisableIsInCustomLevel = false;
		}
	}
	[HarmonyPatch(typeof(FinalPit), "SendInfo")]
	internal static class FinalPit_SendInfo_Patch
	{
		public static FinalRoomTarget lastTarget;

		[HarmonyPrefix]
		public static bool Prefix(FinalPit __instance)
		{
			lastTarget = ((Component)((Component)__instance).transform.parent).GetComponentInParent<FinalRoomTarget>();
			return true;
		}
	}
	[HarmonyPatch(typeof(FinalRank), "Start")]
	internal class FinalRank_Start_Patch
	{
		[HarmonyPrefix]
		private static bool Prefix(FinalRank __instance)
		{
			if (!AngrySceneManager.isInCustomLevel)
			{
				return true;
			}
			if ((Object)(object)((Component)__instance).gameObject.GetComponentInChildren<LevelEndLeaderboard>(true) == (Object)null)
			{
				LevelEndLeaderboard componentInChildren = ((Component)((Component)__instance).transform.parent).GetComponentInChildren<LevelEndLeaderboard>(true);
				if ((Object)(object)componentInChildren != (Object)null)
				{
					((Component)componentInChildren).transform.SetParent(((Component)__instance).transform);
					List<GameObject> list = __instance.toAppear.ToList();
					list.Add(((Component)componentInChildren).gameObject);
					__instance.toAppear = list.ToArray();
				}
			}
			if ((Object)(object)((Component)__instance).transform.Find("Challenge") == (Object)null)
			{
				Transform val = ((Component)__instance).transform.Find("Title/Text");
				if ((Object)(object)val != (Object)null)
				{
					((TMP_Text)((Component)val).GetComponent<TextMeshProUGUI>()).text = AngrySceneManager.currentLevelData.levelName;
				}
				else
				{
					Plugin.logger.LogWarning((object)"Could not find title text under final canvas");
				}
				return true;
			}
			__instance.levelSecrets = MonoSingleton<StatsManager>.Instance.secretObjects;
			if (__instance.levelSecrets.Length != AngrySceneManager.currentLevelData.secretCount)
			{
				Plugin.logger.LogWarning((object)$"Inconsistent secrets size, expected {AngrySceneManager.currentLevelData.secretCount}, found {__instance.levelSecrets.Length}");
				__instance.levelSecrets = (GameObject[])(object)new GameObject[AngrySceneManager.currentLevelData.secretCount];
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(FinalRank), "CountSecrets")]
	internal class FinalRank_CountSecrets_Patch
	{
		private static bool Prefix(FinalRank __instance)
		{
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			if (!AngrySceneManager.isInCustomLevel)
			{
				return true;
			}
			if (__instance.secretsCheckProgress >= AngrySceneManager.currentLevelData.secretCount)
			{
				((MonoBehaviour)__instance).Invoke("Appear", __instance.timeBetween);
				return false;
			}
			if (!AngrySceneManager.currentLevelContainer.SecretDiscovered(__instance.secretsCheckProgress))
			{
				((Graphic)__instance.secretsInfo[__instance.secretsCheckProgress]).color = Color.black;
				__instance.secretsCheckProgress++;
				if (__instance.secretsCheckProgress < __instance.levelSecrets.Length)
				{
					((MonoBehaviour)__instance).Invoke("CountSecrets", __instance.timeBetween);
					return false;
				}
				((MonoBehaviour)__instance).Invoke("Appear", __instance.timeBetween);
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(FinalRank), "LevelChange")]
	internal class FinalRank_LevelChange_Patch
	{
		[HarmonyPrefix]
		private static bool Prefix(FinalRank __instance)
		{
			if (!AngrySceneManager.isInCustomLevel)
			{
				return true;
			}
			((Component)__instance).gameObject.SetActive(false);
			if ((Object)(object)FinalPit_SendInfo_Patch.lastTarget == (Object)null || string.IsNullOrEmpty(FinalPit_SendInfo_Patch.lastTarget.targetLevelUniqueId))
			{
				MonoSingleton<OptionsManager>.Instance.QuitMission();
				return false;
			}
			string targetLevelUniqueId = FinalPit_SendInfo_Patch.lastTarget.targetLevelUniqueId;
			if (!Plugin.TryGetAngryLevel(targetLevelUniqueId, out var level))
			{
				Plugin.logger.LogWarning((object)("Could not find target level id " + targetLevelUniqueId));
				MonoSingleton<OptionsManager>.Instance.QuitMission();
				return false;
			}
			AngrySceneManager.LoadLevel(level, showBlocker: false);
			return false;
		}
	}
	[HarmonyPatch(typeof(GameProgressSaver))]
	internal class GameProgressSaverPatches
	{
		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		[HarmonyPriority(500)]
		[HarmonyPrefix]
		public static bool GetRankDataOverwrite(int lvl, ref RankData __result)
		{
			try
			{
				if (lvl < 0 && AngrySceneManager.isInCustomLevel)
				{
					__result = null;
					return false;
				}
				return true;
			}
			catch (Exception arg)
			{
				Debug.LogError((object)$"Caught exception in patch GetRankDataOverwrite\n{arg}");
				return true;
			}
		}

		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		[HarmonyPrefix]
		public static bool OverwriteCustomLevelProgressPath(ref string __result)
		{
			if (!AngrySceneManager.isInCustomLevel)
			{
				return true;
			}
			__result = GameProgressSaver.CustomLevelProgressPath(AngrySceneManager.currentLevelData.uniqueIdentifier);
			return false;
		}

		[HarmonyPatch("SaveRank", new Type[] { })]
		[HarmonyPriority(500)]
		[HarmonyPrefix]
		public static bool SaveRankOverwrite()
		{
			try
			{
				if (AngrySceneManager.isInCustomLevel)
				{
					return false;
				}
				return true;
			}
			catch (Exception ex)
			{
				Debug.LogError((object)ex);
				return true;
			}
		}

		[HarmonyPatch("ChallengeComplete", new Type[] { })]
		[HarmonyPriority(500)]
		[HarmonyPrefix]
		public static bool ChallengeCompleteOverwrite()
		{
			try
			{
				if (AngrySceneManager.isInCustomLevel)
				{
					return false;
				}
				return true;
			}
			catch (Exception ex)
			{
				Debug.LogError((object)ex);
				return true;
			}
		}

		[HarmonyPatch("SaveProgress", new Type[] { typeof(int) })]
		[HarmonyPriority(500)]
		[HarmonyPrefix]
		public static bool SaveProgressOverwrite()
		{
			try
			{
				if (AngrySceneManager.isInCustomLevel)
				{
					return false;
				}
				return true;
			}
			catch (Exception ex)
			{
				Debug.LogError((object)ex);
				return true;
			}
		}
	}
	[HarmonyPatch(typeof(LeaderboardController))]
	internal class GameStateManagerPatches
	{
		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		[HarmonyPrefix]
		private static bool EnablePostingScoresInCustomLevels(ref bool __result)
		{
			if (!AngrySceneManager.isInCustomLevel)
			{
				return true;
			}
			__result = MonoSingleton<AssistController>.Instance.cheatsEnabled || MonoSingleton<StatsManager>.Instance.majorUsed;
			return false;
		}
	}
	[HarmonyPatch(typeof(GetMissionName), "GetMission")]
	internal class GetMissionName_Patch
	{
		[HarmonyPrefix]
		private static bool Prefix(ref string __result)
		{
			if (!AngrySceneManager.isInCustomLevel)
			{
				return true;
			}
			__result = AngrySceneManager.currentLevelData.levelName;
			return false;
		}
	}
	[HarmonyPatch(typeof(LevelEndLeaderboard))]
	internal static class LevelEndLeaderboardPatches
	{
		private class InstantReturnEnumerator : IEnumerator
		{
			public object Current => null;

			public bool MoveNext()
			{
				return false;
			}

			public void Reset()
			{
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass2_0
		{
			public AngryLeaderboards.RecordInfo record;

			public TextMeshProUGUI newUsernameField;

			public bool isCurrentUser;

			public RawImage profilePicture;

			internal void <CustomFetch>b__1(SteamUserCache result)
			{
				if ((Object)(object)newUsernameField != (Object)null)
				{
					((TMP_Text)newUsernameField).text = ((record.censorName && !isCurrentUser) ? "(hidden)" : result.name);
				}
				if ((Object)(object)result.profilePicture != (Object)null && (Object)(object)profilePicture != (Object)null && (!record.censorIcon || isCurrentUser))
				{
					profilePicture.texture = (Texture)(object)result.profilePicture;
				}
			}
		}

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

			private object <>2__current;

			public LevelEndLeaderboard instance;

			private TextMeshProUGUI <loadingText>5__2;

			private Task<AngryLeaderboards.GetRecordsResult> <getRecordsTask>5__3;

			private Task <postRecordTask>5__4;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<loadingText>5__2 = null;
				<getRecordsTask>5__3 = null;
				<postRecordTask>5__4 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_02f6: Unknown result type (might be due to invalid IL or missing references)
				//IL_02fb: Unknown result type (might be due to invalid IL or missing references)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					instance.ResetEntries();
					<loadingText>5__2 = instance.loadingPanel.gameObject.GetComponent<TextMeshProUGUI>();
					((Component)instance.container).gameObject.SetActive(false);
					instance.loadingPanel.SetActive(true);
					switch (currentCategory)
					{
					case AngryLeaderboards.RecordCategory.ALL:
						instance.leaderboardType.text = "ANY RANK";
						break;
					case AngryLeaderboards.RecordCategory.PRANK:
						instance.leaderboardType.text = "P RANK";
						break;
					case AngryLeaderboards.RecordCategory.CHALLENGE:
						instance.leaderboardType.text = "CHALLENGE";
						break;
					case AngryLeaderboards.RecordCategory.NOMO:
						instance.leaderboardType.text = "NO MONSTERS";
						break;
					case AngryLeaderboards.RecordCategory.NOMOW:
						instance.leaderboardType.text = "NO MONSTERS & WEAPONS";
						break;
					}
					goto IL_018c;
				case 1:
					<>1__state = -1;
					goto IL_0178;
				case 2:
					{
						<>1__state = -1;
						break;
					}
					IL_018c:
					if (AngryLeaderboards.postRecordTasks.Count != 0)
					{
						((TMP_Text)<loadingText>5__2).text = "POSTING RECORD";
						<postRecordTask>5__4 = AngryLeaderboards.postRecordTasks.Where((Task task) => !task.IsCompleted).FirstOrDefault();
						if (<postRecordTask>5__4 != null)
						{
							goto IL_0178;
						}
					}
					((TMP_Text)<loadingText>5__2).text = "CONNECTING TO\nANGRY SERVER";
					<getRecordsTask>5__3 = AngryLeaderboards.GetRecordsTask(currentCategory, AngryLeaderboards.RecordDifficulty.ANY, AngrySceneManager.currentBundleContainer.bundleGuid, AngrySceneManager.currentLevelData.uniqueIdentifier, 0, 10);
					break;
					IL_0178:
					if (!<postRecordTask>5__4.IsCompleted)
					{
						<>2__current = null;
						<>1__state = 1;
						return true;
					}
					<postRecordTask>5__4 = null;
					goto IL_018c;
				}
				if (!<getRecordsTask>5__3.IsCompleted)
				{
					<>2__current = null;
					<>1__state = 2;
					return true;
				}
				AngryLeaderboards.GetRecordsResult result2 = <getRecordsTask>5__3.Result;
				if (result2.networkError)
				{
					Plugin.logger.LogError((object)"Could not get level records (NETWORK_ERROR), check connection");
					((TMP_Text)<loadingText>5__2).text = "NETWORK ERROR,\nCHECK CONNECTION";
					return false;
				}
				if (result2.httpError)
				{
					Plugin.logger.LogError((object)"Could not get level records (HTTP_ERROR), check server");
					((TMP_Text)<loadingText>5__2).text = "SERVER ERROR,\nTRY AGAIN LATER";
					return false;
				}
				if (result2.status != 0)
				{
					Plugin.logger.LogError((object)$"Status error while getting all records. message: {result2.message}, status: {result2.status}");
					switch (result2.status)
					{
					case AngryLeaderboards.GetRecordsStatus.INVALID_BUNDLE:
					case AngryLeaderboards.GetRecordsStatus.INVALID_ID:
						((TMP_Text)<loadingText>5__2).text = "LEADERBOARDS\nDISABLED FOR LEVEL";
						break;
					case AngryLeaderboards.GetRecordsStatus.RATE_LIMITED:
						((TMP_Text)<loadingText>5__2).text = "TOO MANY REQUESTS,\nTRY AGAIN LATER";
						break;
					default:
						((TMP_Text)<loadingText>5__2).text = $"STATUS ERROR:\n{result2.status}";
						break;
					}
					return false;
				}
				string text = "";
				try
				{
					SteamId steamId = SteamClient.SteamId;
					text = ((object)(SteamId)(ref steamId)).ToString();
				}
				catch (Exception)
				{
				}
				AngryLeaderboards.RecordInfo[] records = result2.response.records;
				for (int i = 0; i < records.Length; i++)
				{
					<>c__DisplayClass2_0 CS$<>8__locals0 = new <>c__DisplayClass2_0
					{
						record = records[i]
					};
					if (!ulong.TryParse(CS$<>8__locals0.record.steamId, out var result3))
					{
						Plugin.logger.LogError((object)("Failed to parse steam id " + CS$<>8__locals0.record.steamId));
						continue;
					}
					int num = CS$<>8__locals0.record.time / 60000;
					float num2 = (float)(CS$<>8__locals0.record.time - num * 60000) / 1000f;
					instance.templateTime.text = $"{num}:{num2:00.000}";
					instance.templateUsername.text = "Loading...";
					instance.templateDifficulty.text = CS$<>8__locals0.record.difficulty;
					GameObject val = Object.Instantiate<GameObject>(instance.template, instance.container);
					Transform val2 = val.transform.Find("Username Field");
					CS$<>8__locals0.newUsernameField = null;
					if ((Object)(object)val2 != (Object)null)
					{
						CS$<>8__locals0.newUsernameField = ((Component)val2).GetComponent<TextMeshProUGUI>();
					}
					CS$<>8__locals0.profilePicture = val.GetComponentInChildren<RawImage>();
					CS$<>8__locals0.isCurrentUser = text == CS$<>8__locals0.record.steamId;
					SteamCacheManager.RequestUser(result3, delegate(SteamUserCache result)
					{
						if ((Object)(object)CS$<>8__locals0.newUsernameField != (Object)null)
						{
							((TMP_Text)CS$<>8__locals0.newUsernameField).text = ((CS$<>8__locals0.record.censorName && !CS$<>8__locals0.isCurrentUser) ? "(hidden)" : result.name);
						}
						if ((Object)(object)result.profilePicture != (Object)null && (Object)(object)CS$<>8__locals0.profilePicture != (Object)null && (!CS$<>8__locals0.record.censorIcon || CS$<>8__locals0.isCurrentUser))
						{
							CS$<>8__locals0.profilePicture.texture = (Texture)(object)result.profilePicture;
						}
					});
					val.SetActive(true);
				}
				instance.loadingPanel.SetActive(false);
				((Component)instance.container).gameObject.SetActive(true);
				return false;
			}

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

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

		public static AngryLeaderboards.RecordCategory currentCategory;

		[HarmonyPatch("OnEnable")]
		[HarmonyPrefix]
		public static bool EnableCustomLeaderboard(LevelEndLeaderboard __instance)
		{
			if (!AngrySceneManager.isInCustomLevel)
			{
				return true;
			}
			if (AngrySceneManager.currentLevelData.isSecretLevel)
			{
				if (!ConfigManager.showLeaderboardOnSecretLevelEnd.value)
				{
					((Component)__instance).gameObject.SetActive(false);
					return false;
				}
			}
			else if (!ConfigManager.showLeaderboardOnLevelEnd.value)
			{
				((Component)__instance).gameObject.SetActive(false);
				return false;
			}
			((TMP_Text)__instance.loadingPanel.gameObject.GetComponent<TextMeshProUGUI>()).text = "CONNECTING TO\nANGRY SERVER";
			if (ConfigManager.difficultyField.gamemodeListValueIndex == 0)
			{
				currentCategory = ((MonoSingleton<StatsManager>.Instance.rankScore == 12) ? AngryLeaderboards.RecordCategory.PRANK : AngryLeaderboards.RecordCategory.ALL);
			}
			else if (ConfigManager.difficultyField.gamemodeListValueIndex == 1)
			{
				currentCategory = AngryLeaderboards.RecordCategory.NOMO;
			}
			else if (ConfigManager.difficultyField.gamemodeListValueIndex == 2)
			{
				currentCategory = AngryLeaderboards.RecordCategory.NOMOW;
			}
			((MonoBehaviour)__instance).StartCoroutine(CustomFetch(__instance));
			return false;
		}

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

		[HarmonyPatch("Fetch")]
		[HarmonyPrefix]
		public static bool RouteFetchToCustom(LevelEndLeaderboard __instance, ref IEnumerator __result)
		{
			if (!AngrySceneManager.isInCustomLevel)
			{
				return true;
			}
			__result = new InstantReturnEnumerator();
			((MonoBehaviour)__instance).StartCoroutine(CustomFetch(__instance));
			return false;
		}

		[HarmonyPatch("Update")]
		[HarmonyPrefix]
		public static bool IterateCustomLeaderboardTypes()
		{
			if (MonoSingleton<InputManager>.Instance.InputSource.NextWeapon.WasPerformedThisFrame || MonoSingleton<InputManager>.Instance.InputSource.LastWeapon.WasPerformedThisFrame || MonoSingleton<InputManager>.Instance.InputSource.PreviousVariation.WasPerformedThisFrame)
			{
				switch (currentCategory)
				{
				case AngryLeaderboards.RecordCategory.ALL:
					currentCategory = AngryLeaderboards.RecordCategory.PRANK;
					break;
				case AngryLeaderboards.RecordCategory.PRANK:
					currentCategory = AngryLeaderboards.RecordCategory.CHALLENGE;
					break;
				case AngryLeaderboards.RecordCategory.CHALLENGE:
					currentCategory = AngryLeaderboards.RecordCategory.NOMO;
					break;
				case AngryLeaderboards.RecordCategory.NOMO:
					currentCategory = AngryLeaderboards.RecordCategory.NOMOW;
					break;
				case AngryLeaderboards.RecordCategory.NOMOW:
					currentCategory = AngryLeaderboards.RecordCategory.ALL;
					break;
				}
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(LevelStats))]
	internal static class LevelStatsPatches
	{
		[HarmonyPatch("Start")]
		[HarmonyPostfix]
		public static void OverwriteTabName(LevelStats __instance)
		{
			if (AngrySceneManager.isInCustomLevel)
			{
				StockMapInfo instance = StockMapInfo.Instance;
				if ((Object)(object)instance != (Object)null)
				{
					__instance.levelName.text = instance.assets.LargeText;
				}
				else
				{
					__instance.levelName.text = "???";
				}
				__instance.ready = true;
				__instance.CheckStats();
				((Component)__instance).gameObject.SetActive(true);
			}
		}
	}
	[HarmonyPatch(typeof(MenuEsc))]
	internal class MenuEscPatches
	{
		[HarmonyPatch("Update")]
		[HarmonyPrefix]
		public static bool OnMainPanelExit(MenuEsc __instance)
		{
			if ((Object)(object)((Component)ConfigManager.config.rootPanel.currentPanel).gameObject != (Object)(object)((Component)__instance).gameObject)
			{
				return true;
			}
			Slider val = default(Slider);
			bool num = MonoSingleton<InputManager>.Instance.InputSource.Pause.WasPerformedThisFrame || (Gamepad.current != null && Gamepad.current.buttonEast.wasPressedThisFrame) || (Gamepad.current != null && Gamepad.current.buttonSouth.wasPressedThisFrame && (Object)(object)EventSystem.current.currentSelectedGameObject != (Object)null && EventSystem.current.currentSelectedGameObject.TryGetComponent<Slider>(ref val));
			BackSelectOverride val2 = default(BackSelectOverride);
			bool flag = (Object)(object)EventSystem.current.currentSelectedGameObject != (Object)null && EventSystem.current.currentSelectedGameObject.TryGetComponent<BackSelectOverride>(ref val2);
			if (!num || flag)
			{
				return true;
			}
			if (!string.IsNullOrEmpty(ConfigManager.searchBar.value))
			{
				ConfigManager.searchBar.value = "";
				return false;
			}
			if (AngryBundleList.PopFolder())
			{
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(MeshCombineManager))]
	internal static class MeshCombineManagerPatches
	{
		private static Shader atlasedShader;

		private static Shader vertexlitShader;

		public static void Initialize()
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)atlasedShader == (Object)null)
			{
				AsyncOperationHandle<Shader> handler = Addressables.LoadAssetAsync<Shader>((object)"Assets/Shaders/Main/ULTRAKILL-vertexlit-atlas.shader");
				handler.Completed += delegate
				{
					//IL_0006: Unknown result type (might be due to invalid IL or missing references)
					//IL_000c: Invalid comparison between Unknown and I4
					if ((int)handler.Status != 2)
					{
						atlasedShader = handler.Result;
					}
				};
			}
			if (!((Object)(object)vertexlitShader == (Object)null))
			{
				return;
			}
			AsyncOperationHandle<Shader> handler2 = Addressables.LoadAssetAsync<Shader>((object)"Assets/Shaders/Main/ULTRAKILL-vertexlit.shader");
			handler2.Completed += delegate
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: Invalid comparison between Unknown and I4
				if ((int)handler2.Status != 2)
				{
					vertexlitShader = handler2.Result;
				}
			};
		}

		[HarmonyPatch("Awake")]
		[HarmonyPrefix]
		private static bool LinkNecessaryShaders(MeshCombineManager __instance)
		{
			if ((Object)(object)__instance.atlasedShader == (Object)null)
			{
				__instance.atlasedShader = atlasedShader;
			}
			if (__instance.allowedShadersToBatch == null || __instance.allowedShadersToBatch.Length == 0)
			{
				__instance.allowedShadersToBatch = (Shader[])(object)new Shader[1] { vertexlitShader };
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(OptionsManager))]
	internal static class OptionsManagerPatches
	{
		[HarmonyPatch("UnPause")]
		[HarmonyPostfix]
		public static void MakeReloadPromptTransparent()
		{
			AngryUI.MakeTransparent(transparent: true);
		}

		[HarmonyPatch("Pause")]
		[HarmonyPostfix]
		public static void MakeReloadPromptOpaque()
		{
			AngryUI.MakeTransparent(transparent: false);
		}
	}
	[HarmonyPatch(typeof(SceneHelper))]
	internal static class SceneHelperPatches
	{
		internal static bool forceDisableIsInCustomLevel;

		[HarmonyPatch("LoadScene")]
		[HarmonyPrefix]
		public static bool GoToMainMenuIfNoSceneFound(ref string __0)
		{
			if (AngrySceneManager.isInCustomLevel && __0 == "")
			{
				__0 = "Main Menu";
			}
			return true;
		}

		[HarmonyPatch("RestartSceneAsync")]
		[HarmonyPrefix]
		public static bool ChangeSceneNameBeforeLoad(SceneHelper __instance, ref Coroutine __result)
		{
			if (!AngrySceneManager.isInCustomLevel)
			{
				return true;
			}
			if (string.IsNullOrEmpty(SceneHelper.CurrentScene))
			{
				SceneHelper.CurrentScene = AngrySceneManager.currentLevelData.uniqueIdentifier;
			}
			__result = SceneHelper.LoadSceneAsync(AngrySceneManager.currentLevelData.scenePath, false);
			return false;
		}

		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		[HarmonyPrefix]
		public static bool OverwriteIsInCustomLevel(ref bool __result)
		{
			if (AngrySceneManager.isInCustomLevel)
			{
				__result = !forceDisableIsInCustomLevel;
				return false;
			}
			return true;
		}

		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		[HarmonyPrefix]
		public static bool OverwriteGetCurrentLevelNumber(ref int __result)
		{
			if (AngrySceneManager.isInCustomLevel)
			{
				__result = -1;
				return false;
			}
			return true;
		}

		[HarmonyPatch("OnSceneLoaded")]
		[HarmonyPrefix]
		public static bool AvoidSceneSetup()
		{
			forceDisableIsInCustomLevel = true;
			return true;
		}

		[HarmonyPatch("OnSceneLoaded")]
		[HarmonyPostfix]
		public static void PostAvoidSceneSetup()
		{
			forceDisableIsInCustomLevel = false;
		}

		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		[HarmonyPostfix]
		public static void IsSceneRanklessFix(ref bool __result)
		{
			if (AngrySceneManager.isInCustomLevel)
			{
				__result = AngrySceneManager.currentLevelContainer.FinalRank != '-';
			}
		}
	}
	[HarmonyPatch(typeof(StatsManager), "Awake")]
	internal class StatsManager_Awake_Patch
	{
		public static bool Prefix(StatsManager __instance)
		{
			if (!AngrySceneManager.isInCustomLevel)
			{
				return true;
			}
			__instance.levelNumber = -1;
			__instance.secretObjects = (GameObject[])(object)new GameObject[0];
			return true;
		}

		[HarmonyPostfix]
		public static void Postfix(StatsManager __instance)
		{
			if (!AngrySceneManager.isInCustomLevel)
			{
				return;
			}
			__instance.challengeComplete = false;
			__instance.secretObjects = (GameObject[])(object)new GameObject[AngrySceneManager.currentLevelData.secretCount];
			__instance.prevSecrets.Clear();
			__instance.newSecrets.Clear();
			LevelContainer currentLevelContainer = AngrySceneManager.currentLevelContainer;
			for (int i = 0; i < currentLevelContainer.SecretCount; i++)
			{
				if (currentLevelContainer.SecretDiscovered(i))
				{
					__instance.prevSecrets.Add(i);
				}
			}
		}
	}
	[HarmonyPatch(typeof(StatsManager), "SecretFound")]
	internal class StatsManager_SecretFound_Patch
	{
		[HarmonyPrefix]
		private static bool Prefix(StatsManager __instance, int __0)
		{
			if (!AngrySceneManager.isInCustomLevel)
			{
				return true;
			}
			if (__instance.prevSecrets.Contains(__0) || __instance.newSecrets.Contains(__0))
			{
				return false;
			}
			if ((Object)(object)BonusPatches.lastCaller == (Object)null || BonusPatches.lastCaller.secretNumber != __0)
			{
				return false;
			}
			if ((Object)(object)((Component)BonusPatches.lastCaller).GetComponent<IgnoreSecret>() != (Object)null)
			{
				return false;
			}
			AngrySceneManager.currentLevelContainer.SetSecretDiscovered(__0, discovered: true);
			__instance.newSecrets.Add(__0);
			return false;
		}
	}
	[HarmonyPatch(typeof(StatsManager), "SendInfo")]
	internal class StatsManager_SendInfo_Patch
	{
		private static string RemoveFormatting(string str)
		{
			Regex regex = new Regex("<[^>]*>");
			if (regex.IsMatch(str))
			{
				return regex.Replace(str, string.Empty);
			}
			return str;
		}

		[HarmonyPrefix]
		private static bool Prefix(StatsManager __instance)
		{
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			//IL_0192: Unknown result type (might be due to invalid IL or missing references)
			//IL_0179: Unknown result type (might be due to invalid IL or missing references)
			bool flag = (Object)(object)((Component)__instance.fr).transform.Find("Challenge") == (Object)null;
			if (!AngrySceneManager.isInCustomLevel || flag)
			{
				return true;
			}
			Transform val = ((Component)__instance.fr).transform.Find("Secrets - Info");
			if ((Object)(object)val != (Object)null)
			{
				HorizontalLayoutGroup obj = ((Component)val).gameObject.AddComponent<HorizontalLayoutGroup>();
				((HorizontalOrVerticalLayoutGroup)obj).childControlWidth = true;
				((HorizontalOrVerticalLayoutGroup)obj).childForceExpandWidth = true;
				while (val.childCount != 1)
				{
					Transform child = val.GetChild(1);
					Object.Destroy((Object)(object)((Component)child).gameObject);
					((Component)child).transform.SetParent((Transform)null);
				}
				if (AngrySceneManager.currentLevelData.secretCount == 0)
				{
					Transform child2 = val.GetChild(0);
					Object.Destroy((Object)(object)((Component)child2).gameObject);
					((Component)child2).transform.SetParent((Transform)null);
				}
				else
				{
					List<Transform> list = new List<Transform> { val.GetChild(0) };
					for (int i = 1; i < AngrySceneManager.currentLevelData.secretCount; i++)
					{
						GameObject val2 = Object.Instantiate<GameObject>(((Component)val.GetChild(0)).gameObject, val);
						list.Add(val2.transform);
					}
					for (int j = 0; j < 5 - AngrySceneManager.currentLevelData.secretCount; j++)
					{
						((Graphic)Object.Instantiate<GameObject>(((Component)val.GetChild(0)).gameObject, val).GetComponent<Image>()).color = new Color(0f, 0f, 0f, 0f);
					}
					LevelContainer currentLevelContainer = AngrySceneManager.currentLevelContainer;
					for (int k = 0; k < list.Count; k++)
					{
						if (currentLevelContainer.SecretDiscovered(k))
						{
							((Graphic)((Component)list[k]).GetComponent<Image>()).color = Color.white;
						}
						else
						{
							((Graphic)((Component)list[k]).GetComponent<Image>()).color = Color.black;
						}
					}
					__instance.fr.secretsInfo = list.Select((Transform e) => ((Component)e).GetComponent<Image>()).ToArray();
				}
				__instance.fr.levelSecrets = (GameObject[])(object)new GameObject[0];
			}
			else
			{
				Plugin.logger.LogWarning((object)"Could not find secrets container");
			}
			return true;
		}

		[HarmonyPostfix]
		private static void Postfix(StatsManager __instance)
		{
			//IL_05af: Unknown result type (might be due to invalid IL or missing references)
			//IL_0548: Unknown result type (might be due to invalid IL or missing references)
			//IL_0577: Unknown result type (might be due to invalid IL or missing references)
			//IL_051e: Unknown result type (might be due to invalid IL or missing references)
			if (!AngrySceneManager.isInCustomLevel)
			{
				return;
			}
			LevelEndLeaderboard leaderboard = null;
			if ((Object)(object)MonoSingleton<FinalRank>.Instance != (Object)null)
			{
				leaderboard = ((Component)MonoSingleton<FinalRank>.Instance).GetComponentInChildren<LevelEndLeaderboard>(true);
			}
			if (InternalConfigManager.leaderboardToggle.value)
			{
				if (ConfigManager.difficultyField.gamemodeListValueIndex == 0)
				{
					AngryLeaderboards.PostRecordInfo info = default(AngryLeaderboards.PostRecordInfo);
					info.category = AngryLeaderboards.RecordCategory.ALL;
					info.difficulty = AngryLeaderboards.DifficultyFromInteger(MonoSingleton<PrefsManager>.Instance.GetInt("difficulty", -1));
					info.bundleGuid = AngrySceneManager.currentBundleContainer.bundleGuid;
					info.hash = AngrySceneManager.currentBundleContainer.BuildHash;
					info.levelId = AngrySceneManager.currentLevelData.uniqueIdentifier;
					info.time = (int)(__instance.seconds * 1000f);
					AngryLeaderboards.TryPostRecordTask(info).ContinueWith(delegate(Task<string> t)
					{
						if (t.Exception != null)
						{
							Debug.LogException((Exception)t.Exception);
						}
						else
						{
							AppendInfoToLeaderboard(t.Result);
						}
					}, TaskScheduler.FromCurrentSynchronizationContext());
					if (__instance.rankScore == 12)
					{
						info.category = AngryLeaderboards.RecordCategory.PRANK;
						AngryLeaderboards.TryPostRecordTask(info);
					}
					if (MonoSingleton<ChallengeManager>.Instance.challengeDone && !MonoSingleton<ChallengeManager>.Instance.challengeFailed && AngrySceneManager.currentLevelData.levelChallengeEnabled)
					{
						info.category = AngryLeaderboards.RecordCategory.CHALLENGE;
						AngryLeaderboards.TryPostRecordTask(info);
					}
				}
				else if (ConfigManager.difficultyField.gamemodeListValueIndex == 1 || ConfigManager.difficultyField.gamemodeListValueIndex == 2)
				{
					AngryLeaderboards.PostRecordInfo info2 = default(AngryLeaderboards.PostRecordInfo);
					info2.category = ((ConfigManager.difficultyField.gamemodeListValueIndex == 1) ? AngryLeaderboards.RecordCategory.NOMO : AngryLeaderboards.RecordCategory.NOMOW);
					info2.difficulty = AngryLeaderboards.RecordDifficulty.HARMLESS;
					info2.bundleGuid = AngrySceneManager.currentBundleContainer.bundleGuid;
					info2.hash = AngrySceneManager.currentBundleContainer.BuildHash;
					info2.levelId = AngrySceneManager.currentLevelData.uniqueIdentifier;
					info2.time = (int)(__instance.seconds * 1000f);
					AngryLeaderboards.TryPostRecordTask(info2).ContinueWith(delegate(Task<string> t)
					{
						if (t.Exception != null)
						{
							Debug.LogException((Exception)t.Exception);
						}
						else
						{
							AppendInfoToLeaderboard(t.Result);
						}
					}, TaskScheduler.FromCurrentSynchronizationContext());
				}
			}
			bool flag = ConfigManager.difficultyField.gamemodeListValueIndex == 0;
			if ((Object)(object)((Component)__instance.fr).transform.Find("Challenge") == (Object)null && flag)
			{
				if (AngrySceneManager.currentLevelContainer.FinalRank != 'P')
				{
					AngrySceneManager.currentLevelContainer.FinalRank = (MonoSingleton<AssistController>.Instance.cheatsEnabled ? ' ' : 'P');
				}
				return;
			}
			char c = RemoveFormatting(__instance.fr.totalRank.text)[0];
			if (c == '-')
			{
				c = ' ';
			}
			int rankScore = AngryRankUtils.GetRankScore(AngrySceneManager.currentLevelContainer.FinalRank);
			int rankScore2 = AngryRankUtils.GetRankScore(c);
			bool cheatsEnabled = MonoSingleton<AssistController>.Instance.cheatsEnabled;
			bool flag2 = MonoSingleton<ChallengeManager>.Instance.challengeDone && !MonoSingleton<ChallengeManager>.Instance.challengeFailed;
			bool challengeDone = AngrySceneManager.currentLevelContainer.ChallengeDone;
			bool num = !cheatsEnabled && (rankScore2 > rankScore || (rankScore2 == rankScore && __instance.seconds < AngrySceneManager.currentLevelContainer.Time));
			bool flag3 = rankScore == -1 && cheatsEnabled;
			if (!cheatsEnabled && !challengeDone && AngrySceneManager.currentLevelData.levelChallengeEnabled)
			{
				AngrySceneManager.currentLevelContainer.ChallengeDone = flag2;
			}
			if ((num || flag3) && flag)
			{
				string text = RemoveFormatting(__instance.fr.timeRank.text);
				string text2 = RemoveFormatting(__instance.fr.killsRank.text);
				string text3 = RemoveFormatting(__instance.fr.styleRank.text);
				AngrySceneManager.currentLevelContainer.Time = __instance.seconds;
				AngrySceneManager.currentLevelContainer.TimeRank = ((text.Length == 0) ? '-' : text[0]);
				AngrySceneManager.currentLevelContainer.Kills = __instance.kills;
				AngrySceneManager.currentLevelContainer.KillsRank = ((text2.Length == 0) ? '-' : text2[0]);
				AngrySceneManager.currentLevelContainer.Style = __instance.stylePoints;
				AngrySceneManager.currentLevelContainer.StyleRank = ((text3.Length == 0) ? '-' : text3[0]);
				if (cheatsEnabled)
				{
					AngrySceneManager.currentLevelContainer.FinalRank = ' ';
				}
				else
				{
					string text4 = RemoveFormatting(__instance.fr.totalRank.text);
					AngrySceneManager.currentLevelContainer.FinalRank = ((text4.Length == 0) ? '-' : text4[0]);
				}
			}
			Transform val = ((Component)__instance.fr).transform.Find("Challenge/ChallengeText");
			if ((Object)(object)val != (Object)null)
			{
				((TMP_Text)((Component)val).GetComponent<TextMeshProUGUI>()).text = (AngrySceneManager.currentLevelData.levelChallengeEnabled ? AngrySceneManager.currentLevelData.levelChallengeText : "No challenge available for the level");
			}
			else
			{
				Plugin.logger.LogWarning((object)"Could not find challenge text");
			}
			if (!((Object)(object)MonoSingleton<FinalRank>.Instance != (Object)null))
			{
				return;
			}
			GameObject gameObject = ((Component)((Component)MonoSingleton<FinalRank>.Instance).transform.Find("Challenge/Panel (1)")).gameObject;
			if (!((Object)(object)gameObject != (Object)null))
			{
				return;
			}
			if (AngrySceneManager.currentLevelData.levelChallengeEnabled && (flag2 || challengeDone))
			{
				Plugin.logger.LogInfo((object)"Enabling challenge panel since it is completed now or before");
				if (cheatsEnabled)
				{
					gameObject.GetComponent<AudioSource>().volume = 0f;
					if (challengeDone && !flag2)
					{
						((Graphic)gameObject.GetComponent<Image>()).color = new Color(0f, 1f, 0f, 0.5f);
					}
					else
					{
						((Graphic)gameObject.GetComponent<Image>()).color = new Color(0f, 1f, 0f, 1f);
					}
				}
				else if (challengeDone && !flag2)
				{
					((Graphic)gameObject.GetComponent<Image>()).color = new Color(1f, 0.696f, 0f, 0.5f);
					gameObject.GetComponent<AudioSource>().volume = 1f;
				}
				else
				{
					((Graphic)gameObject.GetComponent<Image>()).color = new Color(1f, 0.696f, 0f, 1f);
					gameObject.GetComponent<AudioSource>().volume = 1f;
				}
				gameObject.SetActive(true);
			}
			else
			{
				Plugin.logger.LogInfo((object)"Disabling challenge panel since it is not completed now and before");
				gameObject.SetActive(false);
			}
			void AppendInfoToLeaderboard(string message)
			{
				//IL_0048: Unknown result type (might be due to invalid IL or missing references)
				//IL_004d: Unknown result type (might be due to invalid IL or missing references)
				//IL_005b: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)leaderboard == (Object)null)
				{
					Debug.LogWarning((object)"Failed to find leaderboard for record info");
				}
				else
				{
					Transform val2 = ((Component)leaderboard).transform.Find("SettingsReminder");
					TextMeshProUGUI val3 = default(TextMeshProUGUI);
					if ((Object)(object)val2 != (Object)null && ((Component)val2).gameObject.TryGetComponent<TextMeshProUGUI>(ref val3))
					{
						Vector4 margin = ((TMP_Text)val3).margin;
						margin.w = -500f;
						((TMP_Text)val3).margin = margin;
						TextMeshProUGUI obj = val3;
						((TMP_Text)obj).text = ((TMP_Text)obj).text + "\n" + message;
					}
				}
			}
		}
	}
	[HarmonyPatch(typeof(SteamController))]
	internal static class SteamControllerPatches
	{
		[HarmonyPatch("FetchSceneActivity")]
		[HarmonyPrefix]
		public static bool FetchSceneActivityOverwrite()
		{
			SceneHelperPatches.forceDisableIsInCustomLevel = true;
			return true;
		}

		[HarmonyPatch("FetchSceneActivity")]
		[HarmonyPostfix]
		public static void PostFetchSceneActivityOverwrite()
		{
			SceneHelperPatches.forceDisableIsInCustomLevel = false;
		}
	}
	[HarmonyPatch(typeof(StockMapInfo), "Awake")]
	internal static class StockMapInfoPatch
	{
		[HarmonyPostfix]
		public static void Postfix()
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			if (!AngrySceneManager.isInCustomLevel)
			{
				return;
			}
			StatsManager val = Object.FindObjectOfType<StatsManager>();
			if ((Object)(object)val != (Object)null)
			{
				val.levelNumber = -1;
			}
			Scene activeScene = SceneManager.GetActiveScene();
			string currentPath = ((Scene)(ref activeScene)).path;
			foreach (ExecuteOnSceneLoad item in from exe in Resources.FindObjectsOfTypeAll<ExecuteOnSceneLoad>().Where(delegate(ExecuteOnSceneLoad o)
				{
					//IL_0006: Unknown result type (might be due to invalid IL or missing references)
					//IL_000b: Unknown result type (might be due to invalid IL or missing references)
					Scene scene = ((Component)o).gameObject.scene;
					return ((Scene)(ref scene)).path == currentPath;
				})
				orderby exe.relativeExecutionOrder
				select exe)
			{
				try
				{
					item.Execute();
				}
				catch (Exception arg)
				{
					Plugin.logger.LogError((object)$"Error while executing OnSceneLoad script for {((Object)((Component)item).gameObject).name}: {arg}");
				}
			}
		}
	}
}
namespace AngryLevelLoader.Patches.NoMo
{
	[HarmonyPatch(typeof(ActivateArena))]
	internal static class ActivateArenaPatches
	{
		[HarmonyPatch("Activate")]
		[HarmonyPrefix]
		public static bool InstantNomoActivasion(ActivateArena __instance)
		{
			if (!AngrySceneManager.isInCustomLevel || !AngryGamemodeManager.NoMonsters)
			{
				return true;
			}
			Door[] doors = __instance.doors;
			foreach (Door val in doors)
			{
				if ((Object)(object)val != (Object)null)
				{
					try
					{
						val.Lock();
					}
					catch (Exception ex)
					{
						Debug.LogException(ex);
					}
				}
			}
			HashSet<ActivateNextWave> processedWaves = new HashSet<ActivateNextWave>();
			HashSet<ActivateNextWave> hashSet = new HashSet<ActivateNextWave>();
			GameObject[] enemies = __instance.enemies;
			foreach (GameObject val2 in enemies)
			{
				if ((Object)(object)val2 == (Object)null)
				{
					continue;
				}
				ActivateNextWave componentInParent = val2.GetComponentInParent<ActivateNextWave>(true);
				if ((Object)(object)componentInParent != (Object)null)
				{
					ActivateNextWave[] components = ((Component)componentInParent).gameObject.GetComponents<ActivateNextWave>();
					foreach (ActivateNextWave item in components)
					{
						hashSet.Add(item);
					}
				}
				try
				{
					val2.SetActive(true);
				}
				catch (Exception ex2)
				{
					Debug.LogException(ex2);
				}
			}
			while (hashSet.Count != 0)
			{
				foreach (ActivateNextWave item2 in hashSet)
				{
					processedWaves.Add(item2);
				}
				HashSet<ActivateNextWave> hashSet2 = new HashSet<ActivateNextWave>();
				foreach (ActivateNextWave item3 in hashSet)
				{
					enemies = item3.toActivate;
					foreach (GameObject val3 in enemies)
					{
						if ((Object)(object)val3 == (Object)null)
						{
							continue;
						}
						try
						{
							val3.SetActive(true);
						}
						catch (Exception ex3)
						{
							Debug.LogException(ex3);
						}
						bool flag = true;
						if (!((Object)(object)val3.GetComponentInChildren<EnemyIdentifier>() != (Object)null) && (Object)(object)val3.GetComponentInChildren<StatueActivator>() == (Object)null && (Object)(object)val3.GetComponentInChildren<DeathMarker>() == (Object)null)
						{
							flag = false;
						}
						if (!flag)
						{
							continue;
						}
						ActivateNextWave componentInParent2 = val3.GetComponentInParent<ActivateNextWave>(true);
						if (!((Object)(object)componentInParent2 != (Object)null))
						{
							continue;
						}
						foreach (ActivateNextWave item4 in from wave in ((Component)componentInParent2).gameObject.GetComponents<ActivateNextWave>()
							where !processedWaves.Contains(wave)
							select wave)
						{
							hashSet2.Add(item4);
						}
					}
					doors = item3.doors;
					foreach (Door val4 in doors)
					{
						if ((Object)(object)val4 != (Object)null)
						{
							try
							{
								val4.Unlock();
							}
							catch (Exception ex4)
							{
								Debug.LogException(ex4);
							}
						}
					}
					enemies = item3.nextEnemies;
					foreach (GameObject val5 in enemies)
					{
						if ((Object)(object)val5 == (Object)null)
						{
							continue;
						}
						try
						{
							val5.SetActive(true);
						}
						catch (Exception ex5)
						{
							Debug.LogException(ex5);
						}
						ActivateNextWave componentInParent3 = val5.GetComponentInParent<ActivateNextWave>(true);
						if (!((Object)(object)componentInParent3 != (Object)null))
						{
							continue;
						}
						foreach (ActivateNextWave item5 in from wave in ((Component)componentInParent3).gameObject.GetComponents<ActivateNextWave>()
							where !processedWaves.Contains(wave)
							select wave)
						{
							hashSet2.Add(item5);
						}
					}
					Object.Destroy((Object)(object)item3);
				}
				hashSet = hashSet2;
			}
			Object.Destroy((Object)(object)__instance);
			return false;
		}
	}
	[HarmonyPatch(typeof(ActivateNextWaveHP))]
	internal static class ActivateNextWaveHPPatches
	{
		[HarmonyPatch("Update")]
		[HarmonyPrefix]
		public static bool PreUpdate(ActivateNextWaveHP __instance)
		{
			if (!AngrySceneManager.isInCustomLevel || !AngryGamemodeManager.NoMonsters)
			{
				return true;
			}
			if ((Object)(object)__instance.target == (Object)null)
			{
				Activate(__instance);
			}
			else if (__instance.target.health <= __instance.health)
			{
				Activate(__instance);
			}
			return false;
			static void Activate(ActivateNextWaveHP wave)
			{
				GameObject[] toActivate = wave.toActivate;
				foreach (GameObject val in toActivate)
				{
					if ((Object)(object)val != (Object)null)
					{
						try
						{
							val.SetActive(true);
						}
						catch (Exception ex)
						{
							Debug.LogException(ex);
						}
					}
				}
				if (wave.lastWave)
				{
					Door[] doors = wave.doors;
					foreach (Door val2 in doors)
					{
						if (!((Object)(object)val2 == (Object)null))
						{
							try
							{
								val2.Unlock();
							}
							catch (Exception ex2)
							{
								Debug.LogException(ex2);
							}
							if ((Object)(object)val2 == (Object)(object)wave.doorForward)
							{
								try
								{
									val2.Open(false, true);
								}
								catch (Exception ex3)
								{
									Debug.LogException(ex3);
								}
							}
						}
					}
				}
				else
				{
					toActivate = wave.nextEnemies;
					foreach (GameObject val3 in toActivate)
					{
						if ((Object)(object)val3 != (Object)null)
						{
							try
							{
								val3.SetActive(true);
							}
							catch (Exception ex4)
							{
								Debug.LogException(ex4);
							}
						}
					}
				}
				Object.Destroy((Object)(object)wave);
			}
		}
	}
	[HarmonyPatch(typeof(DifficultyTitle))]
	internal static class DifficultyTitlePatches
	{
		[HarmonyPatch("Check")]
		[HarmonyPostfix]
		public static void OverrideTitle(DifficultyTitle __instance)
		{
			if (AngrySceneManager.isInCustomLevel)
			{
				string text = null;
				if (AngryGamemodeManager.NoWeapons)
				{
					text = (__instance.lines ? "-- NO MONSTERS AND WEAPONS --" : "NO MONSTERS AND WEAPONS");
				}
				else if (AngryGamemodeManager.NoMonsters)
				{
					text = (__instance.lines ? "-- NO MONSTERS --" : "NO MONSTERS");
				}
				if (text != null && (Object)(object)__instance.txt2 != (Object)null)
				{
					__instance.txt2.text = text;
				}
			}
		}
	}
	[HarmonyPatch(typeof(DisabledEnemiesChecker))]
	internal static class DisabledEnemiesCheckerPatches
	{
		[HarmonyPatch("Update")]
		[HarmonyPrefix]
		public static bool CheckNoMoActivation(DisabledEnemiesChecker __instance)
		{
			if (!AngrySceneManager.isInCustomLevel || !AngryGamemodeManager.NoMonsters)
			{
				return true;
			}
			if ((Object)(object)MonoSingleton<StatsManager>.Instance == (Object)null || !MonoSingleton<StatsManager>.Instance.levelStarted || __instance.activated)
			{
				return false;
			}
			__instance.activated = true;
			((MonoBehaviour)__instance).Invoke("Activate", __instance.delay);
			return false;
		}
	}
	[HarmonyPatch(typeof(EnemyIdentifier))]
	internal static class EnemyIdentifierPatches
	{
		private class ForceDisable : MonoBehaviour
		{
			private void OnEnable()
			{
				((Component)this).gameObject.SetActive(false);
			}
		}

		[HarmonyPatch("Start")]
		[HarmonyPrefix]
		public static bool DisableSpawnInOnNoMo(EnemyIdentifier __instance)
		{
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Invalid comparison between Unknown and I4
			if (!AngrySceneManager.isInCustomLevel || !AngryGamemodeManager.NoMonsters)
			{
				return true;
			}
			__instance.spawnIn = false;
			GameObject[] activateOnDeath = __instance.activateOnDeath;
			foreach (GameObject val in activateOnDeath)
			{
				if ((Object)(object)val != (Object)null)
				{
					try
					{
						val.SetActive(true);
					}
					catch (Exception ex)
					{
						Debug.LogException(ex);
					}
				}
			}
			if (__instance.onDeath != null)
			{
				try
				{
					__instance.onDeath.Invoke();
				}
				catch (Exception ex2)
				{
					Debug.LogException(ex2);
				}
			}
			__instance.dead = true;
			__instance.health = 0f;
			((Component)__instance).gameObject.SetActive(false);
			EnemyType enemyType = __instance.enemyType;
			if ((int)enemyType != 0)
			{
				if ((int)enemyType == 4 && (Object)(object)((Component)__instance).GetComponent<SpiderBody>() != (Object)null)
				{
					((Component)((Component)__instance).transform.parent).gameObject.SetActive(false);
					((Component)((Component)__instance).transform.parent).gameObject.AddComponent<ForceDisable>();
				}
			}
			else if ((Object)(object)((Component)__instance).GetComponent<StatueBoss>() != (Object)null)
			{
				((Component)((Component)__instance).transform.parent).gameObject.SetActive(false);
				((Component)((Component)__instance).transform.parent).gameObject.AddComponent<ForceDisable>();
			}
			((Component)__instance).gameObject.AddComponent<ForceDisable>();
			return false;
		}
	}
	[HarmonyPatch(typeof(Stalker))]
	internal static class StalkerPatches
	{
		[HarmonyPatch("SandExplode")]
		[HarmonyPrefix]
		public static bool PreventSandExplodeOnNomo()
		{
			if (!AngrySceneManager.isInCustomLevel || !AngryGamemodeManager.NoMonsters)
			{
				return true;
			}
			return false;
		}
	}
	[HarmonyPatch(typeof(StatueActivator))]
	internal static class StatueActivatorPatches
	{
		[HarmonyPatch("Start")]
		[HarmonyPrefix]
		public static bool PreventStatueActivation()
		{
			if (!AngrySceneManager.isInCustomLevel || !AngryGamemodeManager.NoMonsters)
			{
				return true;
			}
			return false;
		}
	}
}
namespace AngryLevelLoader.Patches.NoMoW
{
	[HarmonyPatch(typeof(GunControl))]
	internal static class GunControlPatches
	{
		[HarmonyPatch("ForceWeapon")]
		[HarmonyPrefix]
		public static bool PreventForceGun()
		{
			if (!AngrySceneManager.isInCustomLevel || !AngryGamemodeManager.NoWeapons)
			{
				return true;
			}
			return false;
		}

		[HarmonyPatch("UpdateWeaponList")]
		[HarmonyPrefix]
		public static bool PreventWeapons(GunControl __instance)
		{
			if (!AngrySceneManager.isInCustomLevel || !AngryGamemodeManager.NoWeapons)
			{
				return true;
			}
			__instance.noWeapons = true;
			for (int i = 0; i < __instance.slots.Count; i++)
			{
				foreach (GameObject item in __instance.slots[i])
				{
					if ((Object)(object)item != (Object)null)
					{
						Object.Destroy((Object)(object)item);
					}
				}
				__instance.slots[i].Clear();
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(GunSetter))]
	internal static class GunSetterPatches
	{
		[HarmonyPatch("ResetWeapons")]
		[HarmonyPrefix]
		public static bool RemoveGuns(GunSetter __instance)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Expected O, but got Unknown
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Expected O, but got Unknown
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Expected O, but got Unknown
			if (!AngrySceneManager.isInCustomLevel || !AngryGamemodeManager.NoWeapons)
			{
				return true;
			}
			VariantSetting val = new VariantSetting
			{
				blueVariant = (VariantOption)2,
				greenVariant = (VariantOption)2,
				redVariant = (VariantOption)2
			};
			ArmVariantSetting arm = new ArmVariantSetting
			{
				blueVariant = (VariantOption)0,
				greenVariant = (VariantOption)0,
				redVariant = (VariantOption)0
			};
			__instance.forcedLoadout = new ForcedLoadout
			{
				revolver = val,
				shotgun = val,
				nailgun = val,
				railcannon = val,
				rocketLauncher = val,
				altRevolver = val,
				altNailgun = val,
				arm = arm
			};
			return true;
		}

		[HarmonyPatch("ForceWeapon")]
		[HarmonyPrefix]
		public static bool NoForcedWeapons()
		{
			if (!AngrySceneManager.isInCustomLevel || !AngryGamemodeManager.NoWeapons)
			{
				return true;
			}
			return false;
		}

		[HarmonyPatch("CheckWeapon")]
		[HarmonyPrefix]
		public static bool NoCheckWeapon()
		{
			if (!AngrySceneManager.isInCustomLevel || !AngryGamemodeManager.NoWeapons)
			{
				return true;
			}
			return false;
		}
	}
}
namespace AngryLevelLoader.Patches.MapVars
{
	[HarmonyPatch(typeof(MapBoolSetter))]
	internal static class MapBoolSetterPatches
	{
		[HarmonyPatch("SetVar")]
		[HarmonyPrefix]
		public static bool OnSetVar(MapBoolSetter __instance)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			if (!AngrySceneManager.isInCustomLevel)
			{
				return true;
			}
			bool value = ResolveSetValue(__instance);
			AngryMapVarManager.Instance.SetBool(((MapVarSetter)__instance).variableName, value, ((MapVarSetter)__instance).persistence);
			return false;
		}

		private static bool ResolveSetValue(MapBoolSetter setter)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Invalid comparison between Unknown and I4
			BoolInputType inputType = setter.inputType;
			if ((int)inputType != 0)
			{
				if ((int)inputType == 1)
				{
					return (!MonoSingleton<MapVarManager>.Instance.GetBool(((MapVarSetter)setter).variableName)).GetValueOrDefault();
				}
				return false;
			}
			return setter.value;
		}
	}
	[HarmonyPatch(typeof(MapFloatSetter))]
	internal static class MapFloatSetterPatches
	{
		[HarmonyPatch("SetVar")]
		[HarmonyPrefix]
		public static bool OnSetVar(MapFloatSetter __instance)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			if (!AngrySceneManager.isInCustomLevel)
			{
				return true;
			}
			float value = ResolveSetValue(__instance);
			AngryMapVarManager.Instance.SetFloat(((MapVarSetter)__instance).variableName, value, ((MapVarSetter)__instance).persistence);
			return false;
		}

		private static float ResolveSetValue(MapFloatSetter setter)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Expected I4, but got Unknown
			FloatInputType inputType = setter.inputType;
			return (int)inputType switch
			{
				0 => setter.number, 
				1 => setter.number + MonoSingleton<MapVarManager>.Instance.GetFloat(((MapVarSetter)setter).variableName).GetValueOrDefault(), 
				2 => Random.Range(setter.min, setter.max), 
				3 => setter.list[Random.Range(0, setter.list.Length)], 
				4 => MonoSingleton<MapVarManager>.Instance.GetFloat(setter.sourceVariableName).GetValueOrDefault(-1f), 
				5 => setter.number * MonoSingleton<MapVarManager>.Instance.GetFloat(((MapVarSetter)setter).variableName).GetValueOrDefault(1f), 
				6 => (MonoSingleton<MapVarManager>.Instance.GetFloat(((MapVarSetter)setter).variableName).GetValueOrDefault(1f) * MonoSingleton<MapVarManager>.Instance.GetFloat(setter.sourceVariableName)).GetValueOrDefault(1f), 
				_ => 0f, 
			};
		}
	}
	[HarmonyPatch(typeof(MapIntSetter))]
	internal static class MapIntSetterPatches
	{
		[HarmonyPatch("SetVar")]
		[HarmonyPrefix]
		public static bool OnSetVar(MapIntSetter __instance)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			if (!AngrySceneManager.isInCustomLevel)
			{
				return true;
			}
			int value = ResolveSetValue(__instance);
			AngryMapVarManager.Instance.SetInt(((MapVarSetter)__instance).variableName, value, ((MapVarSetter)__instance).persistence);
			return false;
		}

		private static int ResolveSetValue(MapIntSetter intSetter)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Expected I4, but got Unknown
			IntInputType inputType = intSetter.inputType;
			return (int)inputType switch
			{
				0 => intSetter.number, 
				1 => intSetter.number + MonoSingleton<MapVarManager>.Instance.GetInt(((MapVarSetter)intSetter).variableName).GetValueOrDefault(), 
				2 => Random.Range(intSetter.min, intSetter.max), 
				3 => intSetter.list[Random.Range(0, intSetter.list.Length)], 
				4 => MonoSingleton<MapVarManager>.Instance.GetInt(intSetter.sourceVariableName).GetValueOrDefault(-1), 
				_ => 0, 
			};
		}
	}
	[HarmonyPatch(typeof(MapStringSetter))]
	internal static class MapStringSetterPatches
	{
		[HarmonyPatch("SetVar")]
		[HarmonyPrefix]
		public static bool OnSetVar(MapStringSetter __instance)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			if (!AngrySceneManager.isInCustomLevel)
			{
				return true;
			}
			string value = ResolveSetValue(__instance);
			AngryMapVarManager.Instance.SetString(((MapVarSetter)__instance).variableName, value, ((MapVarSetter)__instance).persistence);
			return false;
		}

		private static string ResolveSetValue(MapStringSetter setter)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Invalid comparison between Unknown and I4
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Expected I4, but got Unknown
			StringInputType inputType = setter.inputType;
			if ((int)inputType != 0)
			{
				if ((int)inputType == 1)
				{
					VariableType sourceVariableType = setter.sourceVariableType;
					return (int)sourceVariableType switch
					{
						1 => MonoSingleton<MapVarManager>.Instance.GetInt(setter.sourceVariableName).ToString(), 
						3 => MonoSingleton<MapVarManager>.Instance.GetFloat(setter.sourceVariableName).ToString(), 
						0 => MonoSingleton<MapVarManager>.Instance.GetBool(setter.sourceVariableName).ToString(), 
						2 => MonoSingleton<MapVarManager>.Instance.GetString(setter.sourceVariableName), 
						_ => null, 
					};
				}
				return null;
			}
			return setter.textValue;
		}
	}
	[HarmonyPatch(typeof(MapVarManager))]
	internal static class MapVarManagerPatches
	{
		[HarmonyPatch("Start")]
		[HarmonyPostfix]
		public static void InstanceAngryMapVarManager(MapVarManager __instance)
		{
			AngryMapVarManager angryMapVarManager = default(AngryMapVarManager);
			if (!((Component)__instance).TryGetComponent<AngryMapVarManager>(ref angryMapVarManager))
			{
				((Component)__instance).gameObject.AddComponent<AngryMapVarManager>();
			}
		}

		[HarmonyPatch("StashStore")]
		[HarmonyPrefix]
		public static bool OnStashStore(MapVarManager __instance)
		{
			if (!AngrySceneManager.isInCustomLevel)
			{
				return true;
			}
			AngryMapVarManager angryMapVarManager = default(AngryMapVarManager);
			if (!((Component)__instance).TryGetComponent<AngryMapVarManager>(ref angryMapVarManager))
			{
				((Component)__instance).gameObject.AddComponent<AngryMapVarManager>();
			}
			angryMapVarManager.StashStore();
			return false;
		}

		[HarmonyPatch("RestoreStashedStore")]
		[HarmonyPrefix]
		public static bool OnRestoreStore(MapVarManager __instance)
		{
			if (!AngrySceneManager.isInCustomLevel)
			{
				return true;
			}
			AngryMapVarManager angryMapVarManager = default(AngryMapVarManager);
			if (!((Component)__instance).TryGetComponent<AngryMapVarManager>(ref angryMapVarManager))
			{
				((Component)__instance).gameObject.AddComponent<AngryMapVarManager>();
			}
			angryMapVarManager.RestoreStashedStore();
			return false;
		}

		[HarmonyPatch("ReloadMapVars")]
		[HarmonyPrefix]
		public static bool OnReloadMapVars(MapVarManager __instance)
		{
			if (!AngrySceneManager.isInCustomLevel)
			{
				return true;
			}
			AngryMapVarManager angryMapVarManager = default(AngryMapVarManager);
			if (!((Component)__instance).TryGetComponent<AngryMapVarManager>(ref angryMapVarManager))
			{
				((Component)__instance).gameObject.AddComponent<AngryMapVarManager>();
			}
			angryMapVarManager.ReloadMapVars();
			return false;
		}

		[HarmonyPatch("ResetStores")]
		[HarmonyPrefix]
		public static bool OnResetMapVars(MapVarManager __instance)
		{
			if (!AngrySceneManager.isInCustomLevel)
			{
				return true;
			}
			AngryMapVarManager angryMapVarManager = default(AngryMapVarManager);
			if (!((Component)__instance).TryGetComponent<AngryMapVarManager>(ref angryMapVarManager))
			{
				((Component)__instance).gameObject.AddComponent<AngryMapVarManager>();
			}
			angryMapVarManager.ResetStores();
			return false;
		}

		[HarmonyPatch("GetInt")]
		[HarmonyPostfix]
		public static void OnGetInt(string key, ref int? __result)
		{
			if (AngrySceneManager.isInCustomLevel)
			{
				__result = AngryMapVarManager.Instance.GetInt(key);
			}
		}

		[HarmonyPatch("GetBool")]
		[HarmonyPostfix]
		public static void OnGetBool(string key, ref bool? __result)
		{
			if (AngrySceneManager.isInCustomLevel)
			{
				__result = AngryMapVarManager.Instance.GetBool(key);
			}
		}

		[HarmonyPatch("GetFloat")]
		[HarmonyPostfix]
		public static void OnGetFloat(string key, ref float? __result)
		{
			if (AngrySceneManager.isInCustomLevel)
			{
				__result = AngryMapVarManager.Instance.GetFloat(key);
			}
		}

		[HarmonyPatch("GetString")]
		[HarmonyPostfix]
		public static void OnGetString(string key, ref string __result)
		{
			if (AngrySceneManager.isInCustomLevel)
			{
				__result = AngryMapVarManager.Instance.GetString(key);
			}
		}

		[HarmonyPatch("GetAllVariables")]
		[HarmonyPostfix]
		public static void OnGetAllVariables(ref List<VariableSnapshot> __result)
		{
			if (AngrySceneManager.isInCustomLevel)
			{
				__result = AngryMapVarManager.Instance.GetAllVariables();
			}
		}

		[HarmonyPatch("SetInt")]
		[HarmonyPrefix]
		public static bool OnSetInt(string key, int value, bool persistent)
		{
			if (!AngrySceneManager.isInCustomLevel)
			{
				return true;
			}
			AngryMapVarManager.Instance.SetInt(key, value, (VariablePersistence)(persistent ? 1 : 0));
			return false;
		}

		[HarmonyPatch("SetFloat")]
		[HarmonyPrefix]
		public static bool OnSetFloat(string key, float value, bool persistent)
		{
			if (!AngrySceneManager.isInCustomLevel)
			{
				return true;
			}
			AngryMapVarManager.Instance.SetFloat(key, value, (VariablePersistence)(persistent ? 1 : 0));
			return false;
		}

		[HarmonyPatch("SetBool")]
		[HarmonyPrefix]
		public static bool OnSetBool(string key, bool value, bool persistent)
		{
			if (!AngrySceneManager.isInCustomLevel)
			{
				return true;
			}
			AngryMapVarManager.Instance.SetBool(key, value, (VariablePersistence)(persistent ? 1 : 0));
			return false;
		}

		[HarmonyPatch("SetString")]
		[HarmonyPrefix]
		public static bool OnSetString(string key, string value, bool persistent)
		{
			if (!AngrySceneManager.isInCustomLevel)
			{
				return true;
			}
			AngryMapVarManager.Instance.SetString(key, value, (VariablePersistence)(persistent ? 1 : 0));
			return false;
		}
	}
}
namespace AngryLevelLoader.Notifications
{
	internal class DeleteBundleNotification : Notification
	{
		private class DeleteButtonComponent : MonoBehaviour
		{
			public AngryDeleteBundleNotificationComponent ui;

			private float timeRemaining = 3.99f;

			public void Update()
			{
				timeRemaining = Mathf.MoveTowards(timeRemaining, 0f, Time.unscaledDeltaTime);
				if (timeRemaining == 0f)
				{
					ui.deleteText.text = "Delete";
					((Selectable)ui.deleteButton).interactable = true;
					((Behaviour)this).enabled = false;
				}
				else
				{
					ui.deleteText.text = $"Delete ({(int)timeRemaining})";
				}
			}
		}

		private const string ASSET_PATH = "AngryLevelLoader/Notifications/BundleDeleteNotification.prefab";

		private BundleContainer container;

		private AngryDeleteBundleNotificationComponent ui;

		public DeleteBundleNotification(BundleContainer container)
		{
			this.container = container;
		}

		private async Task DeleteBundleTask()
		{
			try
			{
				await container.DeleteBundle();
			}
			finally
			{
				if ((Object)(object)ui != (Object)null)
				{
					((Selectable)ui.cancelButton).interactable = true;
				}
				((Notification)this).Close();
			}
		}

		public override void OnUI(RectTransform panel)
		{
			//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_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Expected O, but got Unknown
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Expected O, but got Unknown
			ui = Addressables.InstantiateAsync((object)"AngryLevelLoader/Notifications/BundleDeleteNotification.prefab", (Transform)(object)panel, false, true).WaitForCompletion().GetComponent<AngryDeleteBundleNotificationComponent>();
			((UnityEvent)ui.cancelButton.onClick).AddListener((UnityAction)delegate
			{
				((Notification)this).Close();
			});
			((UnityEvent)ui.deleteButton.onClick).AddListener((UnityAction)delegate
			{
				ui.body.text = "Deleting bundle...";
				((Selectable)ui.cancelButton).interactable = false;
				((Selectable)ui.deleteButton).interactable = false;
				DeleteBundleTask();
			});
			ui.bundleIcon.sprite = container.Icon;
			ui.bundleName.text = container.BundleName;
			ui.body.text = "Do you want to delete <color=aqua>" + container.BundleName + "</color>?\n\nFile will be deleted permanently!\n\n(Level ranks will not be affected)";
			((Component)ui).gameObject.AddComponent<DeleteButtonComponent>().ui = ui;
		}
	}
	internal class LoadingBarSpin : MonoBehaviour
	{
		private void Update()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			((Component)this).transform.Rotate(Vector3.forward, Time.unscaledDeltaTime * 360f);
		}
	}
	internal class DeleteOldBundlesNotification : Notification
	{
		private class DeleteButtonComponent : MonoBehaviour
		{
			public AngryDeleteOldBundlesNotificationComponent ui;

			private float timeRemaining = 3.99f;

			public void Update()
			{
				timeRemaining = Mathf.MoveTowards(timeRemaining, 0f, Time.unscaledDeltaTime);
				if (timeRemaining == 0f)
				{
					ui.deleteButtonText.text = "Delete";
					((Selectable)ui.deleteButton).interactable = true;
					((Behaviour)this).enabled = false;
				}
				else
				{
					ui.deleteButtonText.text = $"Delete ({(int)timeRemaining})";
				}
			}
		}

		private const string ASSET_PATH = "AngryLevelLoader/Notifications/DeleteOldBundlesNotification.prefab";

		private AngryDeleteOldBundlesNotificationComponent ui;

		private async Task DeletionTask()
		{
			try
			{
				List<BundleContainer> bundlesToDelete = (from bundle in Plugin.GetAllBundleContainers()
					where bundle.HasValidAngryFile && bundle.BundleVersion < 6
					select bundle).ToList();
				int progress = 1;
				foreach (BundleContainer item in bundlesToDelete)
				{
					string bundleName = item.BuildHash;
					ui.deletionProgress.text = $"Deleting bundles... ({progress}/{bundlesToDelete.Count})";
					try
					{
						await item.DeleteBundle();
					}
					catch (Exception ex)
					{
						Debug.LogError((object)"Could not delete bundle");
						Debug.LogException(ex);
					}
					ui.deletionLog.text = "- Deleted " + bundleName + "\n" + ui.deletionLog.text;
					progress++;
				}
				ui.loadingCircle.SetActive(false);
				ui.deletionProgress.text = "<color=lime>Done! You can close the window</color>";
			}
			finally
			{
				((Selectable)ui.cancelButton).interactable = true;
			}
			Plugin.ScanForLevels();
		}

		public override void OnUI(RectTransform panel)
		{
			//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_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Expected O, but got Unknown
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Expected O, but got Unknown
			ui = Addressables.InstantiateAsync((object)"AngryLevelLoader/Notifications/DeleteOldBundlesNotification.prefab", (Transform)(object)panel, false, true).WaitForCompletion().GetComponent<AngryDeleteOldBundlesNotificationComponent>();
			((UnityEvent)ui.cancelButton.onClick).AddListener((UnityAction)delegate
			{
				((Notification)this).Close();
			});
			int num = (from bundle in Plugin.GetAllBundleContainers()
				where bundle.HasValidAngryFile && bundle.BundleVersion < 6
				select bundle).Count();
			if (num == 0)
			{
				((Notification)this).Close();
				return;
			}
			ui.body.text = $"Do you want to delete <color=orange>{num}</color> old bundles?\n\nThese bundles cannot be played on the latest version of ULTRAKILL.\n\nThey can be played on an older version by downpatching ULTRAKILL to the Violence update and downgrading Angry to version 2.10.1\n\nThe deletion cannot be reverted!";
			((Selectable)ui.deleteButton).interactable = false;
			((UnityEvent)ui.deleteButton.onClick).AddListener((UnityAction)delegate
			{
				((Component)ui.body).gameObject.SetActive(false);
				ui.loadingCircle.SetActive(true);
				((Component)ui.deletionProgress).gameObject.SetActive(true);
				ui.cancelButtonText.text = "Close";
				DeletionTask();
			});
			ui.loadingCircle.AddComponent<LoadingBarSpin>();
			((Component)ui).gameObject.AddComponent<DeleteButtonComponent>().ui = ui;
		}
	}
	internal class EpilepsyWarningNotification : Notification
	{
		private const string ASSET_PATH = "AngryLevelLoader/Notifications/EpilepsyWarningNotification.prefab";

		private string continueText;

		private string continueAndIgnoreText;

		private Action onContinue;

		private AngryEpilepsyWarningNotificationComponent ui;

		public EpilepsyWarningNotification(Action onContinue, string continueText, string continueAndIgnoreText)
		{
			this.onContinue = onContinue;
			this.continueText = continueText;
			this.continueAndIgnoreText = continueAndIgnoreText;
		}

		public override void OnUI(RectTransform panel)
		{
			//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_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Expected O, but got Unknown
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Expected O, but got Unknown
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Expected O, but got Unknown
			ui = Addressables.InstantiateAsync((object)"AngryLevelLoader/Notifications/EpilepsyWarningNotification.prefab", (Transform)(object)panel, false, true).WaitForCompletion().GetComponent<AngryEpilepsyWarningNotificationComponent>();
			((UnityEvent)ui.cancelButton.onClick).AddListener((UnityAction)delegate
			{
				((Notification)this).Close();
			});
			ui.continueButtonText.text = continueText;
			ui.continueAndIgnoreButtonText.text = continueAndIgnoreText;
			((UnityEvent)ui.continueButton.onClick).AddListener((UnityAction)delegate
			{
				((Notification)this).Close();
				if (onContinue != null)
				{
					onContinue();
				}
			});
			((UnityEvent)ui.continueAndIgnoreButton.onClick).AddListener((UnityAction)delegate
			{
				((Notification)this).Close();
				InternalConfigManager.ignoreEpilepsyWarning.value = true;
				if (onContinue != null)
				{
					onContinue();
				}
			});
		}
	}
	internal class LeaderboardNotification : Notification
	{
		private class RefreshCircleSpin : MonoBehaviour
		{
			private void Update()
			{
				//IL_001b: Unknown result type (might be due to invalid IL or missing references)
				((Component)this).transform.Rotate(new Vector3(0f, 0f, Time.unscaledDeltaTime * 360f));
			}
		}

		private class ExitListener : MonoBehaviour
		{
			public LeaderboardNotification callback;

			private void Update()
			{
				if (MonoSingleton<InputManager>.Instance.InputSource.Pause.WasPerformedThisFrame && callback != null)
				{
					((Notification)callback).Close();
				}
			}
		}

		public readonly string bundleName;

		public readonly string levelName;

		public readonly string bundleGuid;

		public readonly string levelId;

		private Texture2D unknownProfile;

		private const string ASSET_PATH = "AngryLevelLoader/Notifications/AngryLeaderboardNotification.prefab";

		private AngryLeaderboardNotificationComponent currentUi;

		private int currentPage;

		private int totalRecordCount;

		private AngryLeaderboards.UserRecord[] friendRecords;

		private Task currentReloadTask;

		private static readonly AngryLeaderboards.RecordCategory[] dropdownCategories = new AngryLeaderboards.RecordCategory[5]
		{
			AngryLeaderboards.RecordCategory.ALL,
			AngryLeaderboards.RecordCategory.PRANK,
			AngryLeaderboards.RecordCategory.CHALLENGE,
			AngryLeaderboards.RecordCategory.NOMO,
			AngryLeaderboards.RecordCategory.NOMOW
		};

		private static readonly AngryLeaderboards.RecordDifficulty[] dropdownDifficulties = new AngryLeaderboards.RecordDifficulty[6]
		{
			AngryLeaderboards.RecordDifficulty.ANY,
			AngryLeaderboards.RecordDifficulty.HARMLESS,
			AngryLeaderboards.RecordDifficulty.LENIENT,
			AngryLeaderboards.RecordDifficulty.STANDARD,
			AngryLeaderboards.RecordDifficulty.VIOLENT,
			AngryLeaderboards.RecordDifficulty.BRUTAL
		};

		private const string NullTime = "--:--.---";

		private List<AngryUserRecordEntryComponent> historyEntries = new List<AngryUserRecordEntryComponent>();

		public LeaderboardNotification(string bundleName, string levelName, string bundleGuid, string levelId)
		{
			this.bundleName = bundleName;
			this.levelName = levelName;
			this.bundleGuid = bundleGuid;
			this.levelId = levelId;
		}

		public override void OnUI(RectTransform panel)
		{
			//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_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Expected O, but got Unknown
			//IL_01be: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c8: Expected O, but got Unknown
			//IL_01df: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e9: Expected O, but got Unknown
			//IL_0221: Unknown result type (might be due to invalid IL or missing references)
			//IL_022b: Expected O, but got Unknown
			//IL_0242: Unknown result type (might be due to invalid IL or missing references)
			//IL_024c: Expected O, but got Unknown
			//IL_02e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f1: Expected O, but got Unknown
			try
			{
				currentUi = Addressables.InstantiateAsync((object)"AngryLevelLoader/Notifications/AngryLeaderboardNotification.prefab", (Transform)(object)panel, false, true).WaitForCompletion().GetComponent<AngryLeaderboardNotificationComponent>();
				((Component)currentUi).gameObject.AddComponent<ExitListener>().callback = this;
				currentUi.header.text = "Leaderboards for\n" + bundleName + " - " + levelName;
				((UnityEvent)currentUi.closeButton.onClick).AddListener((UnityAction)delegate
				{
					((Notification)this).Close();
				});
				currentUi.refreshCircle.AddComponent<RefreshCircleSpin>();
				currentUi.reportLoadCircle.AddComponent<RefreshCircleSpin>();
				currentUi.historyPanel.loadingCircle.AddComponent<RefreshCircleSpin>();
				currentUi.category.value = (int)ConfigManager.defaultLeaderboardCategory.value;
				((Selectable)currentUi.difficulty).interactable = currentUi.category.value != 3 && currentUi.category.value != 4;
				((UnityEvent<int>)(object)currentUi.category.onValueChanged).AddListener((UnityAction<int>)delegate(int index)
				{
					((Selectable)currentUi.difficulty).interactable = index != 3 && index != 4;
					currentPage = 0;
					currentUi.pageInput.SetTextWithoutNotify("1");
					totalRecordCount = 0;
					friendRecords = null;
					Reload(getLocalUser: true);
				});
				currentUi.difficulty.value = (int)ConfigManager.defaultLeaderboardDifficulty.value;
				((UnityEvent<int>)(object)currentUi.difficulty.onValueChanged).AddListener((UnityAction<int>)delegate
				{
					currentPage = 0;
					currentUi.pageInput.SetTextWithoutNotify("1");
					totalRecordCount = 0;
					friendRecords = null;
					Reload(getLocalUser: true);
				});
				currentUi.group.value = (int)ConfigManager.defaultLeaderboardFilter.value;
				((UnityEvent<int>)(object)currentUi.group.onValueChanged).AddListener((UnityAction<int>)delegate
				{
					currentPage = 0;
					currentUi.pageInput.SetTextWithoutNotify("1");
					totalRecordCount = 0;
					friendRecords = null;
					Reload(getLocalUser: true);
				});
				((UnityEvent)currentUi.nextPage.onClick).AddListener((UnityAction)delegate
				{
					currentPage++;
					currentUi.pageInput.SetTextWithoutNotify((currentPage + 1).ToString());
					Reload(getLocalUser: false);
				});
				((UnityEvent)currentUi.prevPage.onClick).AddListener((UnityAction)delegate
				{
					currentPage--;
					currentUi.pageInput.SetTextWithoutNotify((currentPage + 1).ToString());
					Reload(getLocalUser: false);
				});
				((UnityEvent<string>)(object)currentUi.pageInput.onEndEdit).AddListener((UnityAction<string>)delegate
				{
					if (int.TryParse(currentUi.pageInput.text, out var result))
					{
						if (result < 1)
						{
							result = 1;
						}
						currentPage = result - 1;
						currentUi.pageInput.SetTextWithoutNotify(result.ToString());
						Reload(getLocalUser: false);
					}
					else
					{
						currentUi.pageInput.SetTextWithoutNotify(currentPage.ToString());
					}
				});
				((UnityEvent)currentUi.refreshButton.onClick).AddListener((UnityAction)delegate
				{
					Reload(getLocalUser: true);
				});
				((UnityEvent)currentUi.reportCancel.onClick).AddListener((UnityAction)delegate
				{
					currentUi.reportToggle.SetActive(false);
				});
				((UnityEvent<bool>)(object)currentUi.inappropriateName.onValueChanged).AddListener((UnityAction<bool>)delegate
				{
					UpdateReportUI();
				});
				((UnityEvent<bool>)(object)currentUi.inappropriatePicture.onValueChanged).AddListener((UnityAction<bool>)delegate
				{
					UpdateReportUI();
				});
				((UnityEvent<bool>)(object)currentUi.cheatedScore.onValueChanged).AddListener((UnityAction<bool>)delegate
				{
					UpdateReportUI();
				});
				((UnityEvent<bool>)(object)currentUi.reportValidation.onValueChanged).AddListener((UnityAction<bool>)delegate
				{
					UpdateReportUI();
				});
				((UnityEvent)currentUi.reportReturn.onClick).AddListener((UnityAction)delegate
				{
					currentUi.reportToggle.SetActive(false);
				});
				Reload(getLocalUser: true);
				ref Texture2D reference = ref unknownProfile;
				Texture texture = currentUi.manageUserPanel.userIcon.texture;
				reference = (Texture2D)(object)((texture is Texture2D) ? texture : null);
			}
			catch (Exception arg)
			{
				Plugin.logger.LogError((object)$"Exception thrown while opening leaderboards\n{arg}");
				((Notification)this).Close();
			}
		}

		private void Reload(bool getLocalUser)
		{
			if (currentReloadTask != null && !currentReloadTask.IsCompleted)
			{
				return;
			}
			((Selectable)currentUi.category).interactable = false;
			((Selectable)currentUi.difficulty).interactable = false;
			((Selectable)currentUi.group).interactable = false;
			currentUi.localUserRecordContainer.SetActive(!getLocalUser);
			currentUi.recordEnabler.SetActive(false);
			for (int num = currentUi.recordContainer.childCount - 1; num >= 1; num--)
			{
				Object.Destroy((Object)(object)((Component)currentUi.recordContainer.GetChild(num)).gameObject);
			}
			((Component)currentUi.refreshButton).gameObject.SetActive(false);
			((Component)currentUi.failMessage).gameObject.SetActive(false);
			currentUi.refreshCircle.SetActive(true);
			((Selectable)currentUi.nextPage).interactable = false;
			((Selectable)currentUi.prevPage).interactable = false;
			((Selectable)currentUi.pageInput).interactable = false;
			currentReloadTask = ReloadTask(getLocalUser).ContinueWith(delegate(Task task)
			{
				if (task.Exception != null)
				{
					Debug.LogException((Exception)task.Exception);
				}
				if ((Object)(object)currentUi != (Object)null)
				{
					currentUi.refreshCircle.SetActive(false);
					((Selectable)currentUi.category).interactable = true;
					((Selectable)currentUi.difficulty).interactable = currentUi.category.value != 3 && currentUi.category.value != 4;
					((Selectable)currentUi.group).interactable = true;
				}
			}, TaskScheduler.FromCurrentSynchronizationContext());
		}

		private static string MillisecondsToString(int milliseconds)
		{
			int num = milliseconds / 60000;
			float num2 = (float)(milliseconds - num * 60000) / 1000f;
			return $"{num}:{num2:00.000}";
		}

		private async Task ReloadTask(bool getLocalUser)
		{
			AngryLeaderboards.RecordCategory category = dropdownCategories[currentUi.category.value];
			AngryLeaderboards.RecordDifficulty difficulty = dropdownDifficulties[currentUi.difficulty.value];
			if (category == AngryLeaderboards.RecordCategory.NOMO || category == AngryLeaderboards.RecordCategory.NOMOW)
			{
				difficulty = AngryLeaderboards.RecordDifficulty.HARMLESS;
			}
			bool allFilter = currentUi.group.value == 0;
			SteamId steamId3;
			if (getLocalUser)
			{
				AngryLeaderboards.RecordCategory category2 = category;
				AngryLeaderboards.RecordDifficulty difficulty2 = difficulty;
				string text = bundleGuid;
				string text2 = levelId;
				steamId3 = SteamClient.SteamId;
				AngryLeaderboards.GetUserRecordResult localUserResult = await AngryLeaderboards.GetUserRecordTask(category2, difficulty2, text, text2, ((object)(SteamId)(ref steamId3)).ToString());
				if ((Object)(object)currentUi != (Object)null)
				{
					if (SteamCacheManager.TryGetUser(SteamId.op_Implicit(SteamClient.SteamId), out var user2))
					{
						currentUi.localUserPfp.texture = (Texture)(object)user2.profilePicture;
					}
					else
					{
						RawImage localUserPfp = currentUi.localUserPfp;
						localUserPfp.texture = (Texture)(object)(await SteamCacheManager.RequestUser(SteamId.op_Implicit(SteamClient.SteamId))).profilePicture;
					}
					currentUi.localUserName.text = SteamClient.Name;
					if (localUserResult.completedSuccessfully && localUserResult.status == AngryLeaderboards.GetUserRecordStatus.OK)
					{
						currentUi.localUserRank.text = ((localUserResult.response.ranking == -1) ? "#?" : $"#{localUserResult.response.ranking}");
						if (difficulty == AngryLeaderboards.RecordDifficulty.ANY && localUserResult.response.ranking != -1)
						{
							Text localUserName = currentUi.localUserName;
							localUserName.text = localUserName.text + "\n<color=grey>" + localUserResult.response.difficulty + "</color>";
						}
						currentUi.localUserTime.text = ((localUserResult.response.ranking == -1) ? "--:--.---" : MillisecondsToString(localUserResult.response.time));
					}
					else
					{
						currentUi.localUserRank.text = "#?";
						currentUi.localUserTime.text = "--:--.---";
					}
				}
			}
			_ = currentPage;
			int num;
			if (allFilter)
			{
				AngryLeaderboards.GetRecordsResult getRecordsResult = await AngryLeaderboards.GetRecordsTask(category, difficulty, bundleGuid, levelId, currentPage * 5, 5);
				totalRecordCount = getRecordsResult.response.totalCount;
				num = ((totalRecordCount != 0) ? ((totalRecordCount - 1) / 5) : 0);
				if ((Object)(object)currentUi != (Object)null)
				{
					if (!getRecordsResult.completedSuccessfully)
					{
						currentUi.failMessage.text = (getRecordsResult.networkError ? "Network Error\nCheck connection" : "Server Error\nTry again later");
						((Component)currentUi.failMessage).gameObject.SetActive(true);
						((Component)currentUi.refreshButton).gameObject.SetActive(true);
						return;
					}
					if (getRecordsResult.status != 0)
					{
						((Component)currentUi.refreshButton).gameObject.SetActive(true);
						switch (getRecordsResult.status)
						{
						case AngryLeaderboards.GetRecordsStatus.INVALID_BUNDLE:
						case AngryLeaderboards.GetRecordsStatus.INVALID_ID:
							currentUi.failMessage.text = "Leaderboards disabled for this level";
							((Component)currentUi.refreshButton).gameObject.SetActive(false);
							break;
						case AngryLeaderboards.GetRecordsStatus.RATE_LIMITED:
							currentUi.failMessage.text = "Too many requests";
							break;
						default:
							currentUi.failMessage.text = $"Status Error\n{getRecordsResult.status}";
							break;
						}
						((Component)currentUi.failMessage).gameObject.SetActive(true);
						return;
					}
					if (currentPage > num)
					{
						currentPage = num;
						currentUi.pageInput.SetTextWithoutNotify((currentPage + 1).ToString());
						await ReloadTask(getLocalUser: false);
						return;
					}
					for (int i = 0; i < getRecordsResult.response.records.Length; i++)
					{
						AngryLeaderboardRecordEntryComponent entry2 = Object.Instantiate<AngryLeaderboardRecordEntryComponent>(currentUi.recordTemplate, currentUi.recordContainer);
						string entryDifficulty2 = ((difficulty == AngryLeaderboards.RecordDifficulty.ANY) ? getRecordsResult.response.records[i].difficulty : "");
						entry2.rank.text = $"#{getRecordsResult.response.offset + i + 1}";
						entry2.time.text = MillisecondsToString(getRecordsResult.response.records[i].time);
						ulong steamId2 = ulong.Parse(getRecordsResult.response.records[i].steamId);
						steamId3 = SteamClient.SteamId;
						string text3 = ((object)(SteamId)(ref steamId3)).ToString();
						if (steamId2.ToString() == text3)
						{
							((Selectable)entry2.reportButton).interactable = false;
						}
						entry2.username.text = "<color=grey>Loading...</color>";
						if (difficulty == AngryLeaderboards.RecordDifficulty.ANY)
						{
							Text username = entry2.username;
							username.text = username.text + "\n<color=grey>" + entryDifficulty2 + "</color>";
						}
						AngryLeaderboards.RecordDifficulty actualDifficulty = ((difficulty == AngryLeaderboards.RecordDifficulty.ANY) ? AngryLeaderboards.RECORD_DIFFICULTY_REVERSE_DICT[getRecordsResult.response.records[i].difficulty] : difficulty);
						bool flag = getRecordsResult.response.records[i].steamId == text3;
						bool censorIcon = !flag && getRecordsResult.response.records[i].censorIcon;
						bool censorName = !flag && getRecordsResult.response.records[i].censorName;
						SteamCacheManager.RequestUser(steamId2, delegate(SteamUserCache user)
						{
							//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
							//IL_00c9: Expected O, but got Unknown
							if (!((Object)(object)entry2 == (Object)null))
							{
								entry2.username.text = (censorName ? "(hidden)" : user.name);
								if (difficulty == AngryLeaderboards.RecordDifficulty.ANY)
								{
									Text username4 = entry2.username;
									username4.text = username4.text + "\n<color=grey>" + entryDifficulty2 + "</color>";
								}
								if (!censorIcon)
								{
									entry2.profile.texture = (Texture)(object)user.profilePicture;
								}
								((UnityEvent)entry2.reportButton.onClick).AddListener((UnityAction)delegate
								{
									if (AngryUser.hasLeaderboardPermissions)
									{
										ManageButton(steamId2.ToString(), category, actualDifficulty);
									}
									else
									{
										ReportButton(steamId2.ToString(), user.name);
									}
								});
							}
						});
						((Component)entry2).gameObject.SetActive(true);
					}
				}
			}
			else
			{
				if (friendRecords == null)
				{
					AngryLeaderboards.RecordCategory category3 = category;
					AngryLeaderboards.RecordDifficulty difficulty3 = difficulty;
					string text4 = bundleGuid;
					string text5 = levelId;
					IEnumerable<string?> first = from f in SteamFriends.GetFriends()
						select ((object)(SteamId)(ref f.Id)).ToString();
					string[] array = new string[1];
					steamId3 = SteamClient.SteamId;
					array[0] = ((object)(SteamId)(ref steamId3)).ToString();
					AngryLeaderboards.GetUserRecordsResult getUserRecordsResult = await AngryLeaderboards.GetUserRecordsTask(category3, difficulty3, text4, text5, first.Concat<string>(array.AsEnumerable()));
					if (getUserRecordsResult.completedSuccessfully && getUserRecordsResult.status == AngryLeaderboards.GetUserRecordsStatus.OK)
					{
						friendRecords = getUserRecordsResult.response.records;
					}
					if ((Object)(object)currentUi != (Object)null)
					{
						if (!getUserRecordsResult.completedSuccessfully)
						{
							currentUi.failMessage.text = (getUserRecordsResult.networkError ? "Network Error\nCheck connection" : "Server Error\nTry again later");
							((Component)currentUi.failMessage).gameObject.SetActive(true);
							((Component)currentUi.refreshButton).gameObject.SetActive(true);
							return;
						}
						if (getUserRecordsResult.status != 0)
						{
							((Component)currentUi.refreshButton).gameObject.SetActive(true);
							switch (getUserRecordsResult.status)
							{
							case AngryLeaderboards.GetUserRecordsStatus.INVALID_BUNDLE:
							case AngryLeaderboards.GetUserRecordsStatus.INVALID_ID:
								currentUi.failMessage.text = "Leaderboards disabled for this level";
								((Component)currentUi.refreshButton).gameObject.SetActive(false);
								break;
							case AngryLeaderboards.GetUserRecordsStatus.RATE_LIMITED:
								currentUi.failMessage.text = "Too many requests";
								break;
							default:
								currentUi.failMessage.text = $"Status Error\n{getUserRecordsResult.status}";
								break;
							}
							((Component)currentUi.failMessage).gameObject.SetActive(true);
							return;
						}
					}
				}
				totalRecordCount = friendRecords.Length;
				num = ((totalRecordCount != 0) ? ((totalRecordCount - 1) / 5) : 0);
				if (currentPage > num)
				{
					currentPage = num;
					currentUi.pageInput.SetTextWithoutNotify((currentPage + 1).ToString());
					await ReloadTask(getLocalUser: false);
					return;
				}
				if ((Object)(object)currentUi != (Object)null)
				{
					int num2 = Math.Min(5, friendRecords.Length - currentPage * 5);
					for (int j = 0; j < num2; j++)
					{
						int realIndex = j + currentPage * 5;
						AngryLeaderboardRecordEntryComponent entry = Object.Instantiate<AngryLeaderboardRecordEntryComponent>(currentUi.recordTemplate, currentUi.recordContainer);
						string entryDifficulty = ((difficulty == AngryLeaderboards.RecordDifficulty.ANY) ? friendRecords[realIndex].difficulty : "");
						entry.rank.text = $"#{currentPage * 5 + j + 1}";
						entry.time.text = MillisecondsToString(friendRecords[realIndex].time);
						ulong steamId = ulong.Parse(friendRecords[realIndex].steamId);
						string text6 = steamId.ToString();
						steamId3 = SteamClient.SteamId;
						if (text6 == ((object)(SteamId)(ref steamId3)).ToString())
						{
							((Selectable)entry.reportButton).interactable = false;
						}
						entry.username.text = $"<color=grey>Loading...</color> <color=silver>(global #{friendRecords[realIndex].globalRank})</color>";
						if (difficulty == AngryLeaderboards.RecordDifficulty.ANY)
						{
							Text username2 = entry.username;
							username2.text = username2.text + "\n<color=grey>" + entryDifficulty + "</color>";
						}
						SteamCacheManager.RequestUser(steamId, delegate(SteamUserCache user)
						{
							//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
							//IL_00dd: Expected O, but got Unknown
							if (!((Object)(object)entry == (Object)null))
							{
								entry.username.text = $"{user.name} <color=silver>(global #{friendRecords[realIndex].globalRank})</color>";
								if (difficulty == AngryLeaderboards.RecordDifficulty.ANY)
								{
									Text username3 = entry.username;
									username3.text = username3.text + "\n<color=grey>" + entryDifficulty + "</color>";
								}
								entry.profile.texture = (Texture)(object)user.profilePicture;
								((UnityEvent)entry.reportButton.onClick).AddListener((UnityAction)delegate
								{
									ReportButton(steamId.ToString(), user.name);
								});
							}
						});
						((Component)entry).gameObject.SetActive(true);
					}
				}
			}
			if ((Object)(object)currentUi != (Object)null)
			{
				currentUi.localUserRecordContainer.SetActive(true);
				currentUi.recordEnabler.SetActive(true);
				((Selectable)currentUi.pageInput).interactable = true;
				if (currentPage != 0)
				{
					((Selectable)currentUi.prevPage).interactable = true;
				}
				if (currentPage < num)
				{
					((Selectable)currentUi.nextPage).interactable = true;
				}
			}
		}

		private void ReportButton(string steamId, string username)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Expected O, but got Unknown
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Expected O, but got Unknown
			string text = steamId;
			SteamId steamId2 = SteamClient.SteamId;
			if (!(text == ((object)(SteamId)(ref steamId2)).ToString()))
			{
				currentUi.reportFormToggle.gameObject.SetActive(true);
				currentUi.reportResultToggle.gameObject.SetActive(false);
				currentUi.reportBody.text = "Report <color=#00FFFF>" + username + "</color>?";
				ResetReportUI();
				currentUi.reportSend.onClick = new ButtonClickedEvent();
				((UnityEvent)currentUi.reportSend.onClick).AddListener((UnityAction)delegate
				{
					SendReport(steamId, username);
				});
				currentUi.reportToggle.SetActive(true);
			}
		}

		private void ManageButton(string steamId, AngryLeaderboards.RecordCategory category, AngryLeaderboards.RecordDifficulty difficulty)
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Expected O, but got Unknown
			//IL_0162: Unknown result type (might be due to invalid IL or missing references)
			//IL_016c: Expected O, but got Unknown
			//IL_0188: Unknown result type (might be due to invalid IL or missing references)
			//IL_0192: Expected O, but got Unknown
			//IL_01a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ac: Expected O, but got Unknown
			//IL_01c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d2: Expected O, but got Unknown
			//IL_01e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ec: Expected O, but got Unknown
			//IL_0208: Unknown result type (might be due to invalid IL or missing references)
			//IL_0212: Expected O, but got Unknown
			string text = steamId;
			SteamId steamId2 = SteamClient.SteamId;
			if (text == ((object)(SteamId)(ref steamId2)).ToString())
			{
				return;
			}
			currentUi.manageUserPanel.managePanel.SetActive(true);
			currentUi.manageUserPanel.resultPanel.SetActive(false);
			currentUi.manageUserPanel.userInfo.text = "Loading...";
			currentUi.manageUserPanel.userIcon.texture = (Texture)(object)unknownProfile;
			currentUi.manageUserPanel.cencorProfilePicture.isOn = false;
			currentUi.manageUserPanel.cencorProfileName.isOn = false;
			currentUi.manageUserPanel.banUser.isOn = false;
			currentUi.manageUserPanel.removeRecord.isOn = true;
			currentUi.manageUserPanel.removeAll.isOn = false;
			currentUi.manageUserPanel.removeRecord.onValueChanged = new ToggleEvent();
			((UnityEvent<bool>)(object)currentUi.manageUserPanel.removeRecord.onValueChanged).AddListener((UnityAction<bool>)delegate(bool e)
			{
				((Selectable)currentUi.manageUserPanel.removeAll).interactable = e;
				if (!e)
				{
					currentUi.manageUserPanel.removeAll.isOn = false;
				}
			});
			currentUi.manageUserPanel.cancelManage.onClick = new ButtonClickedEvent();
			((UnityEvent)currentUi.manageUserPanel.cancelManage.onClick).AddListener((UnityAction)delegate
			{
				((Component)currentUi.manageUserPanel).gameObject.SetActive(false);
			});
			currentUi.manageUserPanel.applyManage.onClick = new ButtonClickedEvent();
			((UnityEvent)currentUi.manageUserPanel.applyManage.onClick).AddListener((UnityAction)delegate
			{
				if (currentUi.manageUserPanel.removeAll.isOn)
				{
					OpenWarningWindow(steamId, category, difficulty);
				}
				else
				{
					ManageUser(steamId, category, difficulty).ContinueWith(delegate
					{
						((Selectable)currentUi.manageUserPanel.returnButton).interactable = true;
					}, TaskScheduler.FromCurrentSynchronizationContext());
					currentUi.manageUserPanel.resultPanel.SetActive(true);
				}
			});
			currentUi.manageUserPanel.historyButton.onClick = new ButtonClickedEvent();
			((UnityEvent)currentUi.manageUserPanel.historyButton.onClick).AddListener((UnityAction)delegate
			{
				currentUi.manageUserPanel.managePanel.SetActive(false);
				((Component)currentUi.manageUserPanel).gameObject.SetActive(false);
				OpenHistoryWindow(steamId);
			});
			string name = steamId;
			if (ulong.TryParse(steamId, out var result) && SteamCacheManager.TryGetUser(result, out var user))
			{
				name = user.name;
				RawImage userIcon = currentUi.manageUserPanel.userIcon;
				Texture texture = (currentUi.manageUserPanel.warningUserIcon.texture = (Texture)(object)user.profilePicture);
				userIcon.texture = texture;
			}
			AngryLeaderboards.GetUserInfoTask(steamId).ContinueWith(delegate(Task<AngryLeaderboards.GetUserInfoResult> res)
			{
				if (!res.IsCompletedSuccessfully)
				{
					currentUi.manageUserPanel.userInfo.text = "<color=red>Failed to obtain user info!</color>";
				}
				else if (!res.Result.completedSuccessfully || res.Result.status != 0)
				{
					currentUi.manageUserPanel.userInfo.text = "<color=red>Failed to obtain user info!\n" + res.Result.message + "</color>";
				}
				else
				{
					string text2 = "Banned: " + (res.Result.response.leaderboardBanned ? "<color=red>yes</color>" : "<color=green>no</color>");
					Text userInfo = currentUi.manageUserPanel.userInfo;
					string text4 = (currentUi.manageUserPanel.warningUserInfo.text = $"{name}\n{text2}\nRecord count: {res.Result.response.recordCount}\nReceived reports: {res.Result.response.reportCount}\nRemoved records: {res.Result.response.removedRecordCount}");
					userInfo.text = text4;
				}
			}, TaskScheduler.FromCurrentSynchronizationContext());
			((Component)currentUi.manageUserPanel).gameObject.SetActive(true);
		}

		private void SendReport(string steamId, string username)
		{
			currentUi.reportFormToggle.SetActive(false);
			((Selectable)currentUi.reportReturn).interactable = false;
			currentUi.reportLoadCircle.SetActive(true);
			currentUi.reportBody.text = "Sending...";
			currentUi.reportResultToggle.SetActive(true);
			string text = "";
			if (currentUi.inappropriateName.isOn)
			{
				text += "INAPPROPRIATE NAME, ";
			}
			if (currentUi.inappropriatePicture.isOn)
			{
				text += "INAPPROPRIATE PICTURE, ";
			}
			if (currentUi.cheatedScore.isOn)
			{
				text += "CHEATED SCORE, ";
			}
			AngryUser.ReportTask(AngryLeaderboards.RECORD_CATEGORY_DICT[dropdownCategories[currentUi.category.value]], AngryLeaderboards.RECORD_DIFFICULTY_DICT[dropdownDifficulties[currentUi.difficulty.value]], bundleGuid, levelId, steamId, text).ContinueWith(delegate(Task<AngryUser.ReportResult> task)
			{
				if (!((Object)(object)currentUi == (Object)null))
				{
					currentUi.reportLoadCircle.SetActive(false);
					((Selectable)currentUi.reportReturn).interactable = true;
					AngryUser.ReportResult result = task.Result;
					if (result.completedSuccessfully)
					{
						switch (result.status)
						{
						case AngryUser.ReportStatus.OK:
							currentUi.reportBody.text = (result.response.alreadySent ? "Report updated" : "Report sent successfuly");
							break;
						case AngryUser.ReportStatus.INVALID_ENTRY:
							currentUi.reportBody.text = "Record no longer exists";
							break;
						case AngryUser.ReportStatus.BANNED:
							currentUi.reportBody.text = "You have been banned from sending reports";
							break;
						case AngryUser.ReportStatus.RATE_LIMITED:
							currentUi.reportBody.text = "Too many requests, try again later";
							break;
						case AngryUser.ReportStatus.INVALID_TARGET_ID:
							currentUi.reportBody.text = "Target steam ID not found";
							break;
						default:
							currentUi.reportBody.text = $"Unknown error. Message: '{result.message}'. Status: {result.status}";
							break;
						}
					}
					else if (result.networkError)
					{
						currentUi.reportBody.text = "Network error, check connection";
					}
					else if (result.httpError)
					{
						currentUi.reportBody.text = "Server error, try again later";
					}
					else
					{
						currentUi.reportBody.text = "Could not send the report due to an unknown error";
					}
				}
			}, TaskScheduler.FromCurrentSynchronizationContext());
		}

		private async Task OpenWarningWindow(string steamId, AngryLeaderboards.RecordCategory category, AngryLeaderboards.RecordDifficulty difficulty)
		{
			currentUi.manageUserPanel.managePanel.SetActive(false);
			currentUi.manageUserPanel.resultPanel.SetActive(false);
			CancellationTokenSource cancelSource = new CancellationTokenSource();
			cancelSource.Token.ThrowIfCancellationRequested();
			currentUi.manageUserPanel.warningCancelButton.onClick = new ButtonClickedEvent();
			((UnityEvent)currentUi.manageUserPanel.warningCancelButton.onClick).AddListener((UnityAction)delegate
			{
				cancelSource.Cancel();
				currentUi.manageUserPanel.warningPanel.SetActive(false);
				((Component)currentUi.manageUserPanel).gameObject.SetActive(false);
			});
			currentUi.manageUserPanel.warningSubmitButton.onClick = new ButtonClickedEvent();
			((UnityEvent)currentUi.manageUserPanel.warningSubmitButton.onClick).AddListener((UnityAction)delegate
			{
				ManageUser(steamId, category, difficulty).ContinueWith(delegate
				{
					((Selectable)currentUi.manageUserPanel.returnButton).interactable = true;
				}, TaskScheduler.FromCurrentSynchronizationContext());
				currentUi.manageUserPanel.resultPanel.SetActive(true);
			});
			((Selectable)currentUi.manageUserPanel.warningSubmitButton).interactable = false;
			currentUi.manageUserPanel.warningPanel.SetActive(true);
			for (int i = 5; i > 0; i--)
			{
				currentUi.manageUserPanel.warningSubmitButtonText.text = $"Remove All ({i})";
				try
				{
					await Task.Delay(1000, cancelSource.Token);
				}
				catch (OperationCanceledException)
				{
					return;
				}
			}
			currentUi.manageUserPanel.warningSubmitButtonText.text = "Remove All";
			((Selectable)currentUi.manageUserPanel.warningSubmitButton).interactable = true;
		}

		private async Task ManageUser(string steamId, AngryLeaderboards.RecordCategory category, AngryLeaderboards.RecordDifficulty difficulty)
		{
			currentUi.manageUserPanel.managePanel.SetActive(false);
			currentUi.manageUserPanel.warningPanel.SetActive(false);
			bool isOn = currentUi.manageUserPanel.cencorProfilePicture.isOn;
			bool isOn2 = currentUi.manageUserPanel.cencorProfileName.isOn;
			bool isOn3 = currentUi.manageUserPanel.banUser.isOn;
			bool removeRecord = currentUi.manageUserPanel.removeRecord.isOn;
			bool removeAll = currentUi.manageUserPanel.removeAll.isOn;
			currentUi.manageUserPanel.returnButton.onClick = new ButtonClickedEvent();
			((UnityEvent)currentUi.manageUserPanel.returnButton.onClick).AddListener((UnityAction)delegate
			{
				currentUi.manageUserPanel.resultPanel.SetActive(false);
				((Component)currentUi.manageUserPanel).gameObject.SetActive(false);
				Reload(getLocalUser: false);
			});
			if (!isOn && !isOn2 && !isOn3 && !removeRecord && !removeAll)
			{
				currentUi.manageUserPanel.resultText.text = "Nothing to do";
				currentUi.manageUserPanel.resultPanel.SetActive(true);
				return;
			}
			((Selectable)currentUi.manageUserPanel.returnButton).interactable = false;
			currentUi.manageUserPanel.resultText.text = "";
			if (isOn || isOn2 || isOn3)
			{
				Text resultText = currentUi.manageUserPanel.resultText;
				resultText.text += "Managing user... ";
				AngryLeaderboards.ManageUserResult manageUserResult = await AngryLeaderboards.ManageUserTask(steamId, isOn, isOn2, isOn3);
				Text resultText2 = currentUi.manageUserPanel.resultText;
				resultText2.text += ((!manageUserResult.completedSuccessfully || manageUserResult.status != 0) ? ("<color=red>" + manageUserResult.message + "</color>\n") : "<color=green>Success!</color>\n");
			}
			if (removeAll)
			{
				Text resultText3 = currentUi.manageUserPanel.resultText;
				resultText3.text += "Removing all records... ";
				AngryLeaderboards.ClearRecordsResult clearRecordsResult = await AngryLeaderboards.ClearRecordsTask(steamId);
				Text resultText4 = currentUi.manageUserPanel.resultText;
				resultText4.text += ((!clearRecordsResult.completedSuccessfully || clearRecordsResult.status != 0) ? ("<color=red>" + clearRecordsResult.message + "</color>\n") : $"<color=green>Removed {clearRecordsResult.response.removedRecordCount} records!</color>\n");
			}
			else if (removeRecord)
			{
				Text resultText5 = currentUi.manageUserPanel.resultText;
				resultText5.text += "Removing record... ";
				AngryLeaderboards.RemoveRecordResult removeRecordResult = await AngryLeaderboards.RemoveRecordTask(steamId, bundleGuid, levelId, category, difficulty);
				Text resultText6 = currentUi.manageUserPanel.resultText;
				resultText6.text += ((!removeRecordResult.completedSuccessfully || removeRecordResult.status != 0) ? ("<color=red>" + removeRecordResult.message + "</color>\n") : "<color=green>Success!</color>\n");
			}
		}

		private async Task OpenHistoryWindow(string steamId)
		{
			currentUi.historyPanel.backButton.onClick = new ButtonClickedEvent();
			((UnityEvent)currentUi.historyPanel.backButton.onClick).AddListener((UnityAction)delegate
			{
				((Component)currentUi.historyPanel).gameObject.SetActive(false);
			});
			currentUi.historyPanel.categoryFilter.onValueChanged = new DropdownEvent();
			currentUi.historyPanel.difficultyFilter.onValueChanged = new DropdownEvent();
			currentUi.historyPanel.sortOrder.onValueChanged = new DropdownEvent();
			currentUi.historyPanel.reverseOrder.onValueChanged = new ToggleEvent();
			currentUi.historyPanel.bundleName.onEndEdit = new EndEditEvent();
			currentUi.historyPanel.levelName.onEndEdit = new EndEditEvent();
			currentUi.historyPanel.categoryFilter.value = 0;
			currentUi.historyPanel.difficultyFilter.value = 0;
			currentUi.historyPanel.sortOrder.value = 0;
			currentUi.historyPanel.reverseOrder.isOn = false;
			currentUi.historyPanel.bundleName.SetTextWithoutNotify("");
			currentUi.historyPanel.levelName.SetTextWithoutNotify("");
			currentUi.historyPanel.inputGroup.interactable = false;
			historyEntries.ForEach(delegate(AngryUserRecordEntryComponent e)
			{
				((Component)e).gameObject.SetActive(false);
			});
			currentUi.historyPanel.loadingCircle.SetActive(true);
			string steamName = steamId;
			if (ulong.TryParse(steamId, out var result) && SteamCacheManager.TryGetUser(result, out var user))
			{
				steamName = user.name + " (" + steamId + ")";
				currentUi.historyPanel.userIcon.texture = (Texture)(object)user.profilePicture;
			}
			else
			{
				currentUi.historyPanel.userIcon.texture = (Texture)(object)unknownProfile;
			}
			currentUi.historyPanel.userInfo.text = steamName + "\nLoading...";
			((Component)currentUi.historyPanel).gameObject.SetActive(true);
			AngryLeaderboards.GetUserHistoryResult getUserHistoryResult = await AngryLeaderboards.GetUserHistoryTask(steamId);
			currentUi.historyPanel.loadingCircle.SetActive(false);
			if (!getUserHistoryResult.completedSuccessfully || getUserHistoryResult.status != 0)
			{
				currentUi.historyPanel.userInfo.text = steamName + "\n<color=red>" + getUserHistoryResult.message + "</color>";
				return;
			}
			Regex richText = new Regex("<[^>]*>");
			AngryLeaderboards.GetUserHistoryResponse history = getUserHistoryResult.response;
			int pageNum = 0;
			Dictionary<int, string> bundlePkToGuid = history.bundleGuidPK.ToDictionary((KeyValuePair<string, int> pair) => pair.Value, (KeyValuePair<string, int> pair) => pair.Key);
			Dictionary<int, string> levelPkToId = history.levelIdPK.ToDictionary((KeyValuePair<string, int> pair) => pair.Value, (KeyValuePair<string, int> pair) => pair.Key);
			Dictionary<string, string> bundleGuidToName = history.bundleGuidPK.ToDictionary((KeyValuePair<string, int> pair) => pair.Key, delegate(KeyValuePair<string, int> pair)
			{
				BundleInfo bundleInfo2 = OnlineCatalogManager.Catalog.Levels.Where((BundleInfo b) => b.Guid == pair.Key).FirstOrDefault();
				return (bundleInfo2 != null) ? bundleInfo2.Name : pair.Key;
			});
			Dictionary<string, string> levelIdToName = history.levelIdPK.ToDictionary((KeyValuePair<string, int> pair) => pair.Key, delegate(KeyValuePair<string, int> pair)
			{
				LevelInfo levelInfo2 = (from l in OnlineCatalogManager.Catalog.Levels.Select((BundleInfo b) => b.Levels).SelectMany((List<LevelInfo> x) => x)
					where l.LevelId == pair.Key
					select l).FirstOrDefault();
				return (levelInfo2 != null) ? levelInfo2.LevelName : pair.Key;
			});
			Dictionary<int, string> categoryMap = new Dictionary<int, string>
			{
				{ 0, "all" },
				{ 1, "p rank" },
				{ 2, "challenge" },
				{ 3, "no monsters" },
				{ 4, "no monsters & weapons" }
			};
			Dictionary<int, string> difficultyMap = new Dictionary<int, string>
			{
				{ 0, "harmless" },
				{ 1, "lenient" },
				{ 2, "standard" },
				{ 3, "violent" },
				{ 4, "brutal" }
			};
			List<int[]> filteredHistory = new List<int[]>();
			currentUi.historyPanel.nextPageButton.onClick = new ButtonClickedEvent();
			currentUi.historyPanel.prevPageButton.onClick = new ButtonClickedEvent();
			currentUi.historyPanel.pageNumber.onSubmit = new SubmitEvent();
			((UnityEvent)currentUi.historyPanel.nextPageButton.onClick).AddListener((UnityAction)delegate
			{
				pageNum = Math.Clamp(pageNum + 1, 0, Math.Max(0, (filteredHistory.Count - 1) / 100));
				currentUi.historyPanel.pageNumber.SetTextWithoutNotify((pageNum + 1).ToString());
				RefreshList(sort: false);
			});
			((UnityEvent)currentUi.historyPanel.prevPageButton.onClick).AddListener((UnityAction)delegate
			{
				pageNum = Math.Clamp(pageNum - 1, 0, Math.Max(0, (filteredHistory.Count - 1) / 100));
				currentUi.historyPanel.pageNumber.SetTextWithoutNotify((pageNum + 1).ToString());
				RefreshList(sort: false);
			});
			((UnityEvent<string>)(object)currentUi.historyPanel.pageNumber.onSubmit).AddListener((UnityAction<string>)delegate(string e)
			{
				if (!int.TryParse(e, out var result2))
				{
					currentUi.historyPanel.pageNumber.SetTextWithoutNotify((pageNum + 1).ToString());
				}
				else
				{
					pageNum = Math.Clamp(result2 - 1, 0, Math.Max(0, (filteredHistory.Count - 1) / 100));
					currentUi.historyPanel.pageNumber.SetTextWithoutNotify((pageNum + 1).ToString());
					RefreshList(sort: false);
				}
			});
			((UnityEvent<int>)(object)currentUi.historyPanel.categoryFilter.onValueChanged).AddListener((UnityAction<int>)delegate
			{
				ReloadData();
			});
			((UnityEvent<int>)(object)currentUi.historyPanel.difficultyFilter.onValueChanged).AddListener((UnityAction<int>)delegate
			{
				ReloadData();
			});
			((UnityEvent<int>)(object)currentUi.historyPanel.sortOrder.onValueChanged).AddListener((UnityAction<int>)delegate
			{
				RefreshList(sort: true);
			});
			((UnityEvent<bool>)(object)currentUi.historyPanel.reverseOrder.onValueChanged).AddListener((UnityAction<bool>)delegate
			{
				RefreshList(sort: true);
			});
			((UnityEvent<string>)(object)currentUi.historyPanel.bundleName.onEndEdit).AddListener((UnityAction<string>)delegate
			{
				ReloadData();
			});
			((UnityEvent<string>)(object)currentUi.historyPanel.levelName.onEndEdit).AddListener((UnityAction<string>)delegate
			{
				ReloadData();
			});
			currentUi.historyPanel.inputGroup.interactable = true;
			ReloadData();
			void RefreshList(bool sort)
			{
				currentUi.historyPanel.userInfo.text = $"{steamName}\nTotal records: {history.runHistory.Length}\nTotal filtered: {filteredHistory.Count}";
				historyEntries.ForEach(delegate(AngryUserRecordEntryComponent e)
				{
					((Component)e).gameObject.SetActive(false);
				});
				if (sort)
				{
					switch (currentUi.historyPanel.sortOrder.value)
					{
					case 0:
						if (currentUi.historyPanel.reverseOrder.isOn)
						{
							filteredHistory.Sort((int[] e1, int[] e2) => e2[0] - e1[0]);
						}
						else
						{
							filteredHistory.Sort((int[] e1, int[] e2) => e1[0] - e2[0]);
						}
						break;
					case 1:
						if (currentUi.historyPanel.reverseOrder.isOn)
						{
							filteredHistory.Sort((int[] e1, int[] e2) => e2[5] - e1[5]);
						}
						else
						{
							filteredHistory.Sort((int[] e1, int[] e2) => e1[5] - e2[5]);
						}
						break;
					case 2:
					{
						Dictionary<int, int> bundleIdToOrder = (from pair in history.bundleGuidPK.Select(delegate(KeyValuePair<string, int> pair)
							{
								BundleInfo bundleInfo = OnlineCatalogManager.Catalog.Levels.Where((BundleInfo b) => b.Guid == pair.Key).FirstOrDefault();
								return new KeyValuePair<int, string>(pair.Value, (bundleInfo == null) ? null : richText.Replace(bundleInfo.Name, string.Empty).ToLower());
							})
							where pair.Value != null
							orderby pair.Value
							select pair).Select((KeyValuePair<int, string> pair, int i) => new KeyValuePair<int, int>(pair.Key, i)).ToDictionary((KeyValuePair<int, int> pair) => pair.Key, (KeyValuePair<int, int> pair) => pair.Value);
						if (currentUi.historyPanel.reverseOrder.isOn)
						{
							filteredHistory.Sort((int[] e1, int[] e2) => bundleIdToOrder[e2[1]] - bundleIdToOrder[e1[1]]);
						}
						else
						{
							filteredHistory.Sort((int[] e1, int[] e2) => bundleIdToOrder[e1[1]] - bundleIdToOrder[e2[1]]);
						}
						break;
					}
					case 3:
					{
						Dictionary<int, int> levelIdToOrder = (from pair in history.levelIdPK.Select(delegate(KeyValuePair<string, int> pair)
							{
								LevelInfo levelInfo = (from l in OnlineCatalogManager.Catalog.Levels.Select((BundleInfo b) => b.Levels).SelectMany((List<LevelInfo> x) => x)
									where l.LevelId == pair.Key
									select l).FirstOrDefault();
								return new KeyValuePair<int, string>(pair.Value, (levelInfo == null) ? null : richText.Replace(levelInfo.LevelName, string.Empty).ToLower());
							})
							where pair.Value != null
							orderby pair.Value
							select pair).Select((KeyValuePair<int, string> pair, int i) => new KeyValuePair<int, int>(pair.Key, i)).ToDictionary((KeyValuePair<int, int> pair) => pair.Key, (KeyValuePair<int, int> pair) => pair.Value);
						if (currentUi.historyPanel.reverseOrder.isOn)
						{
							filteredHistory.Sort((int[] e1, int[] e2) => levelIdToOrder[e2[2]] - levelIdToOrder[e1[2]]);
						}
						else
						{
							filteredHistory.Sort((int[] e1, int[] e2) => levelIdToOrder[e1[2]] - levelIdToOrder[e2[2]]);
						}
						break;
					}
					case 4:
						if (currentUi.historyPanel.reverseOrder.isOn)
						{
							filteredHistory.Sort((int[] e1, int[] e2) => e2[3] - e1[3]);
						}
						else
						{
							filteredHistory.Sort((int[] e1, int[] e2) => e1[3] - e2[3]);
						}
						break;
					case 5:
						if (currentUi.historyPanel.reverseOrder.isOn)
						{
							filteredHistory.Sort((int[] e1, int[] e2) => e2[4] - e1[4]);
						}
						else
						{
							filteredHistory.Sort((int[] e1, int[] e2) => e1[4] - e2[4]);
						}
						break;
					}
				}
				int num = Math.Max(0, pageNum * 100);
				for (int j = 0; j < 100; j++)
				{
					int num2 = num + j;
					if (num2 >= filteredHistory.Count)
					{
						break;
					}
					if (num2 >= historyEntries.Count)
					{
						AngryUserRecordEntryComponent component = Object.Instantiate<GameObject>(((Component)currentUi.historyPanel.template).gameObject, ((Component)currentUi.historyPanel.template).transform.parent).GetComponent<AngryUserRecordEntryComponent>();
						historyEntries.Add(component);
					}
					AngryUserRecordEntryComponent entry = historyEntries[j];
					int[] array3 = filteredHistory[num2];
					string key2 = bundlePkToGuid[array3[1]];
					string key3 = levelPkToId[array3[2]];
					string text = new DateTime(1970, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc).AddSeconds(array3[0]).ToString("d");
					((TMP_Text)entry.bundleInfo).text = bundleGuidToName[key2] + " -- " + levelIdToName[key3];
					((TMP_Text)entry.recordInfo).text = "<color=grey>Posted on " + text + "</color>\nCategory: " + categoryMap[array3[3]] + "\nDifficulty: " + difficultyMap[array3[4]];
					((TMP_Text)entry.time).text = MillisecondsToString(array3[5]);
					AngryOnlineThumbnailCache.GetThumbnail(key2).ContinueWith(delegate(Task<Texture2D> res)
					{
						entry.bundleIcon.texture = (Texture)(object)res.Result;
					}, TaskScheduler.FromCurrentSynchronizationContext());
					AngryLevelThumbnailCache.GetThumbnail(key2, key3).ContinueWith(delegate(Task<Texture2D> res)
					{
						entry.levelIcon.texture = (Texture)(object)res.Result;
					}, TaskScheduler.FromCurrentSynchronizationContext());
					((Component)entry).gameObject.SetActive(true);
				}
			}
			void ReloadData()
			{
				IEnumerable<int[]> enumerable = history.runHistory;
				int categoryFilter = currentUi.historyPanel.categoryFilter.value - 1;
				if (categoryFilter != -1)
				{
					enumerable = enumerable.Where((int[] e) => e[3] == categoryFilter);
				}
				int difficultyFilter = currentUi.historyPanel.difficultyFilter.value - 1;
				if (difficultyFilter != -1)
				{
					enumerable = enumerable.Where((int[] e) => e[4] == difficultyFilter);
				}
				char[] separator = new char[1] { ' ' };
				string[] array = (from keyword in currentUi.historyPanel.bundleName.text.Split(separator, StringSplitOptions.RemoveEmptyEntries)
					select keyword.ToLower()).ToArray();
				string[] array2 = (from keyword in currentUi.historyPanel.levelName.text.Split(separator, StringSplitOptions.RemoveEmptyEntries)
					select keyword.ToLower()).ToArray();
				if (array.Length != 0)
				{
					HashSet<int> allowedBundles = new HashSet<int>();
					foreach (BundleInfo level in OnlineCatalogManager.Catalog.Levels)
					{
						string bundleName = richText.Replace(level.Name, string.Empty).ToLower();
						if (!array.Any((string key) => bundleName.IndexOf(key) == -1) && history.bundleGuidPK.TryGetValue(level.Guid, out var value))
						{
							allowedBundles.Add(value);
						}
					}
					enumerable = enumerable.Where((int[] e) => allowedBundles.Contains(e[1]));
				}
				if (array2.Length != 0)
				{
					HashSet<int> allowedLevels = new HashSet<int>();
					foreach (BundleInfo level2 in OnlineCatalogManager.Catalog.Levels)
					{
						foreach (LevelInfo level3 in level2.Levels)
						{
							string levelName = richText.Replace(level3.LevelName, string.Empty).ToLower();
							if (!array2.Any((string key) => levelName.IndexOf(key) == -1) && history.levelIdPK.TryGetValue(level3.LevelId, out var value2))
							{
								allowedLevels.Add(value2);
							}
						}
					}
					enumerable = enumerable.Where((int[] e) => allowedLevels.Contains(e[2]));
				}
				filteredHistory.Clear();
				filteredHistory.AddRange(enumerable);
				pageNum = 0;
				currentUi.historyPanel.pageNumber.SetTextWithoutNotify("1");
				RefreshList(sort: true);
			}
		}

		private void ResetReportUI()
		{
			((Selectable)currentUi.reportSend).interactable = false;
			currentUi.inappropriateName.SetIsOnWithoutNotify(false);
			currentUi.inappropriatePicture.SetIsOnWithoutNotify(false);
			currentUi.cheatedScore.SetIsOnWithoutNotify(false);
			currentUi.reportValidation.SetIsOnWithoutNotify(false);
		}

		private void UpdateReportUI()
		{
			((Selectable)currentUi.reportSend).interactable = currentUi.reportValidation.isOn && (currentUi.inappropriateName.isOn || currentUi.inappropriatePicture.isOn || currentUi.cheatedScore.isOn);
		}
	}
	internal class LeaderboardPermissionNotification : Notification
	{
		private const string ASSET_PATH = "AngryLevelLoader/Notifications/LeaderboardPermissionNotification.prefab";

		private AngryLeaderboardPermissionNotificationComponent currentUi;

		public override void OnUI(RectTransform panel)
		{
			//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_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Expected O, but got Unknown
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Expected O, but got Unknown
			currentUi = Addressables.InstantiateAsync((object)"AngryLevelLoader/Notifications/LeaderboardPermissionNotification.prefab", (Transform)(object)panel, false, true).WaitForCompletion().GetComponent<AngryLeaderboardPermissionNotificationComponent>();
			((UnityEvent)currentUi.okButton.onClick).AddListener((UnityAction)delegate
			{
				((Notification)this).Close();
				InternalConfigManager.askedPermissionForLeaderboards.value = true;
				InternalConfigManager.leaderboardToggle.value = true;
			});
			((UnityEvent)currentUi.cancelButton.onClick).AddListener((UnityAction)delegate
			{
				((Notification)this).Close();
				InternalConfigManager.askedPermissionForLeaderboards.value = true;
			});
		}
	}
	internal class LevelUpdateNotification : Notification
	{
		private const string ASSET_PATH = "AngryLevelLoader/Notifications/LevelUpdateNotification.prefab";

		public string currentHash;

		public BundleInfo onlineInfo;

		public OnlineLevelField callback;

		public override void OnUI(RectTransform panel)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Expected O, but got Unknown
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Expected O, but got Unknown
			AngryLevelUpdateNotificationComponent component = Addressables.InstantiateAsync((object)"AngryLevelLoader/Notifications/LevelUpdateNotification.prefab", (Transform)(object)panel, false, true).WaitForCompletion().GetComponent<AngryLevelUpdateNotificationComponent>();
			((UnityEvent)component.cancel.onClick).AddListener((UnityAction)delegate
			{
				((Notification)this).Close();
			});
			((UnityEvent)component.update.onClick).AddListener((UnityAction)delegate
			{
				callback.Download();
				((Notification)this).Close();
			});
			StringBuilder stringBuilder = new StringBuilder();
			bool flag = true;
			for (int num = onlineInfo.Updates.Count - 1; num >= 0; num--)
			{
				string text = new DateTime(1970, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc).AddSeconds(onlineInfo.Updates[num].Date).ToString("d");
				if (!flag)
				{
					if (onlineInfo.Updates[num].Hash != currentHash)
					{
						stringBuilder.Append("\n\n<color=#b2b2b2>Past Version</color> <color=gray>(" + text + ")</color>");
					}
					else
					{
						stringBuilder.Append("\n\n<color=yellow>Current Version</color> <color=gray>(" + text + ")</color>");
					}
				}
				else
				{
					stringBuilder.Append("<color=#00FF00>Latest Version</color> <color=gray>(" + text + ")</color>");
				}
				stringBuilder.Append("<size=18>\n");
				stringBuilder.Append(onlineInfo.Updates[num].Message.Replace("\\n", "\n"));
				stringBuilder.Append("</size>");
				flag = false;
			}
			component.body.text = stringBuilder.ToString();
			if (onlineInfo.Hash == currentHash)
			{
				((Selectable)component.update).interactable = false;
			}
		}
	}
	internal class NoMoNotSupportedNotification : Notification
	{
		private const string ASSET_PATH = "AngryLevelLoader/Notifications/NoMoNotSupportedNotification.prefab";

		private string continueText;

		private string continueAndIgnoreText;

		private Action onContinue;

		private LevelContainer levelContainer;

		private AngryNoMoNotSupportedNotificationComponent ui;

		public NoMoNotSupportedNotification(Action onContinue, string continueText, string continueAndIgnoreText, LevelContainer levelContainer)
		{
			this.onContinue = onContinue;
			this.continueText = continueText;
			this.continueAndIgnoreText = continueAndIgnoreText;
			this.levelContainer = levelContainer;
		}

		public override void OnUI(RectTransform panel)
		{
			//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_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Expected O, but got Unknown
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Expected O, but got Unknown
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Expected O, but got Unknown
			ui = Addressables.InstantiateAsync((object)"AngryLevelLoader/Notifications/NoMoNotSupportedNotification.prefab", (Transform)(object)panel, false, true).WaitForCompletion().GetComponent<AngryNoMoNotSupportedNotificationComponent>();
			((UnityEvent)ui.cancelButton.onClick).AddListener((UnityAction)delegate
			{
				((Notification)this).Close();
			});
			ui.continueButtonText.text = continueText;
			ui.continueAndIgnoreButtonText.text = continueAndIgnoreText;
			((UnityEvent)ui.continueButton.onClick).AddListener((UnityAction)delegate
			{
				((Notification)this).Close();
				if (onContinue != null)
				{
					onContinue();
				}
			});
			((UnityEvent)ui.continueAndIgnoreButton.onClick).AddListener((UnityAction)delegate
			{
				((Notification)this).Close();
				if (!string.IsNullOrEmpty(InternalConfigManager.ignoreNoMoWarning.value))
				{
					StringMultilineField ignoreNoMoWarning = InternalConfigManager.ignoreNoMoWarning;
					ignoreNoMoWarning.value += "\n";
				}
				StringMultilineField ignoreNoMoWarning2 = InternalConfigManager.ignoreNoMoWarning;
				ignoreNoMoWarning2.value += levelContainer.levelId;
				if (onContinue != null)
				{
					onContinue();
				}
			});
		}
	}
	internal class PluginVersion
	{
		public string version { get; set; }

		public string updateText { get; set; }
	}
	internal class PluginInfoJson
	{
		public List<PluginVersion> updates;

		public string latestVersion { get; set; }
	}
	internal class PluginUpdateNotification : Notification
	{
		private const string ASSET_PATH = "AngryLevelLoader/Notifications/PluginUpdateNotification.prefab";

		private PluginInfoJson json;

		public PluginUpdateNotification(PluginInfoJson json)
		{
			this.json = json;
		}

		public override void OnUI(RectTransform panel)
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Expected O, but got Unknown
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Expected O, but got Unknown
			if (json == null)
			{
				Plugin.logger.LogError((object)"Closed plugin changelog panel because passed json is null");
				((Notification)this).Close();
				return;
			}
			AngryPluginChangelogNotificationComponent component = Addressables.InstantiateAsync((object)"AngryLevelLoader/Notifications/PluginUpdateNotification.prefab", (Transform)(object)panel, false, true).WaitForCompletion().GetComponent<AngryPluginChangelogNotificationComponent>();
			((UnityEvent)component.cancel.onClick).AddListener((UnityAction)delegate
			{
				((Notification)this).Close();
			});
			((UnityEvent)component.ignoreUpdate.onClick).AddListener((UnityAction)delegate
			{
				InternalConfigManager.ignoreUpdateVersion.value = json.latestVersion;
				((Notification)this).Close();
			});
			component.header.text = "<color=#00FFFF>Changelog</color>";
			if (Version.TryParse(json.latestVersion, out Version result) && new Version("4.0.3") < result)
			{
				component.header.text = "<color=#00FF00>UPDATE AVAILABLE</color>";
			}
			StringBuilder stringBuilder = new StringBuilder();
			bool flag = true;
			for (int num = json.updates.Count - 1; num >= 0; num--)
			{
				string version = json.updates[num].version;
				if (!flag)
				{
					if (version == "4.0.3")
					{
						stringBuilder.Append("\n\nV" + version + " <color=yellow>Current Version</color>");
					}
					else
					{
						stringBuilder.Append("\n\nV" + version + " <color=#b2b2b2>Past Version</color>");
					}
				}
				else
				{
					stringBuilder.Append("V" + version + " <color=#00FF00>Latest Version</color>");
				}
				stringBuilder.Append("<size=18>\n\n");
				stringBuilder.Append(json.updates[num].updateText.Replace("\\n", "\n"));
				stringBuilder.Append("</size>");
				flag = false;
			}
			component.text.text = stringBuilder.ToString();
		}
	}
	internal class ResetUserMapVarNotification : Notification
	{
		public const string ASSET_PATH = "AngryLevelLoader/Notifications/ResetUserMapVarNotification.prefab";

		public override void OnUI(RectTransform panel)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Expected O, but got Unknown
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Expected O, but got Unknown
			AngryResetUserMapVarNotificationComponent component = Addressables.InstantiateAsync((object)"AngryLevelLoader/Notifications/ResetUserMapVarNotification.prefab", ((Component)panel).transform, false, true).WaitForCompletion().GetComponent<AngryResetUserMapVarNotificationComponent>();
			component.exitButton.onClick = new ButtonClickedEvent();
			((UnityEvent)component.exitButton.onClick).AddListener(new UnityAction(base.Close));
			string currentUserMapVarsDirectory = AngryMapVarManager.GetCurrentUserMapVarsDirectory();
			if (!Directory.Exists(currentUserMapVarsDirectory))
			{
				component.notFoundText.SetActive(true);
				return;
			}
			string[] files = Directory.GetFiles(currentUserMapVarsDirectory);
			if (files.Length == 0)
			{
				component.notFoundText.SetActive(true);
				return;
			}
			string[] array = files;
			foreach (string file in array)
			{
				string fileName = Path.GetFileName(file);
				fileName = (fileName.EndsWith(".vars.json") ? fileName.Substring(0, fileName.Length - ".vars.json".Length) : fileName);
				AngryResetUserMapVarNotificationElementComponent element = component.CreateTemplate();
				element.SetButton();
				((TMP_Text)element.id).text = fileName;
				element.onReset = delegate
				{
					if (File.Exists(file))
					{
						File.Delete(file);
						Object.Destroy((Object)(object)((Component)element).gameObject);
					}
					else
					{
						element.SetButton();
						((TMP_Text)element.resetButtonText).text = "<color=red>Failed</color>";
					}
				};
			}
		}
	}
	public class ScriptUpdateNotification : Notification
	{
		private class ScriptUpdateProgressField
		{
			public enum ScriptStatus
			{
				Download,
				NotFound,
				Update
			}

			public string scriptName;

			public string fileSizeText = "";

			public ScriptUpdateNotification caller;

			public ScriptStatus scriptStatus;

			public bool downloaded;

			public bool downloadError;

			public Text currentTextComp;

			private Task downloadTask;

			private UnityWebRequest currentDllRequest;

			private UnityWebRequest currentCertRequest;

			public bool downloading
			{
				get
				{
					if (downloadTask != null)
					{
						return !downloadTask.IsCompleted;
					}
					return false;
				}
			}

			public bool isDone
			{
				get
				{
					if (!downloaded)
					{
						return scriptStatus == ScriptStatus.NotFound;
					}
					return true;
				}
			}

			public void SetStatusText(bool downloadedFromTask = false)
			{
				if ((Object)(object)currentTextComp == (Object)null)
				{
					return;
				}
				string text = scriptName + "\n";
				if (downloading && !downloadedFromTask)
				{
					text += $"Downloading... {(int)(currentDllRequest.downloadProgress * 100f)} %";
				}
				else if (downloaded)
				{
					text = ((!ScriptManager.ScriptLoaded(scriptName)) ? (text + "<color=#00FF00>Installed!</color>") : (text + "<color=red>RESTART REQUIRED</color>"));
				}
				else
				{
					if (scriptStatus == ScriptStatus.NotFound)
					{
						text += "<color=red>Not Available Online</color>";
					}
					else if (scriptStatus == ScriptStatus.Update)
					{
						text = text + "<color=#00FFFF>Update Available</color> (" + fileSizeText + ")";
					}
					else if (scriptStatus == ScriptStatus.Download)
					{
						text = text + "<color=orange>Available online</color> (" + fileSizeText + ")";
					}
					if (downloadError)
					{
						text += "<color=red>Download error</color>";
					}
				}
				currentTextComp.text = text;
			}

			public void OnUI(Transform content)
			{
				//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)
				currentTextComp = Addressables.InstantiateAsync((object)"AngryLevelLoader/Notifications/ScriptUpdatePrefabs/ScriptUpdateInfo.prefab", content, false, true).WaitForCompletion().GetComponentInChildren<Text>();
				if (string.IsNullOrEmpty(fileSizeText))
				{
					if (OnlineScriptsManager.TryGetScriptInfo(scriptName, out var info))
					{
						string text = "B";
						float num = info.Size;
						if (num >= 1024f)
						{
							num /= 1024f;
							text = "KB";
						}
						if (num >= 1024f)
						{
							num /= 1024f;
							text = "MB";
						}
						fileSizeText = num.ToString("0.0") + " " + text;
					}
					else
					{
						fileSizeText = "? MB";
					}
				}
				SetStatusText();
			}

			public void StartDownload()
			{
				if (!downloading && !downloaded && scriptStatus != ScriptStatus.NotFound)
				{
					downloadTask = DownloadTask();
				}
			}

			private async Task DownloadTask()
			{
				downloadError = false;
				try
				{
					currentDllRequest = new UnityWebRequest(AngryPaths.GetGithubURL(AngryPaths.Repo.AngryLevels, "Scripts/" + scriptName));
					currentCertRequest = new UnityWebRequest(AngryPaths.GetGithubURL(AngryPaths.Repo.AngryLevels, "Scripts/" + scriptName + ".cert"));
					string text = Path.Combine(Plugin.workingDir, "TempDownloads");
					if (!Directory.Exists(text))
					{
						Directory.CreateDirectory(text);
					}
					string tempDllPath = Path.Combine(text, scriptName);
					string tempCertPath = Path.Combine(text, scriptName + ".cert");
					currentDllRequest.downloadHandler = (DownloadHandler)new DownloadHandlerFile(tempDllPath);
					currentCertRequest.downloadHandler = (DownloadHandler)new DownloadHandlerFile(tempCertPath);
					currentDllRequest.SendWebRequest();
					currentCertRequest.SendWebRequest();
					while (!currentDllRequest.isDone || !currentCertRequest.isDone)
					{
						SetStatusText();
						await Task.Delay(500);
					}
					if ((int)currentDllRequest.result != 1 || (int)currentCertRequest.result != 1)
					{
						downloadError = true;
					}
					else
					{
						downloaded = true;
						File.Copy(tempDllPath, Path.Combine(Plugin.workingDir, "Scripts", scriptName), overwrite: true);
						File.Copy(tempCertPath, Path.Combine(Plugin.workingDir, "Scripts", scriptName + ".cert"), overwrite: true);
					}
					if (File.Exists(tempDllPath))
					{
						File.Delete(tempDllPath);
					}
					if (File.Exists(tempCertPath))
					{
						File.Delete(tempCertPath);
					}
					currentDllRequest.Dispose();
					currentCertRequest.Dispose();
				}
				finally
				{
					currentDllRequest = null;
					currentCertRequest = null;
					if (caller != null)
					{
						caller.CheckInteractable(this);
					}
					SetStatusText(downloadedFromTask: true);
				}
			}

			public void StopDownload()
			{
				if (downloading)
				{
					if (currentDllRequest != null)
					{
						currentDllRequest.Abort();
					}
					if (currentCertRequest != null)
					{
						currentCertRequest.Abort();
					}
				}
			}
		}

		private const string ASSET_PATH_PANEL = "AngryLevelLoader/Notifications/ScriptUpdateNotification.prefab";

		private const string ASSET_PATH_SCRIPT_INFO = "AngryLevelLoader/Notifications/ScriptUpdatePrefabs/ScriptUpdateInfo.prefab";

		private List<ScriptUpdateProgressField> fields = new List<ScriptUpdateProgressField>();

		private AngryScriptUpdateNotificationComponent ui;

		public BundleContainer bundleContainer;

		public LevelContainer levelContainer;

		public ScriptUpdateNotification(LevelContainer levelContainer, IEnumerable<string> scriptsToDownload)
		{
			bundleContainer = levelContainer.bundleContainer;
			this.levelContainer = levelContainer;
			if (scriptsToDownload == null)
			{
				return;
			}
			foreach (string item in scriptsToDownload)
			{
				ScriptUpdateProgressField scriptUpdateProgressField = new ScriptUpdateProgressField
				{
					scriptName = item,
					caller = this
				};
				if (OnlineScriptsManager.TryGetScriptInfo(item, out var _))
				{
					if (ScriptManager.ScriptExists(item))
					{
						scriptUpdateProgressField.scriptStatus = ScriptUpdateProgressField.ScriptStatus.Update;
					}
					else
					{
						scriptUpdateProgressField.scriptStatus = ScriptUpdateProgressField.ScriptStatus.Download;
					}
				}
				else
				{
					scriptUpdateProgressField.scriptStatus = ScriptUpdateProgressField.ScriptStatus.NotFound;
				}
				fields.Add(scriptUpdateProgressField);
			}
		}

		private void CheckInteractable(ScriptUpdateProgressField callingField = null)
		{
			if ((Object)(object)ui == (Object)null)
			{
				return;
			}
			bool interactable = true;
			foreach (ScriptUpdateProgressField field in fields)
			{
				if (callingField != field && field.downloading)
				{
					interactable = false;
					break;
				}
			}
			((Selectable)ui.update).interactable = interactable;
			((Selectable)ui.continueButton).interactable = interactable;
		}

		public override void OnUI(RectTransform panel)
		{
			//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_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Expected O, but got Unknown
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Expected O, but got Unknown
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: Expected O, but got Unknown
			ui = Addressables.InstantiateAsync((object)"AngryLevelLoader/Notifications/ScriptUpdateNotification.prefab", (Transform)(object)panel, false, true).WaitForCompletion().GetComponent<AngryScriptUpdateNotificationComponent>();
			((UnityEvent)ui.cancel.onClick).AddListener((UnityAction)delegate
			{
				foreach (ScriptUpdateProgressField field in fields)
				{
					try
					{
						field.StopDownload();
					}
					catch (Exception arg)
					{
						Plugin.logger.LogError((object)$"Exception thrown while stopping download of script update field\n{arg}");
					}
				}
				((Notification)this).Close();
			});
			foreach (ScriptUpdateProgressField field2 in fields)
			{
				field2.OnUI(ui.content);
			}
			((UnityEvent)ui.update.onClick).AddListener((UnityAction)delegate
			{
				foreach (ScriptUpdateProgressField field3 in fields)
				{
					field3.StartDownload();
				}
				if ((Object)(object)ui != (Object)null)
				{
					((Selectable)ui.continueButton).interactable = false;
				}
				CheckInteractable();
			});
			foreach (ScriptUpdateProgressField field4 in fields)
			{
				if (field4.downloading)
				{
					((Selectable)ui.continueButton).interactable = false;
					break;
				}
			}
			((UnityEvent)ui.continueButton.onClick).AddListener((UnityAction)delegate
			{
				((Notification)this).Close();
				AngrySceneManager.LoadLevelWithScripts(levelContainer.RequiredScripts.ToList(), levelContainer);
			});
		}
	}
	internal class ScriptWarningNotification : Notification
	{
		private const string ASSET_PATH = "AngryLevelLoader/Notifications/ScriptWarningNotification.prefab";

		public string header;

		public string text;

		public string leftButtonName;

		public string rightButtonName;

		public string topButtonName;

		public Action<ScriptWarningNotification> leftButton;

		public Action<ScriptWarningNotification> rightButton;

		public Action<ScriptWarningNotification> topButton;

		public ScriptWarningNotification(string header, string text, string leftButtonName, string rightButtonName, Action<ScriptWarningNotification> leftButton, Action<ScriptWarningNotification> rightButton, string topButtonName, Action<ScriptWarningNotification> topButton)
		{
			this.header = header;
			this.text = text;
			this.leftButtonName = leftButtonName;
			this.rightButtonName = rightButtonName;
			this.topButtonName = topButtonName;
			this.leftButton = leftButton;
			this.rightButton = rightButton;
			this.topButton = topButton;
		}

		public ScriptWarningNotification(string header, string text, string leftButtonName, string rightButtonName, Action<ScriptWarningNotification> leftButton, Action<ScriptWarningNotification> rightButton)
			: this(header, text, leftButtonName, rightButtonName, leftButton, rightButton, "", null)
		{
		}

		public override void OnUI(RectTransform panel)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Expected O, but got Unknown
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Expected O, but got Unknown
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Expected O, but got Unknown
			AngryScriptWarningNotificationComponent component = Addressables.InstantiateAsync((object)"AngryLevelLoader/Notifications/ScriptWarningNotification.prefab", (Transform)(object)panel, false, true).WaitForCompletion().GetComponent<AngryScriptWarningNotificationComponent>();
			component.header.text = header;
			component.body.text = text;
			component.leftButtonText.text = leftButtonName;
			((UnityEvent)component.leftButton.onClick).AddListener((UnityAction)delegate
			{
				leftButton(this);
			});
			component.rightButtonText.text = rightButtonName;
			((UnityEvent)component.rightButton.onClick).AddListener((UnityAction)delegate
			{
				rightButton(this);
			});
			if (topButton != null)
			{
				component.topButtonText.text = topButtonName;
				((UnityEvent)component.topButton.onClick).AddListener((UnityAction)delegate
				{
					topButton(this);
				});
			}
			else
			{
				((Component)component.topButton).gameObject.SetActive(false);
			}
		}
	}
}
namespace AngryLevelLoader.Managers
{
	public class AngryDifficulty
	{
		public class UltrapainDifficulty : AngryDifficulty
		{
			public static readonly UltrapainDifficulty Instance = new UltrapainDifficulty();

			public override bool IsSupported => Chainloader.PluginInfos.ContainsKey("com.eternalUnion.ultraPain");

			public override bool IsCurrentlySet
			{
				get
				{
					if (!IsSupported)
					{
						return false;
					}
					try
					{
						return _IsCurrentlySet();
					}
					catch (Exception ex)
					{
						Plugin.logger.LogError((object)ex);
						return false;
					}
				}
			}

			private bool _IsCurrentlySet()
			{
				if (base.IsCurrentlySet)
				{
					return Plugin.ultrapainDifficulty;
				}
				return false;
			}

			private UltrapainDifficulty()
				: base("ULTRAPAIN", 6)
			{
			}

			private void _SetDifficulty()
			{
				MonoSingleton<PrefsManager>.Instance.SetInt("difficulty", 6);
				Plugin.ultrapainDifficulty = true;
				Plugin.realUltrapainDifficulty = true;
			}

			internal override void SetDifficulty()
			{
				if (IsSupported)
				{
					try
					{
						_SetDifficulty();
					}
					catch (Exception ex)
					{
						Plugin.logger.LogError((object)ex);
					}
				}
			}

			private void _UnsetDifficulty()
			{
				Plugin.realUltrapainDifficulty = false;
			}

			internal override void UnsetDifficulty()
			{
				if (IsSupported)
				{
					try
					{
						_UnsetDifficulty();
					}
					catch (Exception ex)
					{
						Plugin.logger.LogError((object)ex);
					}
				}
			}
		}

		public class BananaDifficulty : AngryDifficulty
		{
			public static BananaDifficulty Instance = new BananaDifficulty();

			public override bool IsSupported => Chainloader.PluginInfos.ContainsKey("com.banana.BananaDifficulty");

			private BananaDifficulty()
				: base("BANANA", 5)
			{
			}
		}

		public class BillionDifficulty : AngryDifficulty
		{
			public static BillionDifficulty Instance = new BillionDifficulty();

			public override bool IsSupported => Chainloader.PluginInfos.ContainsKey("billy.billiondifficulty");

			public override bool IsCurrentlySet
			{
				get
				{
					if (!IsSupported)
					{
						return false;
					}
					try
					{
						return _IsCurrentlySet();
					}
					catch (Exception ex)
					{
						Plugin.logger.LogError((object)ex);
						return false;
					}
				}
			}

			private bool _IsCurrentlySet()
			{
				if (base.IsCurrentlySet)
				{
					return !((ConfigValueElement<bool>)(object)Plugin.IsBrilliantBillion).Value;
				}
				return false;
			}

			private BillionDifficulty()
				: base("BILLION", 19)
			{
			}

			private void _SetDifficulty()
			{
				((ConfigValueElement<bool>)(object)Plugin.IsBrilliantBillion).SetValue(false);
				MonoSingleton<PrefsManager>.Instance.SetInt("difficulty", 19);
			}

			internal override void SetDifficulty()
			{
				if (IsSupported)
				{
					try
					{
						_SetDifficulty();
					}
					catch (Exception ex)
					{
						Plugin.logger.LogError((object)ex);
					}
				}
			}
		}

		public class BrilliantBillionDifficulty : AngryDifficulty
		{
			public static BrilliantBillionDifficulty Instance = new BrilliantBillionDifficulty();

			public override bool IsSupported => Chainloader.PluginInfos.ContainsKey("billy.billiondifficulty");

			public override bool IsCurrentlySet
			{
				get
				{
					if (!IsSupported)
					{
						return false;
					}
					try
					{
						return _IsCurrentlySet();
					}
					catch (Exception ex)
					{
						Plugin.logger.LogError((object)ex);
						return false;
					}
				}
			}

			private bool _IsCurrentlySet()
			{
				if (base.IsCurrentlySet)
				{
					return ((ConfigValueElement<bool>)(object)Plugin.IsBrilliantBillion).Value;
				}
				return false;
			}

			private BrilliantBillionDifficulty()
				: base("BILLION (HARD)", 19)
			{
			}

			private void _SetDifficulty()
			{
				((ConfigValueElement<bool>)(object)Plugin.IsBrilliantBillion).SetValue(true);
				MonoSingleton<PrefsManager>.Instance.SetInt("difficulty", 19);
			}

			internal override void SetDifficulty()
			{
				if (IsSupported)
				{
					try
					{
						_SetDifficulty();
					}
					catch (Exception ex)
					{
						Plugin.logger.LogError((object)ex);
					}
				}
			}
		}

		public readonly string name;

		public readonly int difficulty;

		public virtual bool IsSupported => true;

		public virtual bool IsCurrentlySet => MonoSingleton<PrefsManager>.Instance.GetInt("difficulty", 0) == difficulty;

		public AngryDifficulty(string name, int difficulty)
		{
			this.name = name;
			this.difficulty = difficulty;
		}

		internal virtual void SetDifficulty()
		{
			MonoSingleton<PrefsManager>.Instance.SetInt("difficulty", difficulty);
		}

		internal virtual void UnsetDifficulty()
		{
		}
	}
	public static class AngryDifficultyManager
	{
		public static readonly AngryDifficulty HARMLESS = new AngryDifficulty("HARMLESS", 0);

		public static readonly AngryDifficulty LENIENT = new AngryDifficulty("LENIENT", 1);

		public static readonly AngryDifficulty STANDARD = new AngryDifficulty("STANDARD", 2);

		public static readonly AngryDifficulty VIOLENT = new AngryDifficulty("VIOLENT", 3);

		public static readonly AngryDifficulty BRUTAL = new AngryDifficulty("BRUTAL", 4);

		private static readonly List<AngryDifficulty> difficulties = new List<AngryDifficulty> { HARMLESS, LENIENT, STANDARD, VIOLENT, BRUTAL };

		private static bool _inited = false;

		public static AngryDifficulty SelectedDifficulty { get; internal set; } = VIOLENT;


		public static IReadOnlyList<AngryDifficulty> Difficulties => difficulties;

		public static IEnumerable<string> DifficultyNames => Difficulties.Select((AngryDifficulty d) => d.name);

		public static bool SetDifficulty(AngryDifficulty difficulty)
		{
			if (AngrySceneManager.isInCustomLevel)
			{
				return false;
			}
			return ForceSetDifficulty(difficulty);
		}

		internal static bool ForceSetDifficulty(AngryDifficulty difficulty)
		{
			int num = MiscHelpers.IndexOf<AngryDifficulty>((IEnumerable<AngryDifficulty>)Difficulties, difficulty);
			if (num == -1)
			{
				return false;
			}
			ConfigManager.difficultyField.difficultyListValueIndex = num;
			ConfigManager.difficultyField.postDifficultyChange.Invoke(difficulty.name, num);
			return true;
		}

		public static void Init()
		{
			if (!_inited)
			{
				_inited = true;
				difficulties.Clear();
				difficulties.Add(HARMLESS);
				difficulties.Add(LENIENT);
				difficulties.Add(STANDARD);
				difficulties.Add(VIOLENT);
				difficulties.Add(BRUTAL);
				if (AngryDifficulty.UltrapainDifficulty.Instance.IsSupported)
				{
					difficulties.Add(AngryDifficulty.UltrapainDifficulty.Instance);
				}
				if (AngryDifficulty.BananaDifficulty.Instance.IsSupported)
				{
					difficulties.Add(AngryDifficulty.BananaDifficulty.Instance);
				}
				if (AngryDifficulty.BillionDifficulty.Instance.IsSupported)
				{
					difficulties.Add(AngryDifficulty.BillionDifficulty.Instance);
				}
				if (AngryDifficulty.BrilliantBillionDifficulty.Instance.IsSupported)
				{
					difficulties.Add(AngryDifficulty.BrilliantBillionDifficulty.Instance);
				}
			}
		}

		internal static void SetDifficultyFromPrefs()
		{
			int difficulty = MonoSingleton<PrefsManager>.Instance.GetInt("difficulty", 3);
			switch (difficulty)
			{
			case 0:
			case 1:
			case 2:
			case 3:
			case 4:
			{
				AngryDifficulty angryDifficulty = Difficulties.Where((AngryDifficulty d) => d.difficulty == difficulty).FirstOrDefault();
				Plugin.logger.LogInfo((object)("Angry setting difficulty to " + ((angryDifficulty == null) ? "<unknown game difficulty>" : angryDifficulty.name)));
				if (angryDifficulty == null)
				{
					angryDifficulty = VIOLENT;
				}
				ConfigManager.difficultyField.difficultyListValueIndex = MiscHelpers.IndexOf<AngryDifficulty>((IEnumerable<AngryDifficulty>)Difficulties, angryDifficulty);
				break;
			}
			case 5:
				if (AngryDifficulty.BananaDifficulty.Instance.IsSupported)
				{
					ConfigManager.difficultyField.difficultyListValueIndex = MiscHelpers.IndexOf<AngryDifficulty>((IEnumerable<AngryDifficulty>)Difficulties, (AngryDifficulty)AngryDifficulty.BananaDifficulty.Instance);
					break;
				}
				Plugin.logger.LogWarning((object)"Difficulty was set to BANANAS, but angry does not support it. Setting to violent");
				ConfigManager.difficultyField.difficultyListValueIndex = MiscHelpers.IndexOf<AngryDifficulty>((IEnumerable<AngryDifficulty>)Difficulties, VIOLENT);
				break;
			case 6:
				if (AngryDifficulty.UltrapainDifficulty.Instance.IsSupported)
				{
					if (AngryDifficulty.UltrapainDifficulty.Instance.IsCurrentlySet)
					{
						ConfigManager.difficultyField.difficultyListValueIndex = MiscHelpers.IndexOf<AngryDifficulty>((IEnumerable<AngryDifficulty>)Difficulties, (AngryDifficulty)AngryDifficulty.UltrapainDifficulty.Instance);
						break;
					}
					Plugin.logger.LogWarning((object)"Difficulty was set to UKMD, but angry does not support it. Setting to violent");
					ConfigManager.difficultyField.difficultyListValueIndex = MiscHelpers.IndexOf<AngryDifficulty>((IEnumerable<AngryDifficulty>)Difficulties, VIOLENT);
				}
				else
				{
					Plugin.logger.LogWarning((object)"Difficulty was set to UKMD, but angry does not support it. Setting to violent");
					ConfigManager.difficultyField.difficultyListValueIndex = MiscHelpers.IndexOf<AngryDifficulty>((IEnumerable<AngryDifficulty>)Difficulties, VIOLENT);
				}
				break;
			case 19:
				if (AngryDifficulty.BillionDifficulty.Instance.IsSupported)
				{
					if (AngryDifficulty.BillionDifficulty.Instance.IsCurrentlySet)
					{
						ConfigManager.difficultyField.difficultyListValueIndex = MiscHelpers.IndexOf<AngryDifficulty>((IEnumerable<AngryDifficulty>)Difficulties, (AngryDifficulty)AngryDifficulty.BillionDifficulty.Instance);
						break;
					}
					if (AngryDifficulty.BrilliantBillionDifficulty.Instance.IsCurrentlySet)
					{
						ConfigManager.difficultyField.difficultyListValueIndex = MiscHelpers.IndexOf<AngryDifficulty>((IEnumerable<AngryDifficulty>)Difficulties, (AngryDifficulty)AngryDifficulty.BrilliantBillionDifficulty.Instance);
						break;
					}
					Plugin.logger.LogWarning((object)"Difficulty was set to 19, but angry does not support it. Setting to violent");
					ConfigManager.difficultyField.difficultyListValueIndex = MiscHelpers.IndexOf<AngryDifficulty>((IEnumerable<AngryDifficulty>)Difficulties, VIOLENT);
				}
				break;
			default:
				Plugin.logger.LogWarning((object)"Unknown difficulty, defaulting to violent");
				ConfigManager.difficultyField.difficultyListValueIndex = MiscHelpers.IndexOf<AngryDifficulty>((IEnumerable<AngryDifficulty>)Difficulties, VIOLENT);
				break;
			}
			ConfigManager.difficultyField.TriggerPostDifficultyChangeEvent();
		}
	}
	public static class AngryGamemodeManager
	{
		public enum Gamemode
		{
			None,
			NoMonsters,
			NoMonstersAndWeapons
		}

		internal static IReadOnlyList<Gamemode> gamemodeEnumList = new List<Gamemode>
		{
			Gamemode.None,
			Gamemode.NoMonsters,
			Gamemode.NoMonstersAndWeapons
		};

		internal static IReadOnlyList<string> gamemodeList = new List<string> { "None", "No Monsters", "No Monsters/Weapons" };

		public static Gamemode SelectedGamemode => gamemodeEnumList[ConfigManager.difficultyField.gamemodeListValueIndex];

		public static bool NoMonsters
		{
			get
			{
				if (SelectedGamemode != Gamemode.NoMonsters)
				{
					return SelectedGamemode == Gamemode.NoMonstersAndWeapons;
				}
				return true;
			}
		}

		public static bool NoWeapons => SelectedGamemode == Gamemode.NoMonstersAndWeapons;

		public static bool SetGamemode(Gamemode gamemode)
		{
			if (AngrySceneManager.isInCustomLevel)
			{
				return false;
			}
			return ForceSetGamemode(gamemode);
		}

		internal static bool ForceSetGamemode(Gamemode gamemode)
		{
			int num = MiscHelpers.IndexOf<Gamemode>((IEnumerable<Gamemode>)gamemodeEnumList, gamemode);
			if (num == -1)
			{
				return false;
			}
			ConfigManager.difficultyField.gamemodeListValueIndex = num;
			ConfigManager.difficultyField.postGamemodeChange.Invoke(gamemodeList[num], num);
			return true;
		}
	}
	internal class AngryMapVarManager : MonoBehaviour
	{
		internal const string MAPVAR_FILE_EXTENSION = ".vars.json";

		internal const string LEVELS_DIRECTORY = "Levels";

		internal const string BUNDLES_DIRECTORY = "BundleDefined";

		internal const string USER_DEFINED_DIRECTORY = "UserDefined";

		internal const string DEFAULT_PRESET_NAME = "default";

		private List<MapVarHandler> allHandlers;

		private MapVarHandler ultrakillSessionVars;

		private PersistentMapVarHandler ultrakillLevelVars;

		private PersistentMapVarHandler ultrakillBundleVars;

		private Dictionary<string, AngryMapVarHandler> userDefinedVars;

		private Dictionary<string, string> userDefinedMapVarKeyToFileMap;

		public static AngryMapVarManager Instance { get; private set; }

		internal static string angryMapVarsDirectory => Plugin.mapVarsFolderPath;

		internal static string GetCurrentMapVarsDirectory()
		{
			return Path.Combine(angryMapVarsDirectory, GetConfigPresetID());
		}

		internal static string GetBundleDirectory()
		{
			return Path.Combine(GetCurrentMapVarsDirectory(), "BundleDefined", AngrySceneManager.currentBundleContainer.bundleGuid);
		}

		internal static string GetLevelDirectory()
		{
			return Path.Combine(GetBundleDirectory(), "Levels");
		}

		internal static string GetCurrentUserMapVarsDirectory()
		{
			return Path.Combine(GetCurrentMapVarsDirectory(), "UserDefined");
		}

		internal static string GetBundleFilePath()
		{
			return Path.Combine(GetBundleDirectory(), AngrySceneManager.currentBundleContainer.bundleGuid + ".vars.json");
		}

		internal static string GetLevelFilePath()
		{
			return Path.Combine(GetLevelDirectory(), AngrySceneManager.currentLevelData.uniqueIdentifier + ".vars.json");
		}

		internal static string GetConfigPresetID()
		{
			if (!string.IsNullOrEmpty(ConfigManager.config.currentPresetId))
			{
				return ConfigManager.config.currentPresetId;
			}
			return "default";
		}

		private void Awake()
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Expected O, but got Unknown
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Expected O, but got Unknown
			Instance = this;
			allHandlers = new List<MapVarHandler>();
			ConfigManager.config.postPresetChangeEvent += (PostPresetChangeEvent)delegate
			{
				if (AngrySceneManager.isInCustomLevel)
				{
					ReloadMapVars();
				}
			};
			ConfigManager.config.postPresetResetEvent += (PostPresetResetEvent)delegate
			{
				if (Directory.Exists(GetCurrentMapVarsDirectory()))
				{
					Directory.Delete(GetCurrentMapVarsDirectory(), recursive: true);
				}
				if (AngrySceneManager.isInCustomLevel)
				{
					ReloadMapVars();
				}
			};
			SceneManager.sceneLoaded += delegate
			{
				InitializeMapVarHandlers();
			};
			InitializeMapVarHandlers();
		}

		private void InitializeMapVarHandlers()
		{
			if (!AngrySceneManager.isInCustomLevel)
			{
				return;
			}
			allHandlers.Clear();
			ultrakillSessionVars = new MapVarHandler();
			ultrakillSessionVars.ReloadMapVars();
			allHandlers.Add(ultrakillSessionVars);
			ultrakillLevelVars = new PersistentMapVarHandler(GetLevelFilePath());
			ultrakillLevelVars.ReloadMapVars();
			Plugin.logger.LogInfo((object)$"Level mapvars loaded: {ultrakillLevelVars.GetAllVariables().Count}");
			allHandlers.Add(ultrakillLevelVars);
			ultrakillBundleVars = new PersistentMapVarHandler(GetBundleFilePath());
			ultrakillBundleVars.ReloadMapVars();
			Plugin.logger.LogInfo((object)$"Bundle mapvars loaded: {ultrakillLevelVars.GetAllVariables().Count}");
			allHandlers.Add(ultrakillBundleVars);
			RudeMapVarHandler[] array = Object.FindObjectsOfType<RudeMapVarHandler>();
			userDefinedMapVarKeyToFileMap = new Dictionary<string, string>();
			userDefinedVars = new Dictionary<string, AngryMapVarHandler>();
			RudeMapVarHandler[] array2 = array;
			foreach (RudeMapVarHandler val in array2)
			{
				if (!val.IsValid())
				{
					Plugin.logger.LogError((object)("(" + ((Object)val).name + ") RudeMapVarHandler.fileID is invalid and will not be used."));
					continue;
				}
				if (val.varList == null || val.varList.Count <= 0)
				{
					Plugin.logger.LogWarning((object)("(" + ((Object)val).name + ") RudeMapVarHandler.varList contains no MapVar keys and will not be used."));
					continue;
				}
				foreach (string var in val.varList)
				{
					if (!userDefinedMapVarKeyToFileMap.ContainsKey(var))
					{
						userDefinedMapVarKeyToFileMap.Add(var, val.fileID);
					}
					else if (userDefinedMapVarKeyToFileMap[var] != val.fileID)
					{
						Plugin.logger.LogError((object)("Duplicate mapvar key found: " + var + " in " + val.fileID + " and " + userDefinedMapVarKeyToFileMap[var]));
					}
				}
				if (!userDefinedVars.ContainsKey(val.fileID))
				{
					userDefinedVars[val.fileID] = new AngryMapVarHandler(Path.Combine(GetCurrentUserMapVarsDirectory(), val.fileID + ".vars.json"), val);
					userDefinedVars[val.fileID].ReloadMapVars();
					allHandlers.Add(userDefinedVars[val.fileID]);
					Plugin.logger.LogInfo((object)$"Loaded custom mapvar file ({val.fileID}): {userDefinedVars[val.fileID].GetAllVariables().Count}");
				}
			}
		}

		public void StashStore()
		{
			foreach (MapVarHandler allHandler in allHandlers)
			{
				allHandler.StashStore();
			}
		}

		public void RestoreStashedStore()
		{
			foreach (MapVarHandler allHandler in allHandlers)
			{
				allHandler.RestoreStashedStore();
			}
		}

		public List<VariableSnapshot> GetAllVariables()
		{
			return allHandlers.SelectMany((MapVarHandler handler) => handler.GetAllVariables()).ToList();
		}

		public void ReloadMapVars()
		{
			foreach (MapVarHandler allHandler in allHandlers)
			{
				allHandler.ReloadMapVars();
			}
		}

		public void ResetStores()
		{
			foreach (MapVarHandler allHandler in allHandlers)
			{
				allHandler.ResetStores();
			}
		}

		public bool? GetBool(string key)
		{
			if (userDefinedMapVarKeyToFileMap.ContainsKey(key))
			{
				string key2 = userDefinedMapVarKeyToFileMap[key];
				return userDefinedVars[key2].GetBool(key);
			}
			return allHandlers.Where((MapVarHandler handler) => handler.GetStore().ContainsBoolKey(key)).FirstOrDefault()?.GetBool(key);
		}

		public int? GetInt(string key)
		{
			if (userDefinedMapVarKeyToFileMap.ContainsKey(key))
			{
				string key2 = userDefinedMapVarKeyToFileMap[key];
				return userDefinedVars[key2].GetInt(key);
			}
			return allHandlers.Where((MapVarHandler handler) => handler.GetStore().ContainsIntKey(key)).FirstOrDefault()?.GetInt(key);
		}

		public float? GetFloat(string key)
		{
			if (userDefinedMapVarKeyToFileMap.ContainsKey(key))
			{
				string key2 = userDefinedMapVarKeyToFileMap[key];
				return userDefinedVars[key2].GetFloat(key);
			}
			return allHandlers.Where((MapVarHandler handler) => handler.GetStore().ContainsFloatKey(key)).FirstOrDefault()?.GetFloat(key);
		}

		public string GetString(string key)
		{
			if (userDefinedMapVarKeyToFileMap.ContainsKey(key))
			{
				string key2 = userDefinedMapVarKeyToFileMap[key];
				return userDefinedVars[key2].GetString(key);
			}
			return allHandlers.Where((MapVarHandler handler) => handler.GetStore().ContainsStringKey(key)).FirstOrDefault()?.GetString(key);
		}

		public void SetBool(string key, bool value, VariablePersistence persistence = 0)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Expected I4, but got Unknown
			if (userDefinedMapVarKeyToFileMap.ContainsKey(key))
			{
				string key2 = userDefinedMapVarKeyToFileMap[key];
				userDefinedVars[key2].SetBool(key, value);
				return;
			}
			switch ((int)persistence)
			{
			case 1:
				ultrakillLevelVars.SetBool(key, value);
				break;
			case 2:
				ultrakillBundleVars.SetBool(key, value);
				break;
			default:
				ultrakillSessionVars.SetBool(key, value);
				break;
			}
		}

		public void SetInt(string key, int value, VariablePersistence persistence = 0)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Expected I4, but got Unknown
			if (userDefinedMapVarKeyToFileMap.ContainsKey(key))
			{
				string key2 = userDefinedMapVarKeyToFileMap[key];
				userDefinedVars[key2].SetInt(key, value);
				return;
			}
			switch ((int)persistence)
			{
			case 1:
				ultrakillLevelVars.SetInt(key, value);
				break;
			case 2:
				ultrakillBundleVars.SetInt(key, value);
				break;
			default:
				ultrakillSessionVars.SetInt(key, value);
				break;
			}
		}

		public void SetFloat(string key, float value, VariablePersistence persistence = 0)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Expected I4, but got Unknown
			if (userDefinedMapVarKeyToFileMap.ContainsKey(key))
			{
				string key2 = userDefinedMapVarKeyToFileMap[key];
				userDefinedVars[key2].SetFloat(key, value);
				return;
			}
			switch ((int)persistence)
			{
			case 1:
				ultrakillLevelVars.SetFloat(key, value);
				break;
			case 2:
				ultrakillBundleVars.SetFloat(key, value);
				break;
			default:
				ultrakillSessionVars.SetFloat(key, value);
				break;
			}
		}

		public void SetString(string key, string value, VariablePersistence persistence = 0)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Expected I4, but got Unknown
			if (userDefinedMapVarKeyToFileMap.ContainsKey(key))
			{
				string key2 = userDefinedMapVarKeyToFileMap[key];
				userDefinedVars[key2].SetString(key, value);
				return;
			}
			switch ((int)persistence)
			{
			case 1:
				ultrakillLevelVars.SetString(key, value);
				break;
			case 2:
				ultrakillBundleVars.SetString(key, value);
				break;
			default:
				ultrakillSessionVars.SetString(key, value);
				break;
			}
		}
	}
	public static class AngrySceneManager
	{
		private static string _currentLevel = "";

		private static bool _isInCustomLevel = false;

		private static BundleContainer _currentBundleContainer = null;

		private static LevelContainer _currentLevelContainer = null;

		private static RudeLevelData _currentLevelData = null;

		public static bool isInCustomLevel
		{
			get
			{
				CheckCurrentDataStatus();
				return _isInCustomLevel;
			}
		}

		public static BundleContainer currentBundleContainer
		{
			get
			{
				CheckCurrentDataStatus();
				return _currentBundleContainer;
			}
		}

		public static LevelContainer currentLevelContainer
		{
			get
			{
				CheckCurrentDataStatus();
				return _currentLevelContainer;
			}
		}

		public static RudeLevelData currentLevelData
		{
			get
			{
				CheckCurrentDataStatus();
				return _currentLevelData;
			}
		}

		public static bool wasInCustomLevel { get; private set; } = false;


		public static BundleContainer lastBundleContainer { get; private set; } = null;


		public static LevelContainer lastLevelContainer { get; private set; } = null;


		public static RudeLevelData lastLevelData { get; private set; } = null;


		private static void CheckCurrentDataStatus()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			Scene activeScene = SceneManager.GetActiveScene();
			string currentScene = ((Scene)(ref activeScene)).path;
			if (!(currentScene != _currentLevel))
			{
				return;
			}
			_currentLevel = currentScene;
			wasInCustomLevel = _isInCustomLevel;
			lastBundleContainer = _currentBundleContainer;
			lastLevelContainer = _currentLevelContainer;
			lastLevelData = _currentLevelData;
			foreach (BundleContainer allBundleContainer in Plugin.GetAllBundleContainers())
			{
				if (allBundleContainer.GetAllScenePaths().Contains(currentScene))
				{
					_isInCustomLevel = true;
					_currentLevelData = (from data in allBundleContainer.GetAllRudeLevelData()
						where data.scenePath == currentScene
						select data).First();
					_currentBundleContainer = allBundleContainer;
					_currentBundleContainer.TryGetLevelContainer(_currentLevelData.uniqueIdentifier, out _currentLevelContainer);
					_currentLevelContainer.LevelDiscovered = true;
					SceneHelper.CurrentScene = _currentLevelData.uniqueIdentifier;
					ConfigManager.config.presetButtonInteractable = false;
					((ConfigField)ConfigManager.difficultyField).interactable = false;
					return;
				}
			}
			_isInCustomLevel = false;
			_currentBundleContainer = null;
			_currentLevelData = null;
			_currentLevelContainer = null;
			ConfigManager.config.presetButtonInteractable = true;
			((ConfigField)ConfigManager.difficultyField).interactable = true;
		}

		internal static void LevelButtonPressed(LevelContainer levelContainer)
		{
			Stack<Notification> notifications = new Stack<Notification>();
			if (levelContainer.bundleContainer.EpilepsyWarning && !InternalConfigManager.ignoreEpilepsyWarning.value)
			{
				notifications.Push((Notification)(object)new EpilepsyWarningNotification(delegate
				{
					notifications.Pop();
					if (notifications.Count == 0)
					{
						ContinueLoadLevel();
					}
				}, "Play", "Play and do not ask again"));
				NotificationPanel.Open(notifications.Peek());
			}
			if (levelContainer.LevelData.doesNotSupportNoMo && AngryGamemodeManager.NoMonsters && !InternalConfigManager.ignoreNoMoWarning.value.Split('\n').Contains(levelContainer.levelId))
			{
				notifications.Push((Notification)(object)new NoMoNotSupportedNotification(delegate
				{
					notifications.Pop();
					if (notifications.Count == 0)
					{
						ContinueLoadLevel();
					}
				}, "Play", "Play and do not ask again for this level", levelContainer));
				NotificationPanel.Open(notifications.Peek());
			}
			if (notifications.Count == 0)
			{
				ContinueLoadLevel();
			}
			void ContinueLoadLevel()
			{
				List<string> requiredScriptsFromBundle = ScriptManager.GetRequiredScriptsFromBundle(levelContainer.bundleContainer);
				List<string> list = new List<string>();
				foreach (string script in requiredScriptsFromBundle)
				{
					if (ScriptManager.ScriptExists(script))
					{
						ScriptInfo scriptInfo = ((OnlineScriptsManager.ScriptCatalog == null) ? null : OnlineScriptsManager.ScriptCatalog.Scripts.Where((ScriptInfo s) => s.FileName == script).FirstOrDefault());
						if (scriptInfo != null)
						{
							string mD5String = AngryCryptographyUtils.GetMD5String(File.ReadAllBytes(Path.Combine(Plugin.workingDir, "Scripts", script)));
							if (mD5String != scriptInfo.Hash && (!ConfigManager.scriptUpdateIgnoreCustom.value || scriptInfo.Updates == null || scriptInfo.Updates.Contains(mD5String)))
							{
								list.Add(script);
							}
						}
					}
					else
					{
						list.Add(script);
					}
				}
				if (list.Count != 0)
				{
					NotificationPanel.Open((Notification)(object)new ScriptUpdateNotification(levelContainer, list));
				}
				else
				{
					LoadLevelWithScripts(requiredScriptsFromBundle, levelContainer);
				}
			}
		}

		internal static void LoadLevelWithScripts(List<string> scripts, LevelContainer levelContainer)
		{
			Stack<ScriptWarningNotification> notifications = new Stack<ScriptWarningNotification>();
			ConfigManager.scriptCertificateIgnore = ConfigManager.scriptCertificateIgnoreField.value.Split('\n').ToList();
			foreach (string script in scripts)
			{
				if (ScriptManager.ScriptLoaded(script))
				{
					continue;
				}
				ScriptWarningNotification scriptWarningNotification = null;
				if (!ScriptManager.ScriptExists(script))
				{
					scriptWarningNotification = new ScriptWarningNotification("<color=yellow>Missing Script</color>", "Script " + script + " is missing and may cause issues in the level", "Cancel", "Continue", delegate(ScriptWarningNotification inst)
					{
						((Notification)inst).Close();
						foreach (ScriptWarningNotification item in notifications)
						{
							((Notification)item).Close();
						}
					}, delegate(ScriptWarningNotification inst)
					{
						((Notification)inst).Close();
						notifications.Pop();
						if (notifications.Count == 0)
						{
							LoadLevel(levelContainer);
						}
					});
				}
				else
				{
					ScriptManager.LoadScriptResult loadScriptResult = ScriptManager.AttemptLoadScriptWithCertificate(script);
					if (loadScriptResult == ScriptManager.LoadScriptResult.Loaded)
					{
						continue;
					}
					if (ConfigManager.scriptCertificateIgnore.Contains(script))
					{
						ScriptManager.ForceLoadScript(script);
						continue;
					}
					scriptWarningNotification = new ScriptWarningNotification("<color=red>Unverified Script</color>", "Script " + script + " " + ((loadScriptResult == ScriptManager.LoadScriptResult.NoCertificate) ? "has no certificate" : "has invalid certificate") + ", loading scripts from unknown sources could be dangerous", "Cancel", "Load", delegate(ScriptWarningNotification inst)
					{
						((Notification)inst).Close();
						foreach (ScriptWarningNotification item2 in notifications)
						{
							((Notification)item2).Close();
						}
					}, delegate(ScriptWarningNotification inst)
					{
						((Notification)inst).Close();
						notifications.Pop();
						ScriptManager.ForceLoadScript(script);
						if (notifications.Count == 0)
						{
							LoadLevel(levelContainer);
						}
					}, "Don't Ask Again For This Script", delegate(ScriptWarningNotification inst)
					{
						ConfigManager.scriptCertificateIgnore.Add(script);
						ConfigManager.scriptCertificateIgnoreField.value = string.Join("\n", ConfigManager.scriptCertificateIgnore);
						((Notification)inst).Close();
						notifications.Pop();
						ScriptManager.ForceLoadScript(script);
						if (notifications.Count == 0)
						{
							LoadLevel(levelContainer);
						}
					});
				}
				if (scriptWarningNotification != null)
				{
					notifications.Push(scriptWarningNotification);
					NotificationPanel.Open((Notification)(object)scriptWarningNotification);
				}
			}
			if (notifications.Count == 0)
			{
				LoadLevel(levelContainer);
			}
		}

		public static async Task<bool> LoadLevel(LevelContainer levelContainer, bool showBlocker = true)
		{
			BundleContainer bundleContainer = levelContainer.bundleContainer;
			if (!bundleContainer.Loaded)
			{
				while (bundleContainer.Updating)
				{
					await Task.Yield();
				}
				Task loadTask = bundleContainer.ReloadBundle(forceReload: false, lazyLoad: false);
				await loadTask;
				if (!bundleContainer.Loaded)
				{
					Plugin.logger.LogError((object)("Tried to load level " + levelContainer.LevelName + ", but the bundle could not be loaded into memory!"));
					if (loadTask.Exception != null)
					{
						Plugin.logger.LogError((object)loadTask.Exception);
					}
					return false;
				}
			}
			if (!bundleContainer.TryGetRudeLevelData(levelContainer.levelId, out var rudeLevelData))
			{
				Plugin.logger.LogError((object)("Tried to load level " + levelContainer.LevelName + ", but the rude level data could not be found!"));
				return false;
			}
			_isInCustomLevel = true;
			_currentBundleContainer = levelContainer.bundleContainer;
			_currentLevelContainer = levelContainer;
			_currentLevelData = rudeLevelData;
			_currentLevel = rudeLevelData.scenePath;
			ConfigManager.config.presetButtonInteractable = false;
			foreach (AngryDifficulty difficulty in AngryDifficultyManager.Difficulties)
			{
				difficulty.UnsetDifficulty();
			}
			if (ConfigManager.difficultyField.gamemodeListValueIndex == 0)
			{
				AngryDifficultyManager.SelectedDifficulty.SetDifficulty();
			}
			else if (ConfigManager.difficultyField.gamemodeListValueIndex == 1 || ConfigManager.difficultyField.gamemodeListValueIndex == 2)
			{
				AngryDifficultyManager.HARMLESS.SetDifficulty();
			}
			switch (levelContainer.bundleContainer.BundleVersion)
			{
			case 6:
				LegacyPatchManager.SetLegacyPatchState(LegacyPatchState.V6);
				break;
			case 7:
				LegacyPatchManager.SetLegacyPatchState(LegacyPatchState.V7);
				break;
			default:
				LegacyPatchManager.SetLegacyPatchState(LegacyPatchState.None);
				break;
			}
			AngryMapVarManager.Instance.ResetStores();
			LastPlayedMapManager.UpdateLastPlayed(levelContainer.bundleContainer);
			await AngryAsyncUtils.LoadSceneAsync(rudeLevelData.scenePath, !showBlocker);
			return true;
		}

		public static Task<bool> LoadLevel(LevelContainer levelContainer, AngryGamemodeManager.Gamemode gamemode, AngryDifficulty difficulty, bool showBlocker = true)
		{
			AngryGamemodeManager.ForceSetGamemode(gamemode);
			AngryDifficultyManager.SetDifficulty(difficulty);
			return LoadLevel(levelContainer, showBlocker);
		}

		internal static void Init()
		{
			SceneManager.sceneLoaded += delegate(Scene scene, LoadSceneMode mode)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_0002: Invalid comparison between Unknown and I4
				if ((int)mode != 1 && isInCustomLevel)
				{
					Plugin.logger.LogInfo((object)"Running post scene load event");
					PostSceneLoad();
					MonoSingleton<MapVarManager>.Instance.ReloadMapVars();
				}
			};
		}

		private static void PostSceneLoad()
		{
			//IL_000f: 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)
			Physics.gravity = new Vector3(0f, -40f, 0f);
			SceneHelperPatches.forceDisableIsInCustomLevel = false;
			foreach (Bonus item in Resources.FindObjectsOfTypeAll<Bonus>().Where(delegate(Bonus bonus)
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000b: Unknown result type (might be due to invalid IL or missing references)
				Scene scene2 = ((Component)bonus).gameObject.scene;
				return ((Scene)(ref scene2)).path == currentLevelData.scenePath && (Object)(object)((Component)bonus).GetComponent<IgnoreSecret>() == (Object)null;
			}))
			{
				Scene scene = ((Component)item).gameObject.scene;
				if (!(((Scene)(ref scene)).path != currentLevelData.scenePath) && currentLevelContainer.SecretDiscovered(item.secretNumber))
				{
					item.beenFound = true;
					item.BeenFound();
				}
			}
		}
	}
	internal abstract class AsyncObject
	{
		public abstract bool completed { get; }

		public abstract void WaitForCompletion();
	}
	internal class AsyncAddressableObject<T> : AsyncObject where T : Object
	{
		private bool _completed;

		private AsyncOperationHandle<T> _handle;

		public T result;

		public override bool completed => _completed;

		public AsyncAddressableObject(string path)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			_handle = Addressables.LoadAssetAsync<T>((object)path);
			_handle.Completed += delegate(AsyncOperationHandle<T> h)
			{
				_completed = true;
				result = h.Result;
			};
		}

		public override void WaitForCompletion()
		{
			if (!_completed)
			{
				_handle.WaitForCompletion();
				_completed = true;
				result = _handle.Result;
			}
		}
	}
	internal static class AssetManager
	{
		private static AsyncOperationHandle<bool> cleanBundleCacheHandle;

		private static AsyncAddressableObject<Sprite> _arrow;

		private static AsyncAddressableObject<Sprite> _arrowFilled;

		private static AsyncAddressableObject<Sprite> _notPlayedPreview;

		private static AsyncAddressableObject<Sprite> _lockedPreview;

		private static AsyncAddressableObject<Sprite> _favouriteUnselected;

		private static AsyncAddressableObject<Sprite> _favouriteSelected;

		private static bool _inited;

		public static Sprite arrow
		{
			get
			{
				if (!_arrow.completed)
				{
					_arrow.WaitForCompletion();
				}
				return _arrow.result;
			}
		}

		public static Sprite arrowFilled
		{
			get
			{
				if (!_arrowFilled.completed)
				{
					_arrowFilled.WaitForCompletion();
				}
				return _arrowFilled.result;
			}
		}

		public static Sprite notPlayedPreview
		{
			get
			{
				if (!_notPlayedPreview.completed)
				{
					_notPlayedPreview.WaitForCompletion();
				}
				return _notPlayedPreview.result;
			}
		}

		public static Sprite lockedPreview
		{
			get
			{
				if (!_lockedPreview.completed)
				{
					_lockedPreview.WaitForCompletion();
				}
				return _lockedPreview.result;
			}
		}

		public static Sprite favouriteUnselected
		{
			get
			{
				if (!_favouriteUnselected.completed)
				{
					_favouriteUnselected.WaitForCompletion();
				}
				return _favouriteUnselected.result;
			}
		}

		public static Sprite favouriteSelected
		{
			get
			{
				if (!_favouriteSelected.completed)
				{
					_favouriteSelected.WaitForCompletion();
				}
				return _favouriteSelected.result;
			}
		}

		public static AsyncOperationHandle<bool> CleanBundleCache()
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			if (cleanBundleCacheHandle.IsDone)
			{
				cleanBundleCacheHandle = Addressables.CleanBundleCache((IEnumerable<string>)null);
			}
			return cleanBundleCacheHandle;
		}

		public static void Init()
		{
			if (!_inited)
			{
				_inited = true;
				_arrow = new AsyncAddressableObject<Sprite>("AngryLevelLoader/Textures/arrow.png");
				_arrowFilled = new AsyncAddressableObject<Sprite>("AngryLevelLoader/Textures/arrow-filled.png");
				_notPlayedPreview = new AsyncAddressableObject<Sprite>("Assets/Textures/UI/Level Thumbnails/Locked3.png");
				_lockedPreview = new AsyncAddressableObject<Sprite>("Assets/Textures/UI/Level Thumbnails/Locked.png");
				_favouriteUnselected = new AsyncAddressableObject<Sprite>("AngryLevelLoader/Textures/fav-unselected.png");
				_favouriteSelected = new AsyncAddressableObject<Sprite>("AngryLevelLoader/Textures/fav-selected.png");
			}
		}
	}
	internal static class ConfigManager
	{
		public enum CustomLevelButtonPosition
		{
			Top,
			Bottom,
			Disabled
		}

		public enum BundleSorting
		{
			Alphabetically,
			Author,
			LastPlayed,
			LastUpdate
		}

		public enum DefaultLeaderboardCategory
		{
			All,
			PRank,
			Challenge,
			Nomo,
			Nomow
		}

		public enum DefaultLeaderboardDifficulty
		{
			Any,
			Harmless,
			Lenient,
			Standard,
			Violent,
			Brutal
		}

		public enum DefaultLeaderboardFilter
		{
			Global,
			Friends
		}

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

			public static PostPresetChangeEvent <>9__49_0;

			public static Func<string, bool> <>9__49_18;

			public static Func<string, string> <>9__49_19;

			public static OpenPanelEventDelegate <>9__49_1;

			public static OpenPanelEventDelegate <>9__49_2;

			public static PostBoolValueChangeEvent <>9__49_3;

			public static PostEnumValueChangeEvent<BundleSorting> <>9__49_4;

			public static PostStringListValueChangeEvent <>9__49_22;

			public static OpenPanelEventDelegate <>9__49_5;

			public static OnClick <>9__49_6;

			public static OnClick <>9__49_7;

			public static OnClick <>9__49_8;

			public static KeyCodeValueChangeEventDelegate <>9__49_9;

			public static KeyCodeValueChangeEventDelegate <>9__49_10;

			public static BoolValueChangeEventDelegate <>9__49_11;

			public static BoolValueChangeEventDelegate <>9__49_12;

			public static BoolValueChangeEventDelegate <>9__49_13;

			public static OnClick <>9__49_15;

			public static OnClick <>9__49_17;

			public static OnClick <>9__50_0;

			internal void <InitializeConfig>b__49_0(string b, string a)
			{
				foreach (BundleContainer allBundleContainer in Plugin.GetAllBundleContainers())
				{
					allBundleContainer.UpdateAllUI();
				}
			}

			internal void <InitializeConfig>b__49_1(bool external)
			{
				if (newLevelToggle.value)
				{
					newLevelNotifier.text = string.Join("\n", from level in newLevelNotifierLevels.value.Split('`')
						where !string.IsNullOrEmpty(level)
						select level into name
						select "<color=#00FF00>New level: " + name + "</color>");
					((ConfigField)newLevelNotifier).hidden = false;
					newLevelNotifierLevels.value = "";
				}
				newLevelToggle.value = false;
			}

			internal bool <InitializeConfig>b__49_18(string level)
			{
				return !string.IsNullOrEmpty(level);
			}

			internal string <InitializeConfig>b__49_19(string name)
			{
				return "<color=#00FF00>New level: " + name + "</color>";
			}

			internal void <InitializeConfig>b__49_2(bool e)
			{
				((ConfigField)newLevelNotifier).hidden = true;
			}

			internal void <InitializeConfig>b__49_3(bool fav)
			{
				AngryBundleList.SortBundles();
			}

			internal void <InitializeConfig>b__49_4(BundleSorting mode)
			{
				AngryBundleList.SortBundles();
			}

			internal void <InitializeConfig>b__49_22(string gamemodeName, int gamemodeIndex)
			{
				difficultyField.TriggerPostDifficultyChangeEvent();
			}

			internal void <InitializeConfig>b__49_5(bool externally)
			{
				difficultyField.TriggerPostDifficultyChangeEvent();
			}

			internal void <InitializeConfig>b__49_6()
			{
				openButtons.SetButtonInteractable(1, false);
				PluginUpdateHandler.ShowChangelog();
			}

			internal void <InitializeConfig>b__49_7()
			{
				Application.OpenURL(Plugin.levelsPath);
			}

			internal void <InitializeConfig>b__49_8()
			{
				Application.OpenURL(AngryPaths.ScriptsPath);
			}

			internal void <InitializeConfig>b__49_9(KeyCodeValueChangeEvent e)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_000b: Invalid comparison between Unknown and I4
				//IL_000e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0018: Invalid comparison between Unknown and I4
				//IL_001b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0025: Invalid comparison between Unknown and I4
				if ((int)e.value == 323 || (int)e.value == 324 || (int)e.value == 325)
				{
					e.canceled = true;
				}
			}

			internal void <InitializeConfig>b__49_10(KeyCodeValueChangeEvent e)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_000b: Invalid comparison between Unknown and I4
				//IL_000e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0018: Invalid comparison between Unknown and I4
				//IL_001b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0025: Invalid comparison between Unknown and I4
				if ((int)e.value == 323 || (int)e.value == 324 || (int)e.value == 325)
				{
					e.canceled = true;
				}
			}

			internal void <InitializeConfig>b__49_11(BoolValueChangeEvent e)
			{
				levelUpdateNotifierToggle.value = e.value;
				OnlineLevelsList.CheckLevelUpdateText();
			}

			internal void <InitializeConfig>b__49_12(BoolValueChangeEvent e)
			{
				levelUpdateIgnoreCustomBuilds.value = e.value;
				OnlineLevelsList.CheckLevelUpdateText();
			}

			internal void <InitializeConfig>b__49_13(BoolValueChangeEvent e)
			{
				newLevelNotifierToggle.value = e.value;
				if (!e.value)
				{
					((ConfigField)newLevelNotifier).hidden = true;
				}
			}

			internal void <InitializeConfig>b__49_15()
			{
				NotificationPanel.Open((Notification)(object)new DeleteOldBundlesNotification());
			}

			internal void <InitializeConfig>b__49_17()
			{
				Plugin.ScanForLevels();
			}

			internal void <InitializeErrorConfig>b__50_0()
			{
				Application.OpenURL("https://github.com/eternalUnion/AngryLevelLoader/issues");
			}
		}

		public static PluginConfigurator config;

		public static DifficultyField difficultyField;

		public static ConfigHeader levelUpdateNotifier;

		public static ConfigHeader newLevelNotifier;

		public static StringField newLevelNotifierLevels;

		public static BoolField newLevelToggle;

		public static ConfigHeader errorText;

		public static ConfigHeader levelBundlesHeader;

		public static SearchBarField searchBar;

		public static ConfigDivision folderDivision;

		public static ConfigDivision bundleDivision;

		public static ConfigHeader searchInfo;

		public static ConfigDivision leaderboardsDivision;

		public static ConfigPanel bannedModsPanel;

		public static ConfigHeader bannedModsText;

		public static ConfigPanel pendingRecords;

		public static ButtonField sendPendingRecords;

		public static ConfigHeader pendingRecordsStatus;

		public static ConfigHeader pendingRecordsInfo;

		public static ButtonField changelogButton;

		public static ButtonArrayField openButtons;

		public static KeyCodeField reloadFileKeybind;

		public static KeyCodeField reloadScriptKeybind;

		public static EnumField<CustomLevelButtonPosition> customLevelButtonPosition;

		public static ColorField customLevelButtonFrameColor;

		public static ColorField customLevelButtonTextColor;

		public static BoolField refreshCatalogOnBoot;

		public static BoolField levelUpdateNotifierToggle;

		public static BoolField levelUpdateIgnoreCustomBuilds;

		public static BoolField newLevelNotifierToggle;

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

		public static StringMultilineField scriptCertificateIgnoreField;

		public static BoolField useDevelopmentBranch;

		public static BoolField useLocalServer;

		public static BoolField scriptUpdateIgnoreCustom;

		public static BoolField bundleFavSort;

		public static EnumField<BundleSorting> bundleSortingMode;

		public static BoolField reloadAlwaysGoToMainMenu;

		public static BoolField showLeaderboardOnLevelEnd;

		public static BoolField showLeaderboardOnSecretLevelEnd;

		public static EnumField<DefaultLeaderboardCategory> defaultLeaderboardCategory;

		public static EnumField<DefaultLeaderboardDifficulty> defaultLeaderboardDifficulty;

		public static EnumField<DefaultLeaderboardFilter> defaultLeaderboardFilter;

		internal static void DisableAllConfig()
		{
			Stack<ConfigField> stack = new Stack<ConfigField>(config.rootPanel.GetAllFields());
			while (stack.Count != 0)
			{
				ConfigField val = stack.Pop();
				ConfigPanel val2 = (ConfigPanel)(object)((val is ConfigPanel) ? val : null);
				if (val2 != null)
				{
					ConfigField[] allFields = val2.GetAllFields();
					foreach (ConfigField item in allFields)
					{
						stack.Push(item);
					}
				}
				val.interactable = false;
			}
		}

		public static void InitializeConfig()
		{
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Expected O, but got Unknown
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Expected O, but got Unknown
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Expected O, but got Unknown
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Expected O, but got Unknown
			//IL_012c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0136: Expected O, but got Unknown
			//IL_0145: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Expected O, but got Unknown
			//IL_01ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b5: Expected O, but got Unknown
			//IL_01dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e6: Expected O, but got Unknown
			//IL_0225: Unknown result type (might be due to invalid IL or missing references)
			//IL_022f: Expected O, but got Unknown
			//IL_023f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0249: Expected O, but got Unknown
			//IL_027b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0285: Expected O, but got Unknown
			//IL_0291: Unknown result type (might be due to invalid IL or missing references)
			//IL_029b: Expected O, but got Unknown
			//IL_02ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b6: Expected O, but got Unknown
			//IL_02c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e1: Expected O, but got Unknown
			//IL_030f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0319: Expected O, but got Unknown
			//IL_0187: Unknown result type (might be due to invalid IL or missing references)
			//IL_018c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0192: Expected O, but got Unknown
			//IL_0332: Unknown result type (might be due to invalid IL or missing references)
			//IL_0337: Unknown result type (might be due to invalid IL or missing references)
			//IL_033d: Expected O, but got Unknown
			//IL_03bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c6: Expected O, but got Unknown
			//IL_03cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_03fe: Expected O, but got Unknown
			//IL_03fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0408: Expected O, but got Unknown
			//IL_0437: Unknown result type (might be due to invalid IL or missing references)
			//IL_0441: Expected O, but got Unknown
			//IL_0427: Unknown result type (might be due to invalid IL or missing references)
			//IL_042c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0432: Expected O, but got Unknown
			//IL_048f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0499: Expected O, but got Unknown
			//IL_04a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_04cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_04d5: Expected O, but got Unknown
			//IL_045f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0464: Unknown result type (might be due to invalid IL or missing references)
			//IL_046a: Expected O, but got Unknown
			//IL_053b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0545: Expected O, but got Unknown
			//IL_04ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_04f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_04f9: Expected O, but got Unknown
			//IL_0564: Unknown result type (might be due to invalid IL or missing references)
			//IL_0569: Unknown result type (might be due to invalid IL or missing references)
			//IL_056f: Expected O, but got Unknown
			//IL_05b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_05be: Expected O, but got Unknown
			//IL_0593: Unknown result type (might be due to invalid IL or missing references)
			//IL_0598: Unknown result type (might be due to invalid IL or missing references)
			//IL_059e: Expected O, but got Unknown
			//IL_05f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0602: Expected O, but got Unknown
			//IL_05d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_05dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_05e2: Expected O, but got Unknown
			//IL_0638: Unknown result type (might be due to invalid IL or missing references)
			//IL_064c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0681: Unknown result type (might be due to invalid IL or missing references)
			//IL_0686: Unknown result type (might be due to invalid IL or missing references)
			//IL_0691: Unknown result type (might be due to invalid IL or missing references)
			//IL_069b: Expected O, but got Unknown
			//IL_0696: Unknown result type (might be due to invalid IL or missing references)
			//IL_06a0: Expected O, but got Unknown
			//IL_06aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_06b4: Expected O, but got Unknown
			//IL_06af: Unknown result type (might be due to invalid IL or missing references)
			//IL_06b9: Expected O, but got Unknown
			//IL_06c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_06da: Unknown result type (might be due to invalid IL or missing references)
			//IL_06ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_0706: Unknown result type (might be due to invalid IL or missing references)
			//IL_0710: Expected O, but got Unknown
			//IL_0721: Unknown result type (might be due to invalid IL or missing references)
			//IL_072b: Expected O, but got Unknown
			//IL_07ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_07de: Unknown result type (might be due to invalid IL or missing references)
			//IL_07f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0803: Expected O, but got Unknown
			//IL_0814: Unknown result type (might be due to invalid IL or missing references)
			//IL_081e: Expected O, but got Unknown
			//IL_082f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0839: Expected O, but got Unknown
			//IL_061b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0620: Unknown result type (might be due to invalid IL or missing references)
			//IL_0626: Expected O, but got Unknown
			//IL_0882: Unknown result type (might be due to invalid IL or missing references)
			//IL_088c: Expected O, but got Unknown
			//IL_08c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_08d0: Expected O, but got Unknown
			//IL_08a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_08aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_08b0: Expected O, but got Unknown
			//IL_090f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0919: Expected O, but got Unknown
			//IL_0935: Unknown result type (might be due to invalid IL or missing references)
			//IL_093f: Expected O, but got Unknown
			//IL_08e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_08ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_08f4: Expected O, but got Unknown
			//IL_0975: Unknown result type (might be due to invalid IL or missing references)
			//IL_0989: Unknown result type (might be due to invalid IL or missing references)
			//IL_09a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_09ae: Expected O, but got Unknown
			//IL_09c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_09ce: Expected O, but got Unknown
			//IL_0a08: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a1c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a37: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a41: Expected O, but got Unknown
			//IL_0a5f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a64: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a86: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a90: Expected O, but got Unknown
			//IL_0aa0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ab3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0abd: Expected O, but got Unknown
			//IL_0ad0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ada: Expected O, but got Unknown
			//IL_0aea: Unknown result type (might be due to invalid IL or missing references)
			//IL_0958: Unknown result type (might be due to invalid IL or missing references)
			//IL_095d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0963: Expected O, but got Unknown
			//IL_0b54: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b59: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b67: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b71: Expected O, but got Unknown
			//IL_0b03: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b08: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b0e: Expected O, but got Unknown
			//IL_0bb1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0bbb: Expected O, but got Unknown
			//IL_0bcc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0bd6: Expected O, but got Unknown
			//IL_0c09: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c13: Expected O, but got Unknown
			//IL_0c22: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c2c: Expected O, but got Unknown
			//IL_0c3d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c47: Expected O, but got Unknown
			//IL_0c4c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b8b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b90: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b96: Expected O, but got Unknown
			if (config != null)
			{
				return;
			}
			InternalConfigManager.InitializeInternalConfig();
			config = PluginConfigurator.Create("Angry Level Loader", "com.eternalUnion.angryLevelLoader");
			PluginConfigurator obj = config;
			object obj2 = <>c.<>9__49_0;
			if (obj2 == null)
			{
				PostPresetChangeEvent val = delegate
				{
					foreach (BundleContainer allBundleContainer in Plugin.GetAllBundleContainers())
					{
						allBundleContainer.UpdateAllUI();
					}
				};
				<>c.<>9__49_0 = val;
				obj2 = (object)val;
			}
			obj.postPresetChangeEvent += (PostPresetChangeEvent)obj2;
			config.SetIconWithURL("file://" + Path.Combine(Plugin.workingDir, "plugin-icon.png"));
			newLevelToggle = new BoolField(config.rootPanel, "", "v_newLevelToggle", false);
			((ConfigField)newLevelToggle).hidden = true;
			ConfigPanel rootPanel = config.rootPanel;
			object obj3 = <>c.<>9__49_1;
			if (obj3 == null)
			{
				OpenPanelEventDelegate val2 = delegate
				{
					if (newLevelToggle.value)
					{
						newLevelNotifier.text = string.Join("\n", from level in newLevelNotifierLevels.value.Split('`')
							where !string.IsNullOrEmpty(level)
							select level into name
							select "<color=#00FF00>New level: " + name + "</color>");
						((ConfigField)newLevelNotifier).hidden = false;
						newLevelNotifierLevels.value = "";
					}
					newLevelToggle.value = false;
				};
				<>c.<>9__49_1 = val2;
				obj3 = (object)val2;
			}
			rootPanel.onPannelOpenEvent += (OpenPanelEventDelegate)obj3;
			newLevelNotifier = new ConfigHeader(config.rootPanel, "<color=#00FF00>New levels are available!</color>", 16);
			((ConfigField)newLevelNotifier).hidden = true;
			levelUpdateNotifier = new ConfigHeader(config.rootPanel, "<color=#00FF00>Level updates available!</color>", 16);
			((ConfigField)levelUpdateNotifier).hidden = true;
			OnlineLevelsList.onlineLevelsPanel = new ConfigPanel(InternalConfigManager.internalConfig.rootPanel, "Online Levels", "b_onlineLevels", (PanelFieldType)1);
			new ConfigBridge((ConfigField)(object)OnlineLevelsList.onlineLevelsPanel, config.rootPanel);
			OnlineLevelsList.onlineLevelsPanel.SetIconWithURL("file://" + Path.Combine(Plugin.workingDir, "online-icon.png"));
			ConfigPanel onlineLevelsPanel = OnlineLevelsList.onlineLevelsPanel;
			object obj4 = <>c.<>9__49_2;
			if (obj4 == null)
			{
				OpenPanelEventDelegate val3 = delegate
				{
					((ConfigField)newLevelNotifier).hidden = true;
				};
				<>c.<>9__49_2 = val3;
				obj4 = (object)val3;
			}
			onlineLevelsPanel.onPannelOpenEvent += (OpenPanelEventDelegate)obj4;
			OnlineLevelsList.Init();
			leaderboardsDivision = new ConfigDivision(config.rootPanel, "leaderboardsDivision");
			((ConfigField)leaderboardsDivision).hidden = !InternalConfigManager.leaderboardToggle.value;
			bannedModsPanel = new ConfigPanel((ConfigPanel)(object)leaderboardsDivision, "Leaderboard banned mods", "bannedModsPanel", (PanelFieldType)1);
			bannedModsPanel.SetIconWithURL("file://" + Path.Combine(Plugin.workingDir, "banned-mods-icon.png"));
			((ConfigField)bannedModsPanel).hidden = true;
			bannedModsText = new ConfigHeader(bannedModsPanel, "", 24, (TextAlignmentOptions)513);
			pendingRecords = new ConfigPanel((ConfigPanel)(object)leaderboardsDivision, "Pending records", "pendingRecords", (PanelFieldType)1);
			pendingRecords.SetIconWithURL("file://" + Path.Combine(Plugin.workingDir, "pending.png"));
			sendPendingRecords = new ButtonField(pendingRecords, "Send Pending Records", "sendPendingRecordsButton");
			sendPendingRecords.onClick += new OnClick(PendingRecordsManager.ProcessPendingRecords);
			pendingRecordsStatus = new ConfigHeader(pendingRecords, "", 20, (TextAlignmentOptions)513);
			new ConfigSpace(pendingRecords, 5f);
			pendingRecordsInfo = new ConfigHeader(pendingRecords, "", 18, (TextAlignmentOptions)513);
			PendingRecordsManager.UpdatePendingRecordsUI();
			difficultyField = new DifficultyField(config.rootPanel);
			bundleFavSort = new BoolField(InternalConfigManager.internalConfig.rootPanel, "Sort by fav", "s_bundleSortingFav", true);
			BoolField obj5 = bundleFavSort;
			object obj6 = <>c.<>9__49_3;
			if (obj6 == null)
			{
				PostBoolValueChangeEvent val4 = delegate
				{
					AngryBundleList.SortBundles();
				};
				<>c.<>9__49_3 = val4;
				obj6 = (object)val4;
			}
			obj5.postValueChangeEvent += (PostBoolValueChangeEvent)obj6;
			bundleSortingMode = new EnumField<BundleSorting>(InternalConfigManager.internalConfig.rootPanel, "Bundle sorting", "s_bundleSortingMode", BundleSorting.LastPlayed);
			bundleSortingMode.postValueChangeEvent += delegate
			{
				AngryBundleList.SortBundles();
			};
			bundleSortingMode.SetEnumDisplayName(BundleSorting.LastPlayed, "Last Played");
			bundleSortingMode.SetEnumDisplayName(BundleSorting.LastUpdate, "Last Update");
			ConfigHeader difficultyOverrideWarning = new ConfigHeader(config.rootPanel, "Difficulty is overridden by gamemode\nWarning: Some levels may not be compatible with gamemodes", 18);
			difficultyOverrideWarning.textColor = Color.yellow;
			((ConfigField)difficultyOverrideWarning).hidden = true;
			DifficultyField obj7 = difficultyField;
			obj7.postDifficultyChange = (PostStringListValueChangeEvent)Delegate.Combine((Delegate?)(object)obj7.postDifficultyChange, (Delegate?)(PostStringListValueChangeEvent)delegate(string difficultyName, int difficultyIndex)
			{
				AngryDifficulty angryDifficulty = AngryDifficultyManager.Difficulties.Where((AngryDifficulty d) => d.name == difficultyName).FirstOrDefault();
				if (angryDifficulty == null)
				{
					angryDifficulty = AngryDifficultyManager.VIOLENT;
				}
				AngryDifficultyManager.SelectedDifficulty = angryDifficulty;
				if (difficultyField.gamemodeListValueIndex == 1 || difficultyField.gamemodeListValueIndex == 2)
				{
					((ConfigField)difficultyOverrideWarning).hidden = false;
					difficultyField.difficultyInteractable = false;
					difficultyField.ForceSetDifficultyUI(0);
					AngryDifficultyManager.SelectedDifficulty = AngryDifficultyManager.HARMLESS;
				}
				else
				{
					((ConfigField)difficultyOverrideWarning).hidden = true;
					difficultyField.difficultyInteractable = true;
					difficultyIndex = MiscHelpers.IndexOf<AngryDifficulty>((IEnumerable<AngryDifficulty>)AngryDifficultyManager.Difficulties, angryDifficulty);
					if (difficultyIndex == -1)
					{
						angryDifficulty = AngryDifficultyManager.VIOLENT;
						difficultyIndex = MiscHelpers.IndexOf<AngryDifficulty>((IEnumerable<AngryDifficulty>)AngryDifficultyManager.Difficulties, angryDifficulty);
					}
					difficultyField.ForceSetDifficultyUI(difficultyIndex);
				}
			});
			DifficultyField obj8 = difficultyField;
			PostStringListValueChangeEvent postGamemodeChange = obj8.postGamemodeChange;
			object obj9 = <>c.<>9__49_22;
			if (obj9 == null)
			{
				PostStringListValueChangeEvent val5 = delegate
				{
					difficultyField.TriggerPostDifficultyChangeEvent();
				};
				<>c.<>9__49_22 = val5;
				obj9 = (object)val5;
			}
			obj8.postGamemodeChange = (PostStringListValueChangeEvent)Delegate.Combine((Delegate?)(object)postGamemodeChange, (Delegate?)obj9);
			ConfigPanel rootPanel2 = config.rootPanel;
			object obj10 = <>c.<>9__49_5;
			if (obj10 == null)
			{
				OpenPanelEventDelegate val6 = delegate
				{
					difficultyField.TriggerPostDifficultyChangeEvent();
				};
				<>c.<>9__49_5 = val6;
				obj10 = (object)val6;
			}
			rootPanel2.onPannelOpenEvent += (OpenPanelEventDelegate)obj10;
			difficultyField.TriggerPostDifficultyChangeEvent();
			ConfigPanel settingsPanel = new ConfigPanel(InternalConfigManager.internalConfig.rootPanel, "Settings", "p_settings", (PanelFieldType)0);
			new ConfigBridge((ConfigField)(object)settingsPanel, config.rootPanel);
			((ConfigField)settingsPanel).hidden = true;
			changelogButton = new ButtonField(settingsPanel, "Changelog", "changelogButton");
			ButtonField obj11 = changelogButton;
			object obj12 = <>c.<>9__49_6;
			if (obj12 == null)
			{
				OnClick val7 = delegate
				{
					openButtons.SetButtonInteractable(1, false);
					PluginUpdateHandler.ShowChangelog();
				};
				<>c.<>9__49_6 = val7;
				obj12 = (object)val7;
			}
			obj11.onClick += (OnClick)obj12;
			openButtons = new ButtonArrayField(settingsPanel, "settingButtons", 2, new float[2] { 0.5f, 0.5f }, new string[2] { "Open Levels Folder", "Open Scripts Folder" }, 5f);
			ButtonClickEvent obj13 = openButtons.OnClickEventHandler(0);
			object obj14 = <>c.<>9__49_7;
			if (obj14 == null)
			{
				OnClick val8 = delegate
				{
					Application.OpenURL(Plugin.levelsPath);
				};
				<>c.<>9__49_7 = val8;
				obj14 = (object)val8;
			}
			obj13.onClick += (OnClick)obj14;
			ButtonClickEvent obj15 = openButtons.OnClickEventHandler(1);
			object obj16 = <>c.<>9__49_8;
			if (obj16 == null)
			{
				OnClick val9 = delegate
				{
					Application.OpenURL(AngryPaths.ScriptsPath);
				};
				<>c.<>9__49_8 = val9;
				obj16 = (object)val9;
			}
			obj15.onClick += (OnClick)obj16;
			reloadFileKeybind = new KeyCodeField(settingsPanel, "Reload File", "f_reloadFile", (KeyCode)0);
			KeyCodeField obj17 = reloadFileKeybind;
			object obj18 = <>c.<>9__49_9;
			if (obj18 == null)
			{
				KeyCodeValueChangeEventDelegate val10 = delegate(KeyCodeValueChangeEvent e)
				{
					//IL_0001: Unknown result type (might be due to invalid IL or missing references)
					//IL_000b: Invalid comparison between Unknown and I4
					//IL_000e: Unknown result type (might be due to invalid IL or missing references)
					//IL_0018: Invalid comparison between Unknown and I4
					//IL_001b: Unknown result type (might be due to invalid IL or missing references)
					//IL_0025: Invalid comparison between Unknown and I4
					if ((int)e.value == 323 || (int)e.value == 324 || (int)e.value == 325)
					{
						e.canceled = true;
					}
				};
				<>c.<>9__49_9 = val10;
				obj18 = (object)val10;
			}
			obj17.onValueChange += (KeyCodeValueChangeEventDelegate)obj18;
			reloadScriptKeybind = new KeyCodeField(settingsPanel, "Reload Script", "f_reloadScript", (KeyCode)0);
			KeyCodeField obj19 = reloadScriptKeybind;
			object obj20 = <>c.<>9__49_10;
			if (obj20 == null)
			{
				KeyCodeValueChangeEventDelegate val11 = delegate(KeyCodeValueChangeEvent e)
				{
					//IL_0001: Unknown result type (might be due to invalid IL or missing references)
					//IL_000b: Invalid comparison between Unknown and I4
					//IL_000e: Unknown result type (might be due to invalid IL or missing references)
					//IL_0018: Invalid comparison between Unknown and I4
					//IL_001b: Unknown result type (might be due to invalid IL or missing references)
					//IL_0025: Invalid comparison between Unknown and I4
					if ((int)e.value == 323 || (int)e.value == 324 || (int)e.value == 325)
					{
						e.canceled = true;
					}
				};
				<>c.<>9__49_10 = val11;
				obj20 = (object)val11;
			}
			obj19.onValueChange += (KeyCodeValueChangeEventDelegate)obj20;
			new ConfigHeader(settingsPanel, "User Interface", 24).textColor = new Color(1f, 0.504717f, 0.9454f);
			customLevelButtonPosition = new EnumField<CustomLevelButtonPosition>(settingsPanel, "Custom level button position", "s_customLevelButtonPosition", CustomLevelButtonPosition.Bottom);
			ConfigPanel val12 = new ConfigPanel(settingsPanel, "Custom level button colors", "customLevelButtonPanel");
			customLevelButtonFrameColor = new ColorField(val12, "Custom level button frame color", "s_customLevelButtonFrameColor", Color.white);
			customLevelButtonTextColor = new ColorField(val12, "Custom level button text color", "s_customLevelButtonTextColor", Color.white);
			new ConfigHeader(settingsPanel, "Leaderboards", 24).textColor = new Color(1f, 0.692924f, 0.291f);
			new ConfigBridge((ConfigField)(object)InternalConfigManager.leaderboardToggle, settingsPanel);
			showLeaderboardOnLevelEnd = new BoolField(settingsPanel, "Show leaderboard on level end", "showLeaderboardOnLevelEnd", true);
			showLeaderboardOnSecretLevelEnd = new BoolField(settingsPanel, "Show leaderboard on secret level end", "showLeaderboardOnSecretLevelEnd", true);
			new SpaceField(settingsPanel, 5f);
			defaultLeaderboardCategory = new EnumField<DefaultLeaderboardCategory>(settingsPanel, "Default leaderboard category", "defaultLeaderboardCategory", DefaultLeaderboardCategory.All);
			defaultLeaderboardCategory.SetEnumDisplayName(DefaultLeaderboardCategory.PRank, "P Rank");
			defaultLeaderboardCategory.SetEnumDisplayName(DefaultLeaderboardCategory.Nomo, "No Monsters");
			defaultLeaderboardCategory.SetEnumDisplayName(DefaultLeaderboardCategory.Nomow, "No Monsters/Weapons");
			defaultLeaderboardDifficulty = new EnumField<DefaultLeaderboardDifficulty>(settingsPanel, "Default leaderboard difficulty", "defaultLeaderboardDifficulty", DefaultLeaderboardDifficulty.Any);
			defaultLeaderboardFilter = new EnumField<DefaultLeaderboardFilter>(settingsPanel, "Default leaderboard filter", "defaultLeaderboardFilter", DefaultLeaderboardFilter.Global);
			new ConfigHeader(settingsPanel, "Online", 24).textColor = new Color(0.532f, 0.8284001f, 1f);
			refreshCatalogOnBoot = new BoolField(settingsPanel, "Refresh online catalog on boot", "s_refreshCatalogBoot", true);
			useDevelopmentBranch = new BoolField(settingsPanel, "Use development chanel", "s_useDevChannel", false);
			useLocalServer = new BoolField(settingsPanel, "Use local server", "s_useLocalServer", false);
			if (!InternalConfigManager.devMode.value)
			{
				((ConfigField)useDevelopmentBranch).hidden = true;
				useDevelopmentBranch.value = false;
				((ConfigField)useLocalServer).hidden = true;
				useLocalServer.value = false;
			}
			levelUpdateNotifierToggle = new BoolField(settingsPanel, "Notify on level updates", "s_levelUpdateNofify", true);
			BoolField obj21 = levelUpdateNotifierToggle;
			object obj22 = <>c.<>9__49_11;
			if (obj22 == null)
			{
				BoolValueChangeEventDelegate val13 = delegate(BoolValueChangeEvent e)
				{
					levelUpdateNotifierToggle.value = e.value;
					OnlineLevelsList.CheckLevelUpdateText();
				};
				<>c.<>9__49_11 = val13;
				obj22 = (object)val13;
			}
			obj21.onValueChange += (BoolValueChangeEventDelegate)obj22;
			levelUpdateIgnoreCustomBuilds = new BoolField(settingsPanel, "Ignore updates for custom build", "s_levelUpdateIgnoreCustomBuilds", false);
			BoolField obj23 = levelUpdateIgnoreCustomBuilds;
			object obj24 = <>c.<>9__49_12;
			if (obj24 == null)
			{
				BoolValueChangeEventDelegate val14 = delegate(BoolValueChangeEvent e)
				{
					levelUpdateIgnoreCustomBuilds.value = e.value;
					OnlineLevelsList.CheckLevelUpdateText();
				};
				<>c.<>9__49_12 = val14;
				obj24 = (object)val14;
			}
			obj23.onValueChange += (BoolValueChangeEventDelegate)obj24;
			newLevelNotifierLevels = new StringField(settingsPanel, "h_New levels", "s_newLevelNotifierLevels", "", true);
			((ConfigField)newLevelNotifierLevels).hidden = true;
			newLevelNotifierToggle = new BoolField(settingsPanel, "Notify on new level release", "s_newLevelNotiftToggle", true);
			BoolField obj25 = newLevelNotifierToggle;
			object obj26 = <>c.<>9__49_13;
			if (obj26 == null)
			{
				BoolValueChangeEventDelegate val15 = delegate(BoolValueChangeEvent e)
				{
					newLevelNotifierToggle.value = e.value;
					if (!e.value)
					{
						((ConfigField)newLevelNotifier).hidden = true;
					}
				};
				<>c.<>9__49_13 = val15;
				obj26 = (object)val15;
			}
			obj25.onValueChange += (BoolValueChangeEventDelegate)obj26;
			new ConfigHeader(settingsPanel, "Scripts", 24).textColor = new Color(0.6248745f, 1f, 0.617f);
			scriptUpdateIgnoreCustom = new BoolField(settingsPanel, "Ignore updates for custom builds", "s_scriptUpdateIgnoreCustom", false);
			scriptCertificateIgnoreField = new StringMultilineField(settingsPanel, "Certificate ignore", "s_scriptCertificateIgnore", "", true);
			scriptCertificateIgnore = scriptCertificateIgnoreField.value.Split('\n').ToList();
			new SpaceField(settingsPanel, 5f);
			new ConfigHeader(settingsPanel, "Compatibility", 24).textColor = new Color(1f, 0.408f, 0.408f);
			reloadAlwaysGoToMainMenu = new BoolField(settingsPanel, "Quick reload in main menu", "s_reloadAlwaysGoToMainMenu", false);
			new SpaceField(settingsPanel, 5f);
			new ConfigHeader(settingsPanel, "Danger Zone", 24).textColor = Color.red;
			StringField dataPathInput = new StringField(settingsPanel, "Data Path", "s_dataPathInput", Plugin.dataPath, false, false);
			ButtonField val16 = new ButtonField(settingsPanel, "Move Data", "s_changeDataPath");
			ConfigHeader dataInfo = new ConfigHeader(settingsPanel, "<color=red>RESTART REQUIRED</color>", 18);
			((ConfigField)dataInfo).hidden = true;
			val16.onClick += (OnClick)delegate
			{
				string value = dataPathInput.value;
				if (!(value == InternalConfigManager.configDataPath.value))
				{
					if (!Directory.Exists(value))
					{
						dataInfo.text = "<color=red>Could not find the directory</color>";
						((ConfigField)dataInfo).hidden = false;
					}
					else
					{
						string text = Path.Combine(value, "Levels");
						AngryIOUtils.TryCreateDirectory(text);
						string[] files = Directory.GetFiles(Plugin.levelsPath);
						foreach (string text2 in files)
						{
							string text3 = Path.Combine(text, Path.GetFileName(text2));
							if (File.Exists(text3))
							{
								File.Copy(text2, text3, overwrite: true);
								File.Delete(text2);
							}
							else
							{
								File.Move(text2, text3);
							}
						}
						Directory.Delete(Plugin.levelsPath, recursive: true);
						Plugin.levelsPath = text;
						string text4 = Path.Combine(value, "LevelsUnpacked");
						AngryIOUtils.TryCreateDirectory(text4);
						files = Directory.GetDirectories(Plugin.tempFolderPath);
						foreach (string text5 in files)
						{
							string text6 = Path.Combine(text4, Path.GetFileName(text5));
							if (Directory.Exists(text6))
							{
								Directory.Delete(text6, recursive: true);
							}
							AngryIOUtils.DirectoryCopy(text5, text6, copySubDirs: true, deleteSource: true);
						}
						Directory.Delete(Plugin.tempFolderPath, recursive: true);
						Plugin.tempFolderPath = text4;
						string text7 = Path.Combine(value, "MapVars");
						AngryIOUtils.TryCreateDirectory(text7);
						files = Directory.GetDirectories(Path.Combine(Plugin.dataPath, "MapVars"));
						foreach (string text8 in files)
						{
							string text9 = Path.Combine(text7, Path.GetFileName(text8));
							if (Directory.Exists(text9))
							{
								Directory.Delete(text9, recursive: true);
							}
							AngryIOUtils.DirectoryCopy(text8, text9, copySubDirs: true, deleteSource: true);
						}
						if (Directory.Exists(Path.Combine(Plugin.dataPath, "MapVars")))
						{
							Directory.Delete(Path.Combine(Plugin.dataPath, "MapVars"), recursive: true);
						}
						dataInfo.text = "<color=red>RESTART REQUIRED</color>";
						((ConfigField)dataInfo).hidden = false;
						InternalConfigManager.configDataPath.value = value;
						DisableAllConfig();
					}
				}
			};
			ButtonField val17 = new ButtonField(settingsPanel, "Delete Old Bundles", "s_deleteOldBundles");
			object obj27 = <>c.<>9__49_15;
			if (obj27 == null)
			{
				OnClick val18 = delegate
				{
					NotificationPanel.Open((Notification)(object)new DeleteOldBundlesNotification());
				};
				<>c.<>9__49_15 = val18;
				obj27 = (object)val18;
			}
			val17.onClick += (OnClick)obj27;
			ButtonArrayField val19 = new ButtonArrayField(config.rootPanel, "settingsAndReload", 2, new float[2] { 0.5f, 0.5f }, new string[2] { "Settings", "Scan For Levels" }, 5f);
			val19.OnClickEventHandler(0).onClick += (OnClick)delegate
			{
				settingsPanel.OpenPanel();
			};
			ButtonClickEvent obj28 = val19.OnClickEventHandler(1);
			object obj29 = <>c.<>9__49_17;
			if (obj29 == null)
			{
				OnClick val20 = delegate
				{
					Plugin.ScanForLevels();
				};
				<>c.<>9__49_17 = val20;
				obj29 = (object)val20;
			}
			obj28.onClick += (OnClick)obj29;
			errorText = new ConfigHeader(config.rootPanel, "", 16, (TextAlignmentOptions)513);
			levelBundlesHeader = new ConfigHeader(config.rootPanel, "Level Bundles", 24);
			searchBar = new SearchBarField(config.rootPanel);
			new BundleSortField(config.rootPanel);
			folderDivision = new ConfigDivision(config.rootPanel, "div_folders");
			bundleDivision = new ConfigDivision(config.rootPanel, "div_bundles");
			searchInfo = new ConfigHeader(config.rootPanel, "", 18);
			searchInfo.textColor = Color.gray;
			((ConfigField)searchInfo).hidden = true;
		}

		public static void InitializeErrorConfig(string text, Exception ex)
		{
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Expected O, but got Unknown
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			if (config == null)
			{
				config = PluginConfigurator.Create("Angry Level Loader", "com.eternalUnion.angryLevelLoader");
				config.SetIconWithURL("file://" + Path.Combine(Plugin.workingDir, "plugin-icon.png"));
			}
			else
			{
				ConfigField[] allFields = config.rootPanel.GetAllFields();
				for (int i = 0; i < allFields.Length; i++)
				{
					allFields[i].hidden = true;
				}
			}
			ButtonField val = new ButtonField(config.rootPanel, "GitHub bug report", "error_bugReport");
			object obj = <>c.<>9__50_0;
			if (obj == null)
			{
				OnClick val2 = delegate
				{
					Application.OpenURL("https://github.com/eternalUnion/AngryLevelLoader/issues");
				};
				<>c.<>9__50_0 = val2;
				obj = (object)val2;
			}
			val.onClick += (OnClick)obj;
			new ConfigHeader(config.rootPanel, "Error! Failed to create plugin's data folder at '" + Plugin.dataPath + "'", 16, (TextAlignmentOptions)513).textColor = Color.red;
			if (ex != null)
			{
				new ConfigHeader(config.rootPanel, ex.GetType().Name + ": " + ex.Message + "\n" + ex.StackTrace, 16, (TextAlignmentOptions)513);
			}
		}
	}
	internal static class InternalConfigManager
	{
		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static BoolValueChangeEventDelegate <>9__13_0;

			public static PostBoolValueChangeEvent <>9__13_1;

			internal void <InitializeInternalConfig>b__13_0(BoolValueChangeEvent e)
			{
				if (e.value)
				{
					e.canceled = true;
					NotificationPanel.Open((Notification)(object)new LeaderboardPermissionNotification());
				}
			}

			internal void <InitializeInternalConfig>b__13_1(bool newVal)
			{
				((ConfigField)ConfigManager.leaderboardsDivision).hidden = newVal;
			}
		}

		public static PluginConfigurator internalConfig;

		public static BoolField devMode;

		public static StringField lastVersion;

		public static StringField ignoreUpdateVersion;

		public static StringField configDataPath;

		public static BoolField leaderboardToggle;

		public static BoolField askedPermissionForLeaderboards;

		public static StringField pendingRecordsField;

		public static BoolField ignoreEpilepsyWarning;

		public static BoolField instantLoadLevel;

		public static StringField instantLoadLevelGuid;

		public static StringField instantLoadLevelId;

		public static StringMultilineField ignoreNoMoWarning;

		public static void InitializeInternalConfig()
		{
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Expected O, but got Unknown
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Expected O, but got Unknown
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Expected O, but got Unknown
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Expected O, but got Unknown
			//IL_014e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: Expected O, but got Unknown
			//IL_016d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0177: Expected O, but got Unknown
			//IL_018c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0196: Expected O, but got Unknown
			//IL_01b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ba: Expected O, but got Unknown
			//IL_01d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01de: Expected O, but got Unknown
			//IL_01f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fd: Expected O, but got Unknown
			//IL_0212: Unknown result type (might be due to invalid IL or missing references)
			//IL_021c: Expected O, but got Unknown
			//IL_0235: Unknown result type (might be due to invalid IL or missing references)
			//IL_023a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0240: Expected O, but got Unknown
			//IL_0288: Unknown result type (might be due to invalid IL or missing references)
			//IL_0292: Expected O, but got Unknown
			//IL_025e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0263: Unknown result type (might be due to invalid IL or missing references)
			//IL_0269: Expected O, but got Unknown
			if (internalConfig != null)
			{
				return;
			}
			internalConfig = PluginConfigurator.Create("Angry Level Loader (INTERNAL)", "com.eternalUnion.angryLevelLoader_internal");
			internalConfig.hidden = true;
			internalConfig.interactable = false;
			internalConfig.presetButtonHidden = true;
			internalConfig.presetButtonInteractable = false;
			devMode = new BoolField(internalConfig.rootPanel, "devMode", "devMode", false);
			lastVersion = new StringField(internalConfig.rootPanel, "lastPluginVersion", "lastPluginVersion", "4.0.3", true, true, false);
			ignoreUpdateVersion = new StringField(internalConfig.rootPanel, "ignoreUpdateVersion", "ignoreUpdateVersion", "4.0.3", true, true, false);
			configDataPath = new StringField(internalConfig.rootPanel, "dataPath", "dataPath", Path.Combine(AngryIOUtils.AppData, "AngryLevelLoader"), false, true, false);
			if (new Regex("^[^:]+:\\\\Users\\\\User\\\\AppData\\\\Roaming").IsMatch(configDataPath.value) && !Directory.Exists(configDataPath.value))
			{
				Plugin.logger.LogWarning((object)"Bad data path detected, resetting the value!");
				configDataPath.value = configDataPath.defaultValue;
			}
			pendingRecordsField = new StringField(internalConfig.rootPanel, "pendingRecordsField", "pendingRecordsField", "", true, true, false);
			ignoreEpilepsyWarning = new BoolField(internalConfig.rootPanel, "ignoreEpilepsyWarning", "ignoreEpilepsyWarning", false);
			instantLoadLevel = new BoolField(internalConfig.rootPanel, "instantLoadLevel", "instantLoadLevel", false);
			instantLoadLevelGuid = new StringField(internalConfig.rootPanel, "instantLoadLevelGuid", "instantLoadLevelGuid", "", true);
			instantLoadLevelId = new StringField(internalConfig.rootPanel, "instantLoadLevelId", "instantLoadLevelId", "", true);
			askedPermissionForLeaderboards = new BoolField(internalConfig.rootPanel, "askedPermissionForLeaderboards", "askedPermissionForLeaderboards", false);
			leaderboardToggle = new BoolField(internalConfig.rootPanel, "Post records to leaderboards", "leaderboardToggle", false);
			BoolField obj = leaderboardToggle;
			object obj2 = <>c.<>9__13_0;
			if (obj2 == null)
			{
				BoolValueChangeEventDelegate val = delegate(BoolValueChangeEvent e)
				{
					if (e.value)
					{
						e.canceled = true;
						NotificationPanel.Open((Notification)(object)new LeaderboardPermissionNotification());
					}
				};
				<>c.<>9__13_0 = val;
				obj2 = (object)val;
			}
			obj.onValueChange += (BoolValueChangeEventDelegate)obj2;
			BoolField obj3 = leaderboardToggle;
			object obj4 = <>c.<>9__13_1;
			if (obj4 == null)
			{
				PostBoolValueChangeEvent val2 = delegate(bool newVal)
				{
					((ConfigField)ConfigManager.leaderboardsDivision).hidden = newVal;
				};
				<>c.<>9__13_1 = val2;
				obj4 = (object)val2;
			}
			obj3.postValueChangeEvent += (PostBoolValueChangeEvent)obj4;
			ignoreNoMoWarning = new StringMultilineField(internalConfig.rootPanel, "ignoreNoMoWarning", "ignoreNoMoWarning", "", true);
		}
	}
	internal static class LastPlayedMapManager
	{
		public static readonly Dictionary<string, long> lastPlayed = new Dictionary<string, long>();

		public static readonly Dictionary<string, long> lastUpdate = new Dictionary<string, long>();

		public static void LoadLastPlayedMap()
		{
			lastPlayed.Clear();
			string lastPlayedMapPath = AngryPaths.LastPlayedMapPath;
			if (!File.Exists(lastPlayedMapPath))
			{
				return;
			}
			using StreamReader streamReader = new StreamReader(File.Open(lastPlayedMapPath, FileMode.Open, FileAccess.Read));
			while (!streamReader.EndOfStream)
			{
				string key = streamReader.ReadLine();
				if (streamReader.EndOfStream)
				{
					Plugin.logger.LogWarning((object)"Invalid end of last played map file");
					break;
				}
				string text = streamReader.ReadLine();
				if (long.TryParse(text, out var result))
				{
					lastPlayed[key] = result;
				}
				else
				{
					Plugin.logger.LogInfo((object)("Invalid last played time '" + text + "'"));
				}
			}
		}

		public static void LoadLastUpdateMap()
		{
			lastUpdate.Clear();
			string lastUpdateMapPath = AngryPaths.LastUpdateMapPath;
			if (!File.Exists(lastUpdateMapPath))
			{
				return;
			}
			using StreamReader streamReader = new StreamReader(File.Open(lastUpdateMapPath, FileMode.Open, FileAccess.Read));
			while (!streamReader.EndOfStream)
			{
				string key = streamReader.ReadLine();
				if (streamReader.EndOfStream)
				{
					Plugin.logger.LogWarning((object)"Invalid end of last played map file");
					break;
				}
				string text = streamReader.ReadLine();
				if (long.TryParse(text, out var result))
				{
					lastUpdate[key] = result;
				}
				else
				{
					Plugin.logger.LogInfo((object)("Invalid last played time '" + text + "'"));
				}
			}
		}

		public static void UpdateLastPlayed(BundleContainer bundle)
		{
			string bundleGuid = bundle.bundleGuid;
			if (bundleGuid.Length != 32)
			{
				return;
			}
			long value = ((DateTimeOffset)DateTime.UtcNow).ToUnixTimeSeconds();
			lastPlayed[bundleGuid] = value;
			string lastPlayedMapPath = AngryPaths.LastPlayedMapPath;
			AngryIOUtils.TryCreateDirectoryForFile(lastPlayedMapPath);
			using (StreamWriter streamWriter = new StreamWriter(File.Open(lastPlayedMapPath, FileMode.OpenOrCreate, FileAccess.Write)))
			{
				streamWriter.BaseStream.Seek(0L, SeekOrigin.Begin);
				streamWriter.BaseStream.SetLength(0L);
				foreach (KeyValuePair<string, long> item in lastPlayed)
				{
					streamWriter.WriteLine(item.Key);
					streamWriter.WriteLine(item.Value.ToString());
				}
			}
			if (ConfigManager.bundleSortingMode.value == ConfigManager.BundleSorting.LastPlayed)
			{
				AngryBundleList.SortBundles();
			}
		}

		public static void UpdateLastUpdate(BundleContainer bundle)
		{
			string bundleGuid = bundle.bundleGuid;
			if (bundleGuid.Length != 32)
			{
				return;
			}
			long value = ((DateTimeOffset)DateTime.UtcNow).ToUnixTimeSeconds();
			lastUpdate[bundleGuid] = value;
			string lastUpdateMapPath = AngryPaths.LastUpdateMapPath;
			AngryIOUtils.TryCreateDirectoryForFile(lastUpdateMapPath);
			using (StreamWriter streamWriter = new StreamWriter(File.Open(lastUpdateMapPath, FileMode.OpenOrCreate, FileAccess.Write)))
			{
				streamWriter.BaseStream.Seek(0L, SeekOrigin.Begin);
				streamWriter.BaseStream.SetLength(0L);
				foreach (KeyValuePair<string, long> item in lastUpdate)
				{
					streamWriter.WriteLine(item.Key);
					streamWriter.WriteLine(item.Value.ToString());
				}
			}
			if (ConfigManager.bundleSortingMode.value == ConfigManager.BundleSorting.LastUpdate)
			{
				AngryBundleList.SortBundles();
			}
		}
	}
	public static class OnlineCatalogManager
	{
		private static CachedTask<LevelCatalog> currentDownloadTask = new CachedTask<LevelCatalog>(DownloadCatalogWithHashCheck);

		public static LevelCatalog Catalog { get; private set; } = null;


		public static bool Downloading => currentDownloadTask.Running;

		public static Task<LevelCatalog> DownloadCatalogAsync(CancellationToken cancellationToken = default(CancellationToken))
		{
			return currentDownloadTask.GetTask(cancellationToken);
		}

		private static async Task<LevelCatalog> DownloadCatalogWithHashCheck()
		{
			string cachedCatalogPath = AngryPaths.LevelCatalogCachePath;
			AngryIOUtils.TryCreateDirectoryForFile(cachedCatalogPath);
			UnityWebRequest catalogVersionRequest = new UnityWebRequest(AngryPaths.GetGithubURL(AngryPaths.Repo.AngryLevels, "V2/LevelCatalogHash.txt"));
			catalogVersionRequest.downloadHandler = (DownloadHandler)new DownloadHandlerBuffer();
			await (AsyncOperation)(object)catalogVersionRequest.SendWebRequest();
			if ((int)catalogVersionRequest.result != 1)
			{
				Plugin.logger.LogError((object)"Could not download catalog version");
				Catalog = null;
				return Catalog;
			}
			string text = catalogVersionRequest.downloadHandler.text;
			if (File.Exists(cachedCatalogPath))
			{
				string text2 = File.ReadAllText(cachedCatalogPath);
				string mD5String = AngryCryptographyUtils.GetMD5String(text2);
				try
				{
					LevelCatalog catalog = JsonConvert.DeserializeObject<LevelCatalog>(text2);
					if (mD5String == text)
					{
						Plugin.logger.LogInfo((object)"Current online level catalog is up to date, loading from cache");
						Catalog = catalog;
						return Catalog;
					}
				}
				catch (Exception)
				{
					Plugin.logger.LogError((object)"Tried to load cached level catalog, but it is corrupted");
				}
			}
			Plugin.logger.LogInfo((object)"Current online level catalog is out of date, downloading from web");
			Catalog = await DownloadCatalog(text);
			return Catalog;
		}

		private static async Task<LevelCatalog> DownloadCatalog(string newHash)
		{
			string catalogPath = AngryPaths.LevelCatalogCachePath;
			AngryIOUtils.TryCreateDirectoryForFile(catalogPath);
			UnityWebRequest catalogRequest = new UnityWebRequest(AngryPaths.GetGithubURL(AngryPaths.Repo.AngryLevels, "V2/LevelCatalog.json"));
			catalogRequest.downloadHandler = (DownloadHandler)new DownloadHandlerFile(catalogPath);
			await (AsyncOperation)(object)catalogRequest.SendWebRequest();
			if ((int)catalogRequest.result != 1)
			{
				Plugin.logger.LogError((object)"Could not download catalog");
				return null;
			}
			string text = File.ReadAllText(catalogPath);
			string mD5String = AngryCryptographyUtils.GetMD5String(text);
			LevelCatalog result;
			try
			{
				result = JsonConvert.DeserializeObject<LevelCatalog>(text);
			}
			catch (Exception)
			{
				Plugin.logger.LogError((object)"Tried to load level catalog, but it is corrupted");
				return null;
			}
			if (mD5String != newHash)
			{
				Plugin.logger.LogWarning((object)("Catalog hash does not match, github did not cache the new catalog yet (current hash is " + mD5String + ". online hash is " + newHash + ")"));
			}
			return result;
		}

		internal static void LoadCachedCatalog()
		{
			string levelCatalogCachePath = AngryPaths.LevelCatalogCachePath;
			if (File.Exists(levelCatalogCachePath))
			{
				try
				{
					Catalog = JsonConvert.DeserializeObject<LevelCatalog>(File.ReadAllText(levelCatalogCachePath));
				}
				catch (Exception)
				{
					Plugin.logger.LogError((object)"Tried to load cached level catalog, but it is corrupted");
				}
			}
		}
	}
	public static class OnlineScriptsManager
	{
		private static Task<ScriptCatalog> downloadTask;

		public static ScriptCatalog ScriptCatalog { get; private set; }

		public static bool Downloading
		{
			get
			{
				if (downloadTask != null)
				{
					return !downloadTask.IsCompleted;
				}
				return false;
			}
		}

		public static async Task<ScriptCatalog> DownloadCatalogAsync(CancellationToken cancellationToken = default(CancellationToken))
		{
			if (!Downloading)
			{
				downloadTask = DownloadTask();
			}
			return await Task.Run(async () => await downloadTask, cancellationToken);
		}

		private static async Task<ScriptCatalog> DownloadTask()
		{
			string newHash = "";
			UnityWebRequest hashReq = new UnityWebRequest(AngryPaths.GetGithubURL(AngryPaths.Repo.AngryLevels, "ScriptCatalogHash.txt"));
			try
			{
				hashReq.downloadHandler = (DownloadHandler)new DownloadHandlerBuffer();
				await (AsyncOperation)(object)hashReq.SendWebRequest();
				if ((int)hashReq.result != 1)
				{
					Plugin.logger.LogError((object)"Could not download the script catalog hash");
					return ScriptCatalog;
				}
				newHash = hashReq.downloadHandler.text;
			}
			finally
			{
				hashReq.Dispose();
			}
			string cachedCatalogPath = AngryPaths.ScriptCatalogCachePath;
			if (File.Exists(cachedCatalogPath))
			{
				string text = File.ReadAllText(cachedCatalogPath);
				if (AngryCryptographyUtils.GetMD5String(text) == newHash)
				{
					Plugin.logger.LogInfo((object)"Cached script catalog up to date");
					try
					{
						ScriptCatalog = JsonConvert.DeserializeObject<ScriptCatalog>(text);
					}
					catch (Exception)
					{
						Plugin.logger.LogError((object)"Tried to load the script catalog, but it is corrupted");
						return null;
					}
					return ScriptCatalog;
				}
			}
			UnityWebRequest updatedCatalogRequest = new UnityWebRequest(AngryPaths.GetGithubURL(AngryPaths.Repo.AngryLevels, "ScriptCatalog.json"));
			try
			{
				updatedCatalogRequest.downloadHandler = (DownloadHandler)new DownloadHandlerBuffer();
				await (AsyncOperation)(object)updatedCatalogRequest.SendWebRequest();
				if ((int)updatedCatalogRequest.result != 1)
				{
					Plugin.logger.LogError((object)"Could not download the script catalog");
					return ScriptCatalog;
				}
				try
				{
					ScriptCatalog = JsonConvert.DeserializeObject<ScriptCatalog>(updatedCatalogRequest.downloadHandler.text);
				}
				catch (Exception)
				{
					Plugin.logger.LogError((object)"Tried to load script catalog, but it is corrupted");
					return null;
				}
				File.WriteAllText(cachedCatalogPath, updatedCatalogRequest.downloadHandler.text);
				string mD5String = AngryCryptographyUtils.GetMD5String(updatedCatalogRequest.downloadHandler.text);
				if (mD5String != newHash)
				{
					Plugin.logger.LogWarning((object)("New script catalog hash value does not match online catalog hash value, github page not cached yet (current hash is " + mD5String + ". online hash is " + newHash + ")"));
				}
				return ScriptCatalog;
			}
			finally
			{
				updatedCatalogRequest.Dispose();
			}
		}

		internal static void LoadCachedCatalog()
		{
			string scriptCatalogCachePath = AngryPaths.ScriptCatalogCachePath;
			if (File.Exists(scriptCatalogCachePath))
			{
				try
				{
					ScriptCatalog = JsonConvert.DeserializeObject<ScriptCatalog>(File.ReadAllText(scriptCatalogCachePath));
				}
				catch (Exception)
				{
					Plugin.logger.LogError((object)"Tried to load cached script catalog, but it is corrupted");
				}
			}
		}

		public static bool ScriptExistsInCatalog(string script)
		{
			if (ScriptCatalog == null)
			{
				return false;
			}
			return ScriptCatalog.Scripts.Where((ScriptInfo s) => s.FileName == script).Any();
		}

		public static bool TryGetScriptInfo(string script, out ScriptInfo info)
		{
			info = ((ScriptCatalog == null) ? null : ScriptCatalog.Scripts.Where((ScriptInfo s) => s.FileName == script).FirstOrDefault());
			return info != null;
		}
	}
	internal static class PendingRecordsManager
	{
		private class RecordInfoJsonWrapper
		{
			public string category { get; set; }

			public string difficulty { get; set; }

			public string bundleGuid { get; set; }

			public string hash { get; set; }

			public string levelId { get; set; }

			public int time { get; set; }

			public RecordInfoJsonWrapper()
			{
			}

			public RecordInfoJsonWrapper(AngryLeaderboards.PostRecordInfo record)
			{
				category = AngryLeaderboards.RECORD_CATEGORY_DICT[record.category];
				difficulty = AngryLeaderboards.RECORD_DIFFICULTY_DICT[record.difficulty];
				bundleGuid = record.bundleGuid;
				hash = record.hash;
				levelId = record.levelId;
				time = record.time;
			}

			public bool TryParseRecordInfo(out AngryLeaderboards.PostRecordInfo record)
			{
				record = default(AngryLeaderboards.PostRecordInfo);
				record.category = AngryLeaderboards.RECORD_CATEGORY_DICT.FirstOrDefault((KeyValuePair<AngryLeaderboards.RecordCategory, string> i) => i.Value == category).Key;
				if (AngryLeaderboards.RECORD_CATEGORY_DICT[record.category] != category)
				{
					return false;
				}
				record.difficulty = AngryLeaderboards.RECORD_DIFFICULTY_DICT.FirstOrDefault((KeyValuePair<AngryLeaderboards.RecordDifficulty, string> i) => i.Value == difficulty).Key;
				if (AngryLeaderboards.RECORD_DIFFICULTY_DICT[record.difficulty] != difficulty)
				{
					return false;
				}
				record.bundleGuid = bundleGuid;
				record.hash = hash;
				record.levelId = levelId;
				record.time = time;
				return true;
			}
		}

		private static Task pendingRecordsTask;

		internal static void AddPendingRecord(AngryLeaderboards.PostRecordInfo record, bool recursiveCall = false)
		{
			if (pendingRecordsTask != null && !pendingRecordsTask.IsCompleted && !recursiveCall)
			{
				pendingRecordsTask.ContinueWith(delegate
				{
					AddPendingRecord(record, recursiveCall: true);
				}, TaskScheduler.FromCurrentSynchronizationContext());
				return;
			}
			List<RecordInfoJsonWrapper> list;
			try
			{
				list = JsonConvert.DeserializeObject<List<RecordInfoJsonWrapper>>(InternalConfigManager.pendingRecordsField.value);
				if (list == null)
				{
					list = new List<RecordInfoJsonWrapper>();
				}
			}
			catch (Exception arg)
			{
				Plugin.logger.LogError((object)$"Caught exception while trying to deserialize pending records\n{arg}");
				InternalConfigManager.pendingRecordsField.value = "[]";
				list = new List<RecordInfoJsonWrapper>();
			}
			list.Add(new RecordInfoJsonWrapper(record));
			InternalConfigManager.pendingRecordsField.value = JsonConvert.SerializeObject((object)list);
			UpdatePendingRecordsUI();
		}

		internal static void ProcessPendingRecords()
		{
			if (pendingRecordsTask == null || pendingRecordsTask.IsCompleted)
			{
				((ConfigField)ConfigManager.sendPendingRecords).interactable = false;
				pendingRecordsTask = ProcessPendingRecordsTask().ContinueWith((Task task) => ((ConfigField)ConfigManager.sendPendingRecords).interactable = true, TaskScheduler.FromCurrentSynchronizationContext());
			}
		}

		internal static void UpdatePendingRecordsUI()
		{
			try
			{
				List<RecordInfoJsonWrapper> list = JsonConvert.DeserializeObject<List<RecordInfoJsonWrapper>>(InternalConfigManager.pendingRecordsField.value);
				if (list == null)
				{
					list = new List<RecordInfoJsonWrapper>();
				}
				((ConfigField)ConfigManager.pendingRecords).hidden = list.Count == 0;
				ConfigManager.pendingRecordsInfo.text = "";
				foreach (RecordInfoJsonWrapper item in list)
				{
					string text = item.bundleGuid;
					string text2 = item.levelId;
					if (Plugin.TryGetAngryBundleByGuid(text, out var bundleContainer))
					{
						text = bundleContainer.BundleName;
					}
					if (Plugin.TryGetAngryLevel(text2, out var level))
					{
						text2 = level.LevelName;
					}
					ConfigHeader pendingRecordsInfo = ConfigManager.pendingRecordsInfo;
					pendingRecordsInfo.text += $"Bundle: <color=grey>{text}</color>\nLevel: <color=grey>{text2}</color>\nCategory: <color=grey>{item.category}</color>\nDifficulty: <color=grey>{item.difficulty}</color>\nTime: <color=grey>{item.time}</color>\n\n\n";
				}
			}
			catch (Exception arg)
			{
				Plugin.logger.LogError((object)$"Caught exception while trying to deserialize pending records\n{arg}");
				InternalConfigManager.pendingRecordsField.value = "[]";
				((ConfigField)ConfigManager.pendingRecords).hidden = true;
			}
		}

		private static async Task ProcessPendingRecordsTask()
		{
			ConfigManager.pendingRecordsStatus.text = "";
			List<RecordInfoJsonWrapper> list;
			try
			{
				list = JsonConvert.DeserializeObject<List<RecordInfoJsonWrapper>>(InternalConfigManager.pendingRecordsField.value);
				if (list == null)
				{
					list = new List<RecordInfoJsonWrapper>();
				}
			}
			catch (Exception arg)
			{
				ConfigManager.pendingRecordsStatus.text = $"<color=red>Exception thrown while deserializing pending records, discarding\n\n{arg}</color>";
				InternalConfigManager.pendingRecordsField.value = "[]";
				UpdatePendingRecordsUI();
				return;
			}
			List<RecordInfoJsonWrapper> failedToSend = new List<RecordInfoJsonWrapper>();
			foreach (RecordInfoJsonWrapper record in list)
			{
				string text = record.bundleGuid;
				string text2 = record.levelId;
				if (Plugin.TryGetAngryBundleByGuid(text, out var bundleContainer))
				{
					text = bundleContainer.BundleName;
				}
				if (Plugin.TryGetAngryLevel(text2, out var level))
				{
					text2 = level.LevelName;
				}
				ConfigHeader pendingRecordsStatus;
				if (!record.TryParseRecordInfo(out var record2))
				{
					pendingRecordsStatus = ConfigManager.pendingRecordsStatus;
					pendingRecordsStatus.text = pendingRecordsStatus.text + "<color=red>Failed to parse record info for level " + text2 + " in bundle " + text + ". Discarded.</color>\n\n";
					continue;
				}
				pendingRecordsStatus = ConfigManager.pendingRecordsStatus;
				pendingRecordsStatus.text = pendingRecordsStatus.text + "Posting record for level <color=grey>" + text2 + "</color> in bundle <color=grey>" + text + "</color>...\n";
				AngryLeaderboards.PostRecordResult postRecordResult = await AngryLeaderboards.PostRecordTask(record2.category, record2.difficulty, record2.bundleGuid, record2.hash, record2.levelId, record2.time);
				if (postRecordResult.completedSuccessfully)
				{
					if (postRecordResult.status == AngryLeaderboards.PostRecordStatus.OK)
					{
						ConfigHeader pendingRecordsStatus2 = ConfigManager.pendingRecordsStatus;
						pendingRecordsStatus2.text += $"<color=#00FF00>Record posted successfully!</color> Ranking: #{postRecordResult.response.ranking}, New Best: {postRecordResult.response.newBest}\n\n";
						continue;
					}
					switch (postRecordResult.status)
					{
					case AngryLeaderboards.PostRecordStatus.BANNED:
					{
						ConfigHeader pendingRecordsStatus8 = ConfigManager.pendingRecordsStatus;
						pendingRecordsStatus8.text += "<color=red>User banned from the leaderboards. Discarded.</color>\n\n";
						break;
					}
					case AngryLeaderboards.PostRecordStatus.INVALID_BUNDLE:
					case AngryLeaderboards.PostRecordStatus.INVALID_ID:
					{
						ConfigHeader pendingRecordsStatus7 = ConfigManager.pendingRecordsStatus;
						pendingRecordsStatus7.text += "<color=red>Level's leaderboards are not enabled. Discarded.</color>\n\n";
						break;
					}
					case AngryLeaderboards.PostRecordStatus.RATE_LIMITED:
					{
						ConfigHeader pendingRecordsStatus6 = ConfigManager.pendingRecordsStatus;
						pendingRecordsStatus6.text += "<color=red>Too many requests sent. Returning record to the pending list</color>\n\n";
						failedToSend.Add(record);
						break;
					}
					case AngryLeaderboards.PostRecordStatus.INVALID_HASH:
					{
						ConfigHeader pendingRecordsStatus5 = ConfigManager.pendingRecordsStatus;
						pendingRecordsStatus5.text += "<color=red>Record bundle version is not up to date with the leaderboard. Discarded.</color>\n\n";
						break;
					}
					case AngryLeaderboards.PostRecordStatus.INVALID_TIME:
					{
						ConfigHeader pendingRecordsStatus4 = ConfigManager.pendingRecordsStatus;
						pendingRecordsStatus4.text += $"<color=red>Angry server rejected the sent time {record.time}. Discarded.</color>\n\n";
						break;
					}
					default:
					{
						ConfigHeader pendingRecordsStatus3 = ConfigManager.pendingRecordsStatus;
						pendingRecordsStatus3.text += $"<color=red>Encountered an unknown error while posting record. Status: {postRecordResult.status}, Message: '{postRecordResult.message}'. Returning record to the pending list</color>\n\n";
						failedToSend.Add(record);
						break;
					}
					}
				}
				else
				{
					ConfigHeader pendingRecordsStatus9 = ConfigManager.pendingRecordsStatus;
					pendingRecordsStatus9.text += "<color=red>Encountered a network error while posting record. Returning record to the pending list</color>\n\n";
					failedToSend.Add(record);
				}
			}
			ConfigHeader pendingRecordsStatus10 = ConfigManager.pendingRecordsStatus;
			pendingRecordsStatus10.text += "<color=#00FF00>Done!</color>";
			InternalConfigManager.pendingRecordsField.value = JsonConvert.SerializeObject((object)failedToSend);
			UpdatePendingRecordsUI();
		}
	}
	public static class ScriptManager
	{
		public enum LoadScriptResult
		{
			Loaded,
			NotFound,
			NoCertificate,
			InvalidCertificate
		}

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

		private static IEnumerable<string> loadedScripts => loadedScriptsDict.Keys;

		public static LoadScriptResult AttemptLoadScriptWithCertificate(string scriptName)
		{
			if (loadedScripts.Contains(scriptName))
			{
				return LoadScriptResult.Loaded;
			}
			string text = Path.Combine(AngryPaths.ScriptsPath, scriptName);
			if (!File.Exists(text))
			{
				return LoadScriptResult.NotFound;
			}
			if (!File.Exists(text + ".cert"))
			{
				return LoadScriptResult.NoCertificate;
			}
			if (!AngryCryptographyUtils.VerifyFileCertificate(text, text + ".cert"))
			{
				return LoadScriptResult.InvalidCertificate;
			}
			byte[] array = File.ReadAllBytes(text);
			Assembly.Load(array);
			loadedScriptsDict[scriptName] = AngryCryptographyUtils.GetMD5String(array);
			return LoadScriptResult.Loaded;
		}

		internal static bool ForceLoadScript(string scriptName)
		{
			if (Assembly.GetCallingAssembly() != Assembly.GetExecutingAssembly())
			{
				return false;
			}
			string path = Path.Combine(AngryPaths.ScriptsPath, scriptName);
			if (!File.Exists(path))
			{
				return false;
			}
			byte[] array = File.ReadAllBytes(path);
			Assembly.Load(array);
			loadedScriptsDict[scriptName] = AngryCryptographyUtils.GetMD5String(array);
			return true;
		}

		public static bool ScriptLoaded(string scriptName)
		{
			return loadedScripts.Contains(scriptName);
		}

		public static bool ScriptExists(string scriptName)
		{
			return File.Exists(Path.Combine(Plugin.workingDir, "Scripts", scriptName));
		}

		public static bool ScriptChanged(string scriptName)
		{
			if (!loadedScriptsDict.TryGetValue(scriptName, out var value) || !File.Exists(Path.Combine(AngryPaths.ScriptsPath, scriptName)))
			{
				return false;
			}
			return value != AngryCryptographyUtils.GetMD5String(File.ReadAllBytes(Path.Combine(AngryPaths.ScriptsPath, scriptName)));
		}

		public static List<string> GetRequiredScriptsFromBundle(BundleContainer bundleContainer)
		{
			List<string> list = new List<string>();
			foreach (RudeLevelData allRudeLevelDatum in bundleContainer.GetAllRudeLevelData())
			{
				if (allRudeLevelDatum.requiredDllNames == null)
				{
					continue;
				}
				string[] requiredDllNames = allRudeLevelDatum.requiredDllNames;
				foreach (string item in requiredDllNames)
				{
					if (!list.Contains(item))
					{
						list.Add(item);
					}
				}
			}
			return list;
		}

		public static string GetUrlForOnlineScript(string scriptName)
		{
			return AngryPaths.GetGithubURL(AngryPaths.Repo.AngryLevels, "Scripts/" + scriptName);
		}

		public static string GetUrlForOnlineScriptCertificate(string scriptName)
		{
			return AngryPaths.GetGithubURL(AngryPaths.Repo.AngryLevels, "Scripts/" + scriptName + ".cert");
		}
	}
	internal struct SteamUserCache
	{
		public ulong steamId;

		public string name;

		public Texture2D profilePicture;
	}
	internal static class SteamCacheManager
	{
		private static Dictionary<ulong, SteamUserCache> steamUserCacheDict = new Dictionary<ulong, SteamUserCache>();

		private static Dictionary<ulong, Task<SteamUserCache>> requestDict = new Dictionary<ulong, Task<SteamUserCache>>();

		public static bool TryGetUser(ulong steamId, out SteamUserCache user)
		{
			return steamUserCacheDict.TryGetValue(steamId, out user);
		}

		public static Task<SteamUserCache> RequestUser(ulong steamId)
		{
			if (requestDict.TryGetValue(steamId, out var value))
			{
				return value;
			}
			Task<SteamUserCache> steamUserTask = GetSteamUserTask(steamId);
			steamUserTask.ContinueWith(delegate
			{
				requestDict.Remove(steamId);
			}, TaskScheduler.FromCurrentSynchronizationContext());
			requestDict[steamId] = steamUserTask;
			return steamUserTask;
		}

		public static void RequestUser(ulong steamId, Action<SteamUserCache> callback)
		{
			if (steamUserCacheDict.TryGetValue(steamId, out var value))
			{
				callback(value);
				return;
			}
			if (requestDict.TryGetValue(steamId, out var value2))
			{
				value2.ContinueWith(delegate(Task<SteamUserCache> task)
				{
					callback(task.Result);
				}, TaskScheduler.FromCurrentSynchronizationContext());
				return;
			}
			Task<SteamUserCache> steamUserTask = GetSteamUserTask(steamId);
			steamUserTask.ContinueWith(delegate(Task<SteamUserCache> task)
			{
				callback(task.Result);
				requestDict.Remove(steamId);
			}, TaskScheduler.FromCurrentSynchronizationContext());
			requestDict[steamId] = steamUserTask;
		}

		private static async Task<SteamUserCache> GetSteamUserTask(ulong steamId)
		{
			if (steamUserCacheDict.TryGetValue(steamId, out var value))
			{
				return value;
			}
			bool doCache = true;
			SteamUserCache result = default(SteamUserCache);
			result.steamId = steamId;
			SteamId userId = SteamId.op_Implicit(steamId);
			SteamFriends.RequestUserInformation(userId, true);
			Image? val = await SteamFriends.GetMediumAvatarAsync(userId);
			if (val.HasValue)
			{
				Texture2D val2 = new Texture2D((int)val.Value.Width, (int)val.Value.Height, (TextureFormat)4, false);
				val2.LoadRawTextureData(val.Value.Data);
				val2.Apply();
				((Texture)val2).filterMode = (FilterMode)0;
				result.profilePicture = val2;
			}
			else
			{
				doCache = false;
			}
			Friend val3 = new Friend(userId);
			result.name = ((Friend)(ref val3)).Name;
			if (doCache)
			{
				steamUserCacheDict[steamId] = result;
			}
			return result;
		}
	}
	internal class CachedTexture
	{
		public Texture2D texture;

		public string hash;

		public CachedTask<Texture2D> currentTask;

		public CachedTexture(Texture2D texture, string hash)
		{
			this.texture = texture;
			this.hash = hash;
		}

		public static async Task<Texture2D> GetTextureFromFile(string path)
		{
			UnityWebRequest req = UnityWebRequestTexture.GetTexture("file://" + path);
			await (AsyncOperation)(object)req.SendWebRequest();
			if ((int)req.result != 1)
			{
				return null;
			}
			return DownloadHandlerTexture.GetContent(req);
		}
	}
	public static class AngryOnlineThumbnailCache
	{
		private static Dictionary<string, CachedTexture> textureCache = new Dictionary<string, CachedTexture>();

		public static Task<Texture2D> GetThumbnail(string bundleGuid)
		{
			if (!textureCache.TryGetValue(bundleGuid, out var value))
			{
				value = new CachedTexture(null, string.Empty);
				value.currentTask = new CachedTask<Texture2D>(() => _GetTexture(bundleGuid));
				textureCache.Add(bundleGuid, value);
			}
			return value.currentTask.GetTask();
		}

		private static async Task<Texture2D> _GetTexture(string guid)
		{
			LevelCatalog levelCatalog = OnlineCatalogManager.Catalog;
			if (levelCatalog == null)
			{
				levelCatalog = await OnlineCatalogManager.DownloadCatalogAsync();
			}
			LevelCatalog levelCatalog2 = levelCatalog;
			if (levelCatalog2 == null)
			{
				return null;
			}
			BundleInfo bundleInfo = levelCatalog2.Levels.Where((BundleInfo b) => b.Guid == guid).FirstOrDefault();
			if (bundleInfo == null)
			{
				return null;
			}
			string hash = bundleInfo.ThumbnailHash;
			if (textureCache.TryGetValue(guid, out var cachedTexture))
			{
				if ((Object)(object)cachedTexture.texture != (Object)null && cachedTexture.hash == hash)
				{
					return cachedTexture.texture;
				}
			}
			else
			{
				cachedTexture = new CachedTexture(null, hash);
				textureCache.Add(guid, cachedTexture);
			}
			string thumbnailCacheFolderPath = AngryPaths.ThumbnailCacheFolderPath;
			AngryIOUtils.TryCreateDirectory(thumbnailCacheFolderPath);
			string imageCachePath = Path.Combine(thumbnailCacheFolderPath, guid + ".png");
			if (File.Exists(imageCachePath) && AngryCryptographyUtils.GetMD5String(File.ReadAllBytes(imageCachePath)) == hash)
			{
				Texture2D val = await CachedTexture.GetTextureFromFile(imageCachePath);
				if ((Object)(object)val != (Object)null)
				{
					cachedTexture.texture = val;
					((Texture)cachedTexture.texture).filterMode = (FilterMode)0;
					cachedTexture.hash = hash;
					return val;
				}
			}
			if (File.Exists(imageCachePath))
			{
				File.Delete(imageCachePath);
			}
			string githubURL = AngryPaths.GetGithubURL(AngryPaths.Repo.AngryLevels, "Levels/" + guid + "/thumbnail.png");
			UnityWebRequest thumbnailReq = new UnityWebRequest(githubURL);
			thumbnailReq.downloadHandler = (DownloadHandler)new DownloadHandlerFile(imageCachePath);
			await (AsyncOperation)(object)thumbnailReq.SendWebRequest();
			if ((int)thumbnailReq.result != 1)
			{
				return null;
			}
			Texture2D val2 = await CachedTexture.GetTextureFromFile(imageCachePath);
			if ((Object)(object)val2 != (Object)null)
			{
				cachedTexture.texture = val2;
				((Texture)cachedTexture.texture).filterMode = (FilterMode)0;
				cachedTexture.hash = hash;
				return val2;
			}
			return null;
		}
	}
	public static class AngryLevelThumbnailCache
	{
		private static Dictionary<string, CachedTexture> textureCache = new Dictionary<string, CachedTexture>();

		public static Task<Texture2D> GetThumbnail(string bundleGuid, string levelId)
		{
			if (!textureCache.TryGetValue(levelId, out var value))
			{
				value = new CachedTexture(null, string.Empty);
				value.currentTask = new CachedTask<Texture2D>(() => _GetTexture(bundleGuid, levelId));
				textureCache.Add(levelId, value);
			}
			return value.currentTask.GetTask();
		}

		private static async Task<Texture2D> _GetTexture(string bundleGuid, string levelId)
		{
			CachedTexture cache = textureCache[levelId];
			if ((Object)(object)cache.texture != (Object)null)
			{
				return cache.texture;
			}
			string mD5String = AngryCryptographyUtils.GetMD5String(levelId);
			UnityWebRequest thumbnailReq = new UnityWebRequest(AngryPaths.GetGithubURL(AngryPaths.Repo.AngryLevels, "Levels/" + bundleGuid + "/LevelThumbnails/" + mD5String + ".png"));
			thumbnailReq.downloadHandler = (DownloadHandler)new DownloadHandlerTexture();
			await (AsyncOperation)(object)thumbnailReq.SendWebRequest();
			if ((int)thumbnailReq.result != 1)
			{
				return null;
			}
			cache.texture = ((DownloadHandlerTexture)thumbnailReq.downloadHandler).texture;
			((Texture)cache.texture).filterMode = (FilterMode)0;
			return cache.texture;
		}
	}
}
namespace AngryLevelLoader.Managers.ServerManager
{
	public static class AngryLeaderboards
	{
		public enum RecordCategory
		{
			ALL,
			PRANK,
			CHALLENGE,
			NOMO,
			NOMOW
		}

		public enum RecordDifficulty
		{
			ANY,
			HARMLESS,
			LENIENT,
			STANDARD,
			VIOLENT,
			BRUTAL
		}

		public class RecordInfo
		{
			public string steamId { get; set; }

			public int time { get; set; }

			public string difficulty { get; set; }

			public bool censorIcon { get; set; }

			public bool censorName { get; set; }
		}

		internal struct PostRecordInfo
		{
			public RecordCategory category;

			public RecordDifficulty difficulty;

			public string bundleGuid;

			public string hash;

			public string levelId;

			public int time;
		}

		public enum GetRecordsStatus
		{
			FAILED = -2,
			RATE_LIMITED = -1,
			OK = 0,
			MISSING_CATEGORY = 4,
			INVALID_CATEGORY = 5,
			MISSING_DIFFICULTY = 6,
			INVALID_DIFFICULTY = 7,
			MISSING_BUNDLE = 8,
			INVALID_BUNDLE = 9,
			MISSING_ID = 10,
			INVALID_ID = 11,
			MISSING_OFFSET = 12,
			INVALID_OFFSET = 13,
			MISSING_COUNT = 14,
			INVALID_COUNT = 15
		}

		public class GetRecordsResponse : AngryResponse
		{
			public RecordInfo[] records;

			public int offset { get; set; }

			public int totalCount { get; set; }
		}

		public class GetRecordsResult : AngryResult<GetRecordsResponse, GetRecordsStatus>
		{
		}

		internal enum PostRecordStatus
		{
			FAILED = -2,
			RATE_LIMITED,
			OK,
			INVALID_TOKEN,
			MISSING_TIME,
			INVALID_TIME,
			MISSING_CATEGORY,
			INVALID_CATEGORY,
			MISSING_DIFFICULTY,
			INVALID_DIFFICULTY,
			MISSING_BUNDLE,
			INVALID_BUNDLE,
			MISSING_ID,
			INVALID_ID,
			MISSING_HASH,
			INVALID_HASH,
			BANNED
		}

		internal class PostRecordResponse : AngryResponse
		{
			public int ranking { get; set; }

			public bool newBest { get; set; }
		}

		internal class PostRecordResult : AngryResult<PostRecordResponse, PostRecordStatus>
		{
		}

		public enum GetUserRecordStatus
		{
			FAILED = -2,
			RATE_LIMITED = -1,
			OK = 0,
			INVALID_TOKEN = 1,
			MISSING_CATEGORY = 4,
			INVALID_CATEGORY = 5,
			MISSING_DIFFICULTY = 6,
			INVALID_DIFFICULTY = 7,
			MISSING_BUNDLE = 8,
			INVALID_BUNDLE = 9,
			MISSING_ID = 10,
			INVALID_ID = 11,
			MISSING_TARGET_USER_ID = 12
		}

		public class GetUserRecordResponse : AngryResponse
		{
			public int ranking { get; set; }

			public int time { get; set; }

			public string difficulty { get; set; }
		}

		public class GetUserRecordResult : AngryResult<GetUserRecordResponse, GetUserRecordStatus>
		{
		}

		public enum GetUserRecordsStatus
		{
			FAILED = -2,
			RATE_LIMITED = -1,
			OK = 0,
			INVALID_TOKEN = 1,
			MISSING_CATEGORY = 4,
			INVALID_CATEGORY = 5,
			MISSING_DIFFICULTY = 6,
			INVALID_DIFFICULTY = 7,
			MISSING_BUNDLE = 8,
			INVALID_BUNDLE = 9,
			MISSING_ID = 10,
			INVALID_ID = 11,
			MISSING_JSON_BODY = 12
		}

		public class UserRecord
		{
			public string steamId { get; set; }

			public int time { get; set; }

			public string difficulty { get; set; }

			public int globalRank { get; set; }
		}

		public class GetUserRecordsResponse : AngryResponse
		{
			public UserRecord[] records;
		}

		public class GetUserRecordsResult : AngryResult<GetUserRecordsResponse, GetUserRecordsStatus>
		{
		}

		private class GetUserRecordsBodyObject
		{
			public string[] targetUserIds;
		}

		internal enum GetUserInfoStatus
		{
			FAILED = -2,
			RATE_LIMITED,
			OK,
			INVALID_TOKEN,
			ACCESS_DENIED,
			INTERNAL_ERROR,
			INVALID_ID
		}

		internal class GetUserInfoResponse : AngryResponse
		{
			public bool leaderboardBanned { get; set; }

			public int recordCount { get; set; }

			public int reportCount { get; set; }

			public int removedRecordCount { get; set; }
		}

		internal class GetUserInfoResult : AngryResult<GetUserInfoResponse, GetUserInfoStatus>
		{
		}

		internal enum ManageUserStatus
		{
			FAILED = -2,
			RATE_LIMITED,
			OK,
			INVALID_TOKEN,
			ACCESS_DENIED,
			INTERNAL_ERROR,
			INVALID_ID
		}

		internal class ManageUserResponse : AngryResponse
		{
		}

		internal class ManageUserResult : AngryResult<ManageUserResponse, ManageUserStatus>
		{
		}

		internal enum RemoveRecordStatus
		{
			FAILED = -2,
			RATE_LIMITED,
			OK,
			INVALID_TOKEN,
			ACCESS_DENIED,
			INTERNAL_ERROR,
			INVALID_ID,
			MISSING_CATEGORY,
			INVALID_CATEGORY,
			MISSING_DIFFICULTY,
			INVALID_DIFFICULTY,
			MISSING_BUNDLE,
			INVALID_BUNDLE,
			INVALID_LEVEL_ID,
			MISSING_LEVEL_ID,
			ENTRY_NOT_FOUND
		}

		internal class RemoveRecordResponse : AngryResponse
		{
		}

		internal class RemoveRecordResult : AngryResult<RemoveRecordResponse, RemoveRecordStatus>
		{
		}

		internal enum ClearRecordsStatus
		{
			FAILED = -2,
			RATE_LIMITED,
			OK,
			INVALID_TOKEN,
			ACCESS_DENIED,
			INTERNAL_ERROR,
			INVALID_ID
		}

		internal class ClearRecordsResponse : AngryResponse
		{
			public int removedRecordCount { get; set; }
		}

		internal class ClearRecordsResult : AngryResult<ClearRecordsResponse, ClearRecordsStatus>
		{
		}

		internal enum GetUserHistoryStatus
		{
			FAILED = -2,
			RATE_LIMITED,
			OK,
			INVALID_TOKEN,
			ACCESS_DENIED,
			INTERNAL_ERROR,
			INVALID_ID
		}

		internal class GetUserHistoryResponse : AngryResponse
		{
			public Dictionary<string, int> bundleGuidPK;

			public Dictionary<string, int> levelIdPK;

			public int[][] runHistory;
		}

		internal class GetUserHistoryResult : AngryResult<GetUserHistoryResponse, GetUserHistoryStatus>
		{
		}

		public const string RECORD_CATEGORY_ALL = "all";

		public const string RECORD_CATEGORY_PRANK = "prank";

		public const string RECORD_CATEGORY_CHALLENGE = "challenge";

		public const string RECORD_CATEGORY_NOMO = "nomo";

		public const string RECORD_CATEGORY_NOMOW = "nomow";

		public static readonly Dictionary<RecordCategory, string> RECORD_CATEGORY_DICT = new Dictionary<RecordCategory, string>
		{
			{
				RecordCategory.ALL,
				"all"
			},
			{
				RecordCategory.PRANK,
				"prank"
			},
			{
				RecordCategory.CHALLENGE,
				"challenge"
			},
			{
				RecordCategory.NOMO,
				"nomo"
			},
			{
				RecordCategory.NOMOW,
				"nomow"
			}
		};

		public const string RECORD_DIFFICULTY_ANY = "any";

		public const string RECORD_DIFFICULTY_HARMLESS = "harmless";

		public const string RECORD_DIFFICULTY_LENIENT = "lenient";

		public const string RECORD_DIFFICULTY_STANDARD = "standard";

		public const string RECORD_DIFFICULTY_VIOLENT = "violent";

		public const string RECORD_DIFFICULTY_BRUTAL = "brutal";

		public static readonly Dictionary<RecordDifficulty, string> RECORD_DIFFICULTY_DICT = new Dictionary<RecordDifficulty, string>
		{
			{
				RecordDifficulty.ANY,
				"any"
			},
			{
				RecordDifficulty.HARMLESS,
				"harmless"
			},
			{
				RecordDifficulty.LENIENT,
				"lenient"
			},
			{
				RecordDifficulty.STANDARD,
				"standard"
			},
			{
				RecordDifficulty.VIOLENT,
				"violent"
			},
			{
				RecordDifficulty.BRUTAL,
				"brutal"
			}
		};

		public static readonly Dictionary<string, RecordDifficulty> RECORD_DIFFICULTY_REVERSE_DICT = new Dictionary<string, RecordDifficulty>
		{
			{
				"any",
				RecordDifficulty.ANY
			},
			{
				"harmless",
				RecordDifficulty.HARMLESS
			},
			{
				"lenient",
				RecordDifficulty.LENIENT
			},
			{
				"standard",
				RecordDifficulty.STANDARD
			},
			{
				"violent",
				RecordDifficulty.VIOLENT
			},
			{
				"brutal",
				RecordDifficulty.BRUTAL
			}
		};

		internal static List<Task> postRecordTasks = new List<Task>();

		public static RecordDifficulty DifficultyFromInteger(int difficulty)
		{
			return difficulty switch
			{
				0 => RecordDifficulty.HARMLESS, 
				1 => RecordDifficulty.LENIENT, 
				2 => RecordDifficulty.STANDARD, 
				4 => RecordDifficulty.BRUTAL, 
				_ => RecordDifficulty.VIOLENT, 
			};
		}

		private static async Task<string> TryPostRecordInternalTask(PostRecordInfo info)
		{
			if (LeaderboardController.LeaderboardsBlocked)
			{
				Plugin.logger.LogWarning((object)"Angry did not post the record because cheats or major assists were used");
				return "<color=red>Failed to post record:\nCheats used</color>";
			}
			int @int = MonoSingleton<PrefsManager>.Instance.GetInt("difficulty", -1);
			if (@int < 0 || @int > 4)
			{
				Plugin.logger.LogWarning((object)"Angry did not post the record because current difficulty is not valid");
				return "<color=red>Failed to post record:\nInvalid difficulty</color>";
			}
			bool flag = false;
			foreach (string key in Chainloader.PluginInfos.Keys)
			{
				_ = key;
				foreach (SoftBan checker in BannedModsManager.checkers)
				{
					try
					{
						SoftBanCheckResult softBanCheckResult = checker.Check();
						if (softBanCheckResult.banned)
						{
							Plugin.logger.LogWarning((object)("Banned mod found: " + checker.ModName + "\n" + softBanCheckResult.message));
							flag = true;
						}
					}
					catch (Exception arg)
					{
						Plugin.logger.LogError((object)$"Exception thrown while checking for soft ban for {checker.ModName}\n{arg}");
						flag = true;
					}
				}
			}
			if (flag)
			{
				Plugin.logger.LogWarning((object)"Angry did not post the record because there were banned mods found");
				return "<color=red>Failed to post record:\nBanned mods found</color>";
			}
			Plugin.logger.LogInfo((object)"Environment safe to send record. Posting to angry servers...");
			PostRecordResult postRecordResult = await PostRecordTask(info.category, info.difficulty, info.bundleGuid, info.hash, info.levelId, info.time);
			if (postRecordResult.completedSuccessfully)
			{
				if (postRecordResult.status == PostRecordStatus.OK)
				{
					Plugin.logger.LogInfo((object)$"Record posted successfully! Ranking: {postRecordResult.response.ranking}, New Best: {postRecordResult.response.newBest}");
					return string.Format("<color=green>Record posted! Rank {0}{1}</color>", postRecordResult.response.ranking, postRecordResult.response.newBest ? "\n(NEW BEST)" : "");
				}
				switch (postRecordResult.status)
				{
				case PostRecordStatus.BANNED:
					Plugin.logger.LogError((object)"User banned from the leaderboards");
					return "<color=red>Failed to post record:\nBanned</color>";
				case PostRecordStatus.INVALID_BUNDLE:
				case PostRecordStatus.INVALID_ID:
					Plugin.logger.LogWarning((object)"Level's leaderboards were not enabled");
					return "<color=red>Failed to post record:\nLeaderboards disabled for this level</color>";
				case PostRecordStatus.RATE_LIMITED:
					Plugin.logger.LogWarning((object)"Too many requests sent. Adding record to the pending list");
					PendingRecordsManager.AddPendingRecord(info);
					return "<color=red>Failed to post record:\nSent too many requests, added to pending list</color>";
				case PostRecordStatus.INVALID_HASH:
					Plugin.logger.LogWarning((object)"Current bundle version is not up to date with the leaderboard");
					return "<color=red>Failed to post record:\nBundle out of date</color>";
				case PostRecordStatus.INVALID_TIME:
					Plugin.logger.LogWarning((object)$"Angry server rejected the sent time {info.time}");
					return "<color=red>Failed to post record:\nInvalid time</color>";
				default:
					Plugin.logger.LogWarning((object)$"Encountered an unknown error while posting record. Status: {postRecordResult.status}, Message: '{postRecordResult.message}'. Adding record to the pending list");
					PendingRecordsManager.AddPendingRecord(info);
					return "<color=red>Failed to post record:\nReason unknown</color>";
				}
			}
			Plugin.logger.LogWarning((object)"Encountered a network error while posting record. Adding to the pending list");
			PendingRecordsManager.AddPendingRecord(info);
			return "<color=red>Failed to post record:\nNetwork error, added to the pending list</color>";
		}

		internal static Task<string> TryPostRecordTask(PostRecordInfo info)
		{
			Task<string> task2 = TryPostRecordInternalTask(info);
			postRecordTasks.Add(task2);
			task2.ContinueWith(delegate(Task<string> task)
			{
				if (task.Exception != null)
				{
					Plugin.logger.LogError((object)$"Post record task threw an exception\n{task.Exception}");
				}
				postRecordTasks.Remove(task);
			}, TaskScheduler.FromCurrentSynchronizationContext());
			return task2;
		}

		public static async Task<GetRecordsResult> GetRecordsTask(RecordCategory category, RecordDifficulty difficulty, string bundleGuid, string levelId, int offset, int count, CancellationToken cancellationToken = default(CancellationToken))
		{
			GetRecordsResult result = new GetRecordsResult();
			await AngryRequest.MakeRequest(AngryPaths.SERVER_ROOT + $"/leaderboards/getRecords?category={RECORD_CATEGORY_DICT[category]}&difficulty={RECORD_DIFFICULTY_DICT[difficulty]}&bundleGuid={bundleGuid}&levelId={levelId}&offset={offset}&count={count}", result, cancellationToken);
			result.completed = true;
			if (!result.completedSuccessfully)
			{
				result.status = GetRecordsStatus.FAILED;
			}
			return result;
		}

		internal static async Task<PostRecordResult> PostRecordTask(RecordCategory category, RecordDifficulty difficulty, string bundleGuid, string hash, string levelId, int time, CancellationToken cancellationToken = default(CancellationToken))
		{
			PostRecordResult result = new PostRecordResult();
			await AngryRequest.MakeRequestWithToken(AngryPaths.SERVER_ROOT + $"/leaderboards/postRecord?category={RECORD_CATEGORY_DICT[category]}&difficulty={RECORD_DIFFICULTY_DICT[difficulty]}&bundleGuid={bundleGuid}&hash={hash}&levelId={Uri.EscapeDataString(levelId)}&time={time}", result, PostRecordStatus.INVALID_TOKEN, cancellationToken);
			result.completed = true;
			if (!result.completedSuccessfully)
			{
				result.status = PostRecordStatus.FAILED;
			}
			return result;
		}

		public static async Task<GetUserRecordResult> GetUserRecordTask(RecordCategory category, RecordDifficulty difficulty, string bundleGuid, string levelId, string targetUserId, CancellationToken cancellationToken = default(CancellationToken))
		{
			GetUserRecordResult result = new GetUserRecordResult();
			await AngryRequest.MakeRequestWithToken(AngryPaths.SERVER_ROOT + "/leaderboards/getUserRecord?category=" + RECORD_CATEGORY_DICT[category] + "&difficulty=" + RECORD_DIFFICULTY_DICT[difficulty] + "&bundleGuid=" + bundleGuid + "&levelId=" + levelId + "&targetUserId=" + targetUserId, result, GetUserRecordStatus.INVALID_TOKEN, cancellationToken);
			result.completed = true;
			if (!result.completedSuccessfully)
			{
				result.status = GetUserRecordStatus.FAILED;
			}
			return result;
		}

		public static async Task<GetUserRecordsResult> GetUserRecordsTask(RecordCategory category, RecordDifficulty difficulty, string bundleGuid, string levelId, IEnumerable<string> targetUserIds, CancellationToken cancellationToken = default(CancellationToken))
		{
			GetUserRecordsResult result = new GetUserRecordsResult();
			string url = AngryPaths.SERVER_ROOT + "/leaderboards/getUserRecords?category=" + RECORD_CATEGORY_DICT[category] + "&difficulty=" + RECORD_DIFFICULTY_DICT[difficulty] + "&bundleGuid=" + bundleGuid + "&levelId=" + levelId;
			string body = JsonConvert.SerializeObject((object)new GetUserRecordsBodyObject
			{
				targetUserIds = targetUserIds.ToArray()
			});
			await AngryRequest.MakeRequestWithToken(url, result, GetUserRecordsStatus.INVALID_TOKEN, cancellationToken, "POST", body, "application/json");
			result.completed = true;
			if (!result.completedSuccessfully)
			{
				result.status = GetUserRecordsStatus.FAILED;
			}
			return result;
		}

		internal static async Task<GetUserInfoResult> GetUserInfoTask(string targetId, CancellationToken cancellationToken = default(CancellationToken))
		{
			GetUserInfoResult result = new GetUserInfoResult();
			await AngryRequest.MakeRequestWithToken(AngryPaths.SERVER_ROOT + "/leaderboards/getUserInfo?targetId=" + targetId, result, GetUserInfoStatus.INVALID_TOKEN, cancellationToken);
			result.completed = true;
			if (!result.completedSuccessfully)
			{
				result.status = GetUserInfoStatus.FAILED;
			}
			return result;
		}

		internal static async Task<ManageUserResult> ManageUserTask(string targetId, bool censorIcon = false, bool censorName = false, bool banUser = false, CancellationToken cancellationToken = default(CancellationToken))
		{
			ManageUserResult result = new ManageUserResult();
			await AngryRequest.MakeRequestWithToken(AngryPaths.SERVER_ROOT + "/leaderboards/manageUser?targetId=" + targetId + "&censorIcon=" + (censorIcon ? "true" : "false") + "&censorName=" + (censorName ? "true" : "false") + "&banUser=" + (banUser ? "true" : "false"), result, ManageUserStatus.INVALID_TOKEN, cancellationToken);
			result.completed = true;
			if (!result.completedSuccessfully)
			{
				result.status = ManageUserStatus.FAILED;
			}
			return result;
		}

		internal static async Task<RemoveRecordResult> RemoveRecordTask(string targetId, string bundleGuid, string levelId, RecordCategory category, RecordDifficulty difficulty, CancellationToken cancellationToken = default(CancellationToken))
		{
			RemoveRecordResult result = new RemoveRecordResult();
			await AngryRequest.MakeRequestWithToken(AngryPaths.SERVER_ROOT + "/leaderboards/removeRecord?targetId=" + targetId + "&bundleGuid=" + bundleGuid + "&levelId=" + Uri.EscapeDataString(levelId) + "&category=" + RECORD_CATEGORY_DICT[category] + "&difficulty=" + RECORD_DIFFICULTY_DICT[difficulty], result, RemoveRecordStatus.INVALID_TOKEN, cancellationToken);
			result.completed = true;
			if (!result.completedSuccessfully)
			{
				result.status = RemoveRecordStatus.FAILED;
			}
			return result;
		}

		internal static async Task<ClearRecordsResult> ClearRecordsTask(string targetId, CancellationToken cancellationToken = default(CancellationToken))
		{
			ClearRecordsResult result = new ClearRecordsResult();
			await AngryRequest.MakeRequestWithToken(AngryPaths.SERVER_ROOT + "/leaderboards/clearRecords?targetId=" + targetId, result, ClearRecordsStatus.INVALID_TOKEN, cancellationToken);
			result.completed = true;
			if (!result.completedSuccessfully)
			{
				result.status = ClearRecordsStatus.FAILED;
			}
			return result;
		}

		internal static async Task<GetUserHistoryResult> GetUserHistoryTask(string targetId, CancellationToken cancellationToken = default(CancellationToken))
		{
			GetUserHistoryResult result = new GetUserHistoryResult();
			await AngryRequest.MakeRequestWithToken(AngryPaths.SERVER_ROOT + "/leaderboards/getUserHistory?targetId=" + targetId, result, GetUserHistoryStatus.INVALID_TOKEN, cancellationToken);
			result.completed = true;
			if (!result.completedSuccessfully)
			{
				result.status = GetUserHistoryStatus.FAILED;
			}
			return result;
		}
	}
	public abstract class AngryResponse
	{
		public string message { get; set; }

		public int status { get; set; }
	}
	public abstract class AngryResult<Resp, Stat> where Resp : AngryResponse where Stat : Enum
	{
		public bool networkError;

		public bool httpError;

		public bool completed;

		public string message;

		public Stat status;

		public Resp response;

		public bool completedSuccessfully
		{
			get
			{
				if (completed && !networkError)
				{
					return !httpError;
				}
				return false;
			}
		}
	}
	internal static class AngryRequest
	{
		public const string CONTENT_TYPE_JSON = "application/json";

		public static async Task<AngryResult<Resp, Stat>> MakeRequestWithToken<Resp, Stat>(string url, AngryResult<Resp, Stat> result, Stat invalidTokenStatus, CancellationToken cancellationToken = default(CancellationToken), string method = "GET", string body = null, string contentType = null, bool tokenRequested = false) where Resp : AngryResponse where Stat : Enum
		{
			bool flag = string.IsNullOrEmpty(AngryUser.token);
			if (!flag || tokenRequested)
			{
				string text = (url.EndsWith("?") ? (url + "steamId=" + AngryUser.steamId + "&token=" + AngryUser.token) : (url + "&steamId=" + AngryUser.steamId + "&token=" + AngryUser.token));
				UnityWebRequest req = new UnityWebRequest(text, method);
				req.downloadHandler = (DownloadHandler)new DownloadHandlerBuffer();
				if (body != null)
				{
					req.uploadHandler = (UploadHandler)new UploadHandlerRaw(Encoding.UTF8.GetBytes(body));
				}
				if (contentType != null)
				{
					req.SetRequestHeader("Content-Type", contentType);
					if (req.uploadHandler != null)
					{
						req.uploadHandler.contentType = contentType;
					}
				}
				cancellationToken.Register(delegate
				{
					if (req != null && !req.isDone)
					{
						req.Abort();
					}
				});
				await (AsyncOperation)(object)req.SendWebRequest();
				if ((int)req.result == 2)
				{
					result.networkError = true;
					result.completed = true;
					return result;
				}
				if ((int)req.result == 3)
				{
					result.httpError = true;
					result.completed = true;
					return result;
				}
				if ((int)req.result != 1)
				{
					result.networkError = true;
					result.completed = true;
					return result;
				}
				Resp val = (result.response = JsonConvert.DeserializeObject<Resp>(req.downloadHandler.text));
				result.message = val.message;
				result.status = (Stat)Enum.ToObject(typeof(Stat), val.status);
				if (!EqualityComparer<Stat>.Default.Equals(result.status, invalidTokenStatus))
				{
					result.completed = true;
					return result;
				}
				flag = true;
			}
			if (flag)
			{
				if (tokenRequested)
				{
					result.completed = true;
					return result;
				}
				await AngryUser.GenerateToken();
				return await MakeRequestWithToken(url, result, invalidTokenStatus, cancellationToken, method, body, contentType, tokenRequested: true);
			}
			return result;
		}

		public static async Task<AngryResult<Resp, Stat>> MakeRequest<Resp, Stat>(string url, AngryResult<Resp, Stat> result, CancellationToken cancellationToken = default(CancellationToken), string method = "GET", string body = null, string contentType = null) where Resp : AngryResponse where Stat : Enum
		{
			UnityWebRequest req = new UnityWebRequest(url, method);
			req.downloadHandler = (DownloadHandler)new DownloadHandlerBuffer();
			if (body != null)
			{
				req.uploadHandler = (UploadHandler)new UploadHandlerRaw(Encoding.UTF8.GetBytes(body));
			}
			if (contentType != null)
			{
				req.SetRequestHeader("Content-Type", contentType);
				if (req.uploadHandler != null)
				{
					req.uploadHandler.contentType = contentType;
				}
			}
			cancellationToken.Register(delegate
			{
				if (req != null && !req.isDone)
				{
					req.Abort();
				}
			});
			await (AsyncOperation)(object)req.SendWebRequest();
			if ((int)req.result == 2)
			{
				result.networkError = true;
				result.completed = true;
				return result;
			}
			if ((int)req.result == 3)
			{
				result.httpError = true;
				result.completed = true;
				return result;
			}
			if ((int)req.result != 1)
			{
				result.httpError = true;
				result.completed = true;
				return result;
			}
			Resp val = (result.response = JsonConvert.DeserializeObject<Resp>(req.downloadHandler.text));
			result.message = val.message;
			result.status = (Stat)Enum.ToObject(typeof(Stat), val.status);
			result.completed = true;
			return result;
		}
	}
	public static class AngryUser
	{
		internal enum TokengenStatus
		{
			FAILED = -2,
			RATE_LIMITED,
			OK,
			INVALID_TICKET,
			INVALID_APP_ID,
			TICKET_EXPIRED
		}

		internal class TokenGenResponse
		{
			public string message { get; set; }

			public int status { get; set; }

			public string steamId { get; set; }

			public string token { get; set; }
		}

		internal class TokenGenResult
		{
			public bool networkError;

			public bool httpError;

			public TokengenStatus status = TokengenStatus.FAILED;

			public TokenGenResponse response;
		}

		public enum UserInfoStatus
		{
			FAILED = -2,
			RATE_LIMITED,
			OK,
			INVALID_TOKEN
		}

		public class UserInfoData
		{
			public string[] upvotedBundles;

			public string[] downvotedBundles;
		}

		public class UserInfoResponse : AngryResponse
		{
			public UserInfoData info;
		}

		public class UserInfoResult : AngryResult<UserInfoResponse, UserInfoStatus>
		{
		}

		internal enum ReportStatus
		{
			FAILED = -2,
			RATE_LIMITED,
			OK,
			INVALID_TOKEN,
			BANNED,
			INVALID_TARGET_ID,
			INVALID_ENTRY
		}

		internal class ReportResponse : AngryResponse
		{
			public bool alreadySent { get; set; }
		}

		internal class ReportResult : AngryResult<ReportResponse, ReportStatus>
		{
		}

		internal enum UserPermissionsStatus
		{
			FAILED = -2,
			RATE_LIMITED,
			OK,
			INVALID_TOKEN
		}

		internal class GetPermissionsResponse : AngryResponse
		{
			public bool hasLeaderboardModificationPermission { get; set; }
		}

		internal class GetPermissionsResult : AngryResult<GetPermissionsResponse, UserPermissionsStatus>
		{
		}

		internal static string token = "";

		internal static string steamId = "";

		private static StringField tokenCache;

		private static StringField lastTokenFetch;

		internal static bool hasLeaderboardPermissions = false;

		private static Task<TokenGenResult> currentTokenGenTask = null;

		internal static void Init()
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Expected O, but got Unknown
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Expected O, but got Unknown
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			tokenCache = new StringField(InternalConfigManager.internalConfig.rootPanel, "token", "angryServerToken", "", true);
			lastTokenFetch = new StringField(InternalConfigManager.internalConfig.rootPanel, "last token fetch", "angryServerTokenFetchTime", "0", false);
			try
			{
				SteamClient.Init(1229490u, true);
				if (long.TryParse(lastTokenFetch.value, out var result) && (DateTime.Now - new DateTime(result)).TotalDays < 1.0)
				{
					Plugin.logger.LogInfo((object)"Using cached token");
					steamId = SteamClient.SteamId.Value.ToString();
					token = tokenCache.value;
				}
			}
			catch (Exception ex)
			{
				Plugin.logger.LogError((object)ex.Message);
				Plugin.logger.LogError((object)ex.StackTrace);
			}
		}

		private static async Task<TokenGenResult> TokenGenTask()
		{
			TokenGenResult result = new TokenGenResult();
			try
			{
				AuthTicket val = await SteamUser.GetAuthTicketForWebApiAsync("com_eternalUnion_ultrakill", 10.0);
				if (val == null)
				{
					result.networkError = true;
					return result;
				}
				string text = ByteArrayToString(val.Data);
				UnityWebRequest tokenReq = new UnityWebRequest(AngryPaths.SERVER_ROOT + "/user/tokengen?ticket=" + text);
				tokenReq.downloadHandler = (DownloadHandler)new DownloadHandlerBuffer();
				await (AsyncOperation)(object)tokenReq.SendWebRequest();
				if ((int)tokenReq.result == 2)
				{
					result.networkError = true;
					return result;
				}
				if ((int)tokenReq.result == 3)
				{
					result.httpError = true;
					return result;
				}
				if ((int)tokenReq.result != 1)
				{
					result.httpError = true;
					return result;
				}
				TokenGenResponse tokenGenResponse = (result.response = JsonConvert.DeserializeObject<TokenGenResponse>(tokenReq.downloadHandler.text));
				result.status = (TokengenStatus)tokenGenResponse.status;
				if (result.status == TokengenStatus.OK)
				{
					steamId = tokenGenResponse.steamId;
					token = tokenGenResponse.token;
					tokenCache.value = token;
					lastTokenFetch.value = DateTime.Now.Ticks.ToString();
				}
				return result;
			}
			catch (Exception arg)
			{
				Plugin.logger.LogError((object)$"Failed to obtain user token\n{arg}");
				result.networkError = true;
				return result;
			}
			finally
			{
				currentTokenGenTask = null;
			}
			static string ByteArrayToString(byte[] ba)
			{
				StringBuilder stringBuilder = new StringBuilder(ba.Length * 2);
				foreach (byte b in ba)
				{
					stringBuilder.AppendFormat("{0:x2}", b);
				}
				return stringBuilder.ToString();
			}
		}

		internal static Task<TokenGenResult> GenerateToken()
		{
			if (currentTokenGenTask != null)
			{
				return currentTokenGenTask;
			}
			token = "";
			steamId = "";
			currentTokenGenTask = TokenGenTask();
			return currentTokenGenTask;
		}

		public static async Task<UserInfoResult> GetUserInfo(CancellationToken cancellationToken = default(CancellationToken))
		{
			UserInfoResult result = new UserInfoResult();
			await AngryRequest.MakeRequestWithToken(AngryPaths.SERVER_ROOT + "/user/info?", result, UserInfoStatus.INVALID_TOKEN, cancellationToken);
			result.completed = true;
			if (!result.completedSuccessfully)
			{
				result.status = UserInfoStatus.FAILED;
			}
			return result;
		}

		internal static async Task<ReportResult> ReportTask(string category, string difficulty, string bundleGuid, string levelId, string targetId, string reason, CancellationToken cancellationToken = default(CancellationToken))
		{
			ReportResult result = new ReportResult();
			await AngryRequest.MakeRequestWithToken(AngryPaths.SERVER_ROOT + "/user/report?category=" + category + "&difficulty=" + difficulty + "&bundleGuid=" + bundleGuid + "&levelId=" + levelId + "&targetId=" + targetId + "&reason=" + reason, result, ReportStatus.INVALID_TOKEN, cancellationToken);
			result.completed = true;
			if (!result.completedSuccessfully)
			{
				result.status = ReportStatus.FAILED;
			}
			return result;
		}

		internal static async Task<GetPermissionsResult> GetPermissionsTask(CancellationToken cancellationToken = default(CancellationToken))
		{
			GetPermissionsResult result = new GetPermissionsResult();
			await AngryRequest.MakeRequestWithToken(AngryPaths.SERVER_ROOT + "/user/getPermissions?", result, UserPermissionsStatus.INVALID_TOKEN, cancellationToken);
			result.completed = true;
			if (!result.completedSuccessfully)
			{
				result.status = UserPermissionsStatus.FAILED;
			}
			return result;
		}
	}
	public static class AngryVotes
	{
		public enum GetAllVotesStatus
		{
			FAILED = -2,
			RATE_LIMITED,
			GET_ALL_VOTES_OK
		}

		public class GetAllVotesBundleInfo
		{
			public int upvotes { get; set; }

			public int downvotes { get; set; }
		}

		public class GetAllVotesResponse : AngryResponse
		{
			public Dictionary<string, GetAllVotesBundleInfo> bundles;
		}

		public class GetAllVotesResult : AngryResult<GetAllVotesResponse, GetAllVotesStatus>
		{
		}

		internal enum VoteOperation
		{
			UPVOTE,
			DOWNVOTE,
			CLEAR,
			UNKNOWN
		}

		internal enum VoteStatus
		{
			FAILED = -2,
			RATE_LIMITED,
			VOTE_OK,
			VOTE_INVALID_TOKEN,
			VOTE_INVALID_BUNDLE,
			VOTE_INVALID_OPERATION
		}

		internal class VoteResponse : AngryResponse
		{
			public string bundleGuid { get; set; }

			public string operation { get; set; }

			public int upvotes { get; set; }

			public int downvotes { get; set; }
		}

		internal class VoteResult : AngryResult<VoteResponse, VoteStatus>
		{
			public VoteOperation operation;
		}

		internal const string VOTE_OP_UPVOTE = "upvote";

		internal const string VOTE_OP_DOWNVOTE = "downvote";

		internal const string VOTE_OP_CLEAR = "clear";

		public static async Task<GetAllVotesResult> GetAllVotesTask(CancellationToken cancellationToken = default(CancellationToken))
		{
			GetAllVotesResult result = new GetAllVotesResult();
			await AngryRequest.MakeRequest(AngryPaths.SERVER_ROOT + "/votes", result, cancellationToken);
			result.completed = true;
			if (!result.completedSuccessfully)
			{
				result.status = GetAllVotesStatus.FAILED;
			}
			return result;
		}

		internal static async Task<VoteResult> VoteTask(string bundleGuid, VoteOperation operation, CancellationToken cancellationToken = default(CancellationToken))
		{
			VoteResult result = new VoteResult();
			string text = "clear";
			switch (operation)
			{
			case VoteOperation.UPVOTE:
				text = "upvote";
				break;
			case VoteOperation.DOWNVOTE:
				text = "downvote";
				break;
			}
			await AngryRequest.MakeRequestWithToken(AngryPaths.SERVER_ROOT + "/user/vote?bundleGuid=" + bundleGuid + "&op=" + text, result, VoteStatus.VOTE_INVALID_TOKEN, cancellationToken);
			result.operation = VoteOperation.CLEAR;
			if (result.completedSuccessfully && result.response != null)
			{
				if (result.response.operation == "upvote")
				{
					result.operation = VoteOperation.UPVOTE;
				}
				else if (result.response.operation == "downvote")
				{
					result.operation = VoteOperation.DOWNVOTE;
				}
			}
			result.completed = true;
			if (!result.completedSuccessfully)
			{
				result.status = VoteStatus.FAILED;
			}
			return result;
		}
	}
}
namespace AngryLevelLoader.Managers.LegacyPatches
{
	internal class LazyAddressableAsset<T> where T : Object
	{
		private T _asset;

		private readonly string path;

		public LazyAddressableAsset(string path)
		{
			this.path = path;
		}

		public T Get()
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_asset != (Object)null)
			{
				return _asset;
			}
			_asset = Addressables.LoadAssetAsync<T>((object)path).WaitForCompletion();
			return _asset;
		}
	}
	internal class LazyAsset<T>
	{
		private T _asset;

		private Func<T> _assetGetter;

		public LazyAsset(Func<T> assetGetter)
		{
			_assetGetter = assetGetter;
		}

		public T Get()
		{
			if (_asset != null)
			{
				return _asset;
			}
			_asset = _assetGetter();
			return _asset;
		}
	}
	internal enum LegacyPatchState
	{
		None,
		V6,
		V7
	}
	[AttributeUsage(AttributeTargets.Class, AllowMultiple = true)]
	internal class LegacyPatchAttribute : Attribute
	{
		public readonly LegacyPatchState targetVersion;

		public LegacyPatchAttribute(LegacyPatchState targetVersion)
		{
			this.targetVersion = targetVersion;
		}
	}
	internal static class LegacyPatchManager
	{
		internal static Dictionary<LegacyPatchState, List<Type>> patches;

		private static LegacyPatchState patchState;

		private static Harmony legacyHarmony;

		static LegacyPatchManager()
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			patches = new Dictionary<LegacyPatchState, List<Type>>();
			patchState = LegacyPatchState.None;
			legacyHarmony = new Harmony("com.eternalUnion.angryLevelLoader_legacyPatches");
			foreach (LegacyPatchState value in Enum.GetValues(typeof(LegacyPatchState)))
			{
				patches[value] = new List<Type>();
			}
			foreach (Type item in from t in Assembly.GetExecutingAssembly().GetTypes()
				where t.GetCustomAttribute(typeof(LegacyPatchAttribute)) != null
				select t)
			{
				foreach (LegacyPatchState item2 in (from attr in item.GetCustomAttributes<LegacyPatchAttribute>()
					select attr.targetVersion).Distinct())
				{
					patches[item2].Add(item);
				}
			}
		}

		internal static void Init()
		{
			SceneManager.sceneLoaded += delegate(Scene scene, LoadSceneMode mode)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_0002: Invalid comparison between Unknown and I4
				if ((int)mode != 1)
				{
					if (AngrySceneManager.isInCustomLevel)
					{
						switch (AngrySceneManager.currentBundleContainer.BundleVersion)
						{
						case 6:
							SetLegacyPatchState(LegacyPatchState.V6);
							break;
						case 7:
							SetLegacyPatchState(LegacyPatchState.V7);
							break;
						default:
							SetLegacyPatchState(LegacyPatchState.None);
							break;
						}
					}
					else
					{
						SetLegacyPatchState(LegacyPatchState.None);
					}
				}
			};
		}

		internal static void SetLegacyPatchState(LegacyPatchState state)
		{
			if (patchState == state)
			{
				return;
			}
			patchState = state;
			legacyHarmony.UnpatchSelf();
			if (!patches.TryGetValue(state, out var value))
			{
				return;
			}
			foreach (Type item in value)
			{
				legacyHarmony.PatchAll(item);
			}
		}
	}
	[LegacyPatch(LegacyPatchState.V6)]
	internal static class V6LegacyScriptPatches
	{
		[HarmonyPatch(typeof(MovingPlatform), "Start")]
		[HarmonyPrefix]
		private static void PatchMovingPlatform(MovingPlatform __instance)
		{
			__instance.moveOnEnable = true;
		}
	}
	[LegacyPatch(LegacyPatchState.V6)]
	internal static class V6LegacyEnemyPatches
	{
		private static LazyAddressableAsset<GameObject> MINDFLAYER_BEAM = new LazyAddressableAsset<GameObject>("Assets/Prefabs/Attacks and Projectiles/Hitscan Beams/Mindflayer Beam.prefab");

		private static LazyAddressableAsset<GameObject> MALICIOUS_FACE = new LazyAddressableAsset<GameObject>("Assets/Prefabs/Enemies/Malicious Face.prefab");

		private static LazyAsset<AssetReference> MALICIOUS_FACE_EXPLOSION = new LazyAsset<AssetReference>(() => MALICIOUS_FACE.Get().GetComponentInChildren<MaliciousFace>(true).beamExplosion);

		private static LazyAsset<AssetReference> MALICIOUS_FACE_SHOCKWAVE = new LazyAsset<AssetReference>(() => MALICIOUS_FACE.Get().GetComponentInChildren<MaliciousFace>(true).shockwave);

		private static Enemy MachineToEnemy(Machine machine, EnemyIdentifier eid)
		{
			((Component)machine).gameObject.SetActive(false);
			Enemy val = (eid.machine = ((Component)machine).gameObject.AddComponent<Enemy>());
			val.isMachine = true;
			val.health = ((Enemy)machine).health;
			val.noFallDamage = ((Enemy)machine).noFallDamage;
			val.dontDie = ((Enemy)machine).dontDie;
			val.specialDeath = ((Enemy)machine).specialDeath;
			val.simpleDeath = ((Enemy)machine).simpleDeath;
			val.dismemberment = ((Enemy)machine).dismemberment;
			val.knockedBack = ((Enemy)machine).knockedBack;
			val.brakes = ((Enemy)machine).brakes;
			val.juggleWeight = ((Enemy)machine).juggleWeight;
			val.parryable = ((Enemy)machine).parryable;
			val.partiallyParryable = ((Enemy)machine).partiallyParryable;
			val.hurtSounds = ((Enemy)machine).hurtSounds;
			val.deathSound = ((Enemy)machine).deathSound;
			val.scream = ((Enemy)machine).scream;
			val.chest = ((Enemy)machine).chest;
			val.smr = ((Enemy)machine).smr;
			val.deadMaterial = ((Enemy)machine).deadMaterial;
			val.destroyOnDeath = ((Enemy)machine).destroyOnDeath;
			val.bigKill = ((Enemy)machine).bigKill;
			val.thickLimbs = ((Enemy)machine).thickLimbs;
			val.onDeath = ((Enemy)machine).onDeath;
			GameObjectExtensions.SwapComponents(((Component)machine).gameObject, ((Component)machine).GetComponentIndex(), ((Component)val).GetComponentIndex());
			((Behaviour)machine).enabled = false;
			return val;
		}

		private static Enemy StatueToEnemy(Statue statue, EnemyIdentifier eid)
		{
			((Component)statue).gameObject.SetActive(false);
			Enemy val = (eid.statue = ((Component)statue).gameObject.AddComponent<Enemy>());
			val.isStatue = true;
			val.health = ((Enemy)statue).health;
			val.chest = ((Enemy)statue).chest;
			val.hurtSounds = ((Enemy)statue).hurtSounds;
			val.deadMaterial = ((Enemy)statue).deadMaterial;
			val.woundedMaterial = ((Enemy)statue).woundedMaterial;
			val.woundedEnrageMaterial = ((Enemy)statue).woundedEnrageMaterial;
			val.woundedParticle = ((Enemy)statue).woundedParticle;
			val.woundedModel = ((Enemy)statue).woundedModel;
			val.smr = ((Enemy)statue).smr;
			val.deathSound = ((Enemy)statue).deathSound;
			val.extraDamageZones = ((Enemy)statue).extraDamageZones;
			val.extraDamageMultiplier = ((Enemy)statue).extraDamageMultiplier;
			val.brakes = ((Enemy)statue).brakes;
			val.juggleWeight = ((Enemy)statue).juggleWeight;
			val.bigBlood = ((Enemy)statue).bigBlood;
			val.isMassDeath = ((Enemy)statue).isMassDeath;
			val.specialDeath = ((Enemy)statue).specialDeath;
			GameObjectExtensions.SwapComponents(((Component)statue).gameObject, ((Component)statue).GetComponentIndex(), ((Component)val).GetComponentIndex());
			((Behaviour)statue).enabled = false;
			return val;
		}

		private static Enemy ZombieToEnemy(Zombie zombie, EnemyIdentifier eid)
		{
			((Component)zombie).gameObject.SetActive(false);
			Enemy val = (eid.zombie = ((Component)zombie).gameObject.AddComponent<Enemy>());
			val.isZombie = true;
			val.health = ((Enemy)zombie).health;
			val.noFallDamage = ((Enemy)zombie).noFallDamage;
			val.variableSpeed = true;
			val.hurtSounds = ((Enemy)zombie).hurtSounds;
			val.deathSound = ((Enemy)zombie).deathSound;
			val.scream = ((Enemy)zombie).scream;
			val.hurtSoundVol = ((Enemy)zombie).hurtSoundVol;
			val.deathSoundVol = ((Enemy)zombie).deathSoundVol;
			val.chest = ((Enemy)zombie).chest;
			val.brakes = ((Enemy)zombie).brakes;
			val.juggleWeight = ((Enemy)zombie).juggleWeight;
			val.smr = ((Enemy)zombie).smr;
			val.deadMaterial = ((Enemy)zombie).deadMaterial;
			GameObjectExtensions.SwapComponents(((Component)zombie).gameObject, ((Component)zombie).GetComponentIndex(), ((Component)val).GetComponentIndex());
			((Behaviour)zombie).enabled = false;
			return val;
		}

		[HarmonyPatch(typeof(EnemyIdentifier), "Awake")]
		[HarmonyPrefix]
		private static bool PatchPreAwakeEnemyIdentifier(EnemyIdentifier __instance)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Expected I4, but got Unknown
			//IL_0609: Unknown result type (might be due to invalid IL or missing references)
			//IL_0613: Unknown result type (might be due to invalid IL or missing references)
			//IL_0618: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				EnemyType enemyType = __instance.enemyType;
				switch (enemyType - 1)
				{
				case 0:
				{
					((Component)__instance).gameObject.SetActive(false);
					Enemy mach = ((Component)__instance).gameObject.AddComponent<Enemy>();
					mach.isDrone = true;
					mach.hurtSounds = (AudioClip[])(object)new AudioClip[0];
					mach.health = __instance.health;
					Drone component4 = ((Component)__instance).gameObject.GetComponent<Drone>();
					if ((Object)(object)((Component)__instance).gameObject.GetComponent<DroneFlesh>() == (Object)null)
					{
						mach.brakes = 1f;
					}
					if ((Object)(object)component4 != (Object)null)
					{
						mach.hurtSound = component4.hurtSound;
						mach.deathSound = component4.deathSound;
					}
					break;
				}
				case 8:
				{
					((Component)__instance).gameObject.SetActive(false);
					Enemy mach = ((Component)__instance).gameObject.AddComponent<Enemy>();
					mach.isDrone = true;
					mach.hurtSounds = (AudioClip[])(object)new AudioClip[0];
					mach.health = __instance.health;
					if (__instance.bigEnemy)
					{
						mach.brakes = 1f;
					}
					Drone component4 = ((Component)__instance).gameObject.GetComponent<Drone>();
					if ((Object)(object)component4 != (Object)null)
					{
						mach.hurtSound = component4.hurtSound;
						mach.deathSound = component4.deathSound;
						mach.enrageEffect = component4.enrageEffect;
					}
					if ((Object)(object)((Component)__instance).GetComponent<DroneFlesh>() != (Object)null)
					{
						mach.health = 5f;
					}
					break;
				}
				case 25:
				{
					Machine component3 = ((Component)__instance).GetComponent<Machine>();
					if ((Object)(object)component3 != (Object)null)
					{
						Enemy mach = MachineToEnemy(component3, __instance);
						mach.overrideFalling = true;
					}
					break;
				}
				case 16:
				{
					Statue component2 = ((Component)__instance).GetComponent<Statue>();
					if ((Object)(object)component2 != (Object)null)
					{
						StatueToEnemy(component2, __instance);
					}
					break;
				}
				case 29:
				{
					Statue component2 = ((Component)__instance).GetComponent<Statue>();
					if ((Object)(object)component2 != (Object)null)
					{
						StatueToEnemy(component2, __instance);
					}
					break;
				}
				case 32:
				{
					Machine component3 = ((Component)__instance).GetComponent<Machine>();
					if ((Object)(object)component3 != (Object)null)
					{
						MachineToEnemy(component3, __instance);
					}
					break;
				}
				case 33:
				{
					Machine component3 = ((Component)__instance).GetComponent<Machine>();
					if ((Object)(object)component3 != (Object)null)
					{
						MachineToEnemy(component3, __instance);
					}
					break;
				}
				case 30:
				{
					Statue component2 = ((Component)__instance).GetComponent<Statue>();
					if ((Object)(object)component2 != (Object)null)
					{
						StatueToEnemy(component2, __instance);
					}
					break;
				}
				case 1:
				{
					Statue component2 = ((Component)__instance).GetComponent<Statue>();
					if ((Object)(object)component2 != (Object)null)
					{
						StatueToEnemy(component2, __instance);
					}
					Mass val2 = default(Mass);
					if (((Component)__instance).gameObject.TryGetComponent<Mass>(ref val2))
					{
						EnemySimplifier[] componentsInChildren = ((Component)__instance).gameObject.GetComponentsInChildren<EnemySimplifier>(true);
						foreach (EnemySimplifier obj in componentsInChildren)
						{
							obj.enragedMaterial = val2.enrageMaterial;
							obj.enemyScriptHandlesEnrage = false;
						}
					}
					break;
				}
				case 4:
				{
					Machine component3 = ((Component)__instance).GetComponent<Machine>();
					if ((Object)(object)component3 != (Object)null)
					{
						MachineToEnemy(component3, __instance);
					}
					break;
				}
				case 17:
				{
					Machine component3 = ((Component)__instance).GetComponent<Machine>();
					if ((Object)(object)component3 != (Object)null)
					{
						Enemy mach = MachineToEnemy(component3, __instance);
						mach.overrideFalling = true;
					}
					break;
				}
				case 31:
				{
					Machine component3 = ((Component)__instance).GetComponent<Machine>();
					if ((Object)(object)component3 != (Object)null)
					{
						MachineToEnemy(component3, __instance);
					}
					break;
				}
				case 12:
				{
					Zombie component = ((Component)__instance).GetComponent<Zombie>();
					if ((Object)(object)component != (Object)null)
					{
						ZombieToEnemy(component, __instance);
					}
					break;
				}
				case 35:
				{
					Machine component3 = ((Component)__instance).GetComponent<Machine>();
					if ((Object)(object)component3 != (Object)null)
					{
						MachineToEnemy(component3, __instance);
					}
					break;
				}
				case 14:
				{
					Zombie component = ((Component)__instance).GetComponent<Zombie>();
					if ((Object)(object)component != (Object)null)
					{
						Enemy mach = ZombieToEnemy(component, __instance);
						mach.variableSpeed = false;
					}
					ZombieProjectiles val3 = default(ZombieProjectiles);
					if (((Component)__instance).gameObject.TryGetComponent<ZombieProjectiles>(ref val3))
					{
						val3.chaser = true;
					}
					break;
				}
				case 18:
				{
					Machine component3 = ((Component)__instance).GetComponent<Machine>();
					if ((Object)(object)component3 != (Object)null)
					{
						Enemy mach = MachineToEnemy(component3, __instance);
						mach.overrideFalling = true;
					}
					break;
				}
				case 28:
				{
					Machine component3 = ((Component)__instance).GetComponent<Machine>();
					if ((Object)(object)component3 != (Object)null)
					{
						MachineToEnemy(component3, __instance);
					}
					break;
				}
				case 3:
				{
					((Component)__instance).gameObject.SetActive(false);
					((Component)((Component)__instance).transform.parent).gameObject.AddComponent<PortalAwareRenderer>();
					Enemy mach = ((Component)__instance).gameObject.AddComponent<Enemy>();
					SpiderBody component5 = ((Component)__instance).gameObject.GetComponent<SpiderBody>();
					mach.isSpider = true;
					mach.hurtSounds = (AudioClip[])(object)new AudioClip[0];
					mach.brakes = 1f;
					mach.health = component5.health;
					if ((Object)(object)component5 != (Object)null)
					{
						mach.hurtSound = component5.hurtSound;
						mach.woundedMaterial = component5.woundedMaterial;
						mach.woundedEnrageMaterial = component5.woundedEnrageMaterial;
						mach.woundedParticle = component5.woundedParticle;
						mach.enrageEffect = component5.enrageEffect;
						((Behaviour)component5).enabled = false;
						GameObjectExtensions.SwapComponents(((Component)__instance).gameObject, ((Component)mach).GetComponentIndex(), ((Component)component5).GetComponentIndex());
					}
					mach.bodyCenter = ((Component)__instance).transform;
					MaliciousFace val4 = (__instance.spider = ((Component)__instance).gameObject.AddComponent<MaliciousFace>());
					val4.spider = mach;
					val4.proj = component5.proj;
					val4.spark = component5.spark;
					val4.spiderBeam = component5.spiderBeam;
					val4.beamExplosion = MALICIOUS_FACE_EXPLOSION.Get();
					val4.shockwave = MALICIOUS_FACE_SHOCKWAVE.Get();
					val4.breakParticle = component5.breakParticle;
					val4.impactParticle = component5.impactParticle;
					val4.impactSprite = component5.impactSprite;
					val4.dripBlood = component5.dripBlood;
					val4.chargeEffect = component5.chargeEffect;
					val4.enrageEffect = component5.enrageEffect;
					val4.hurtSound = component5.hurtSound;
					val4.spiderStationary = component5.stationary;
					val4.spiderTargetHeight = component5.targetHeight;
					val4.mouth = component5.mouth;
					val4.sparkRotationOffset = Vector3.up * 90f;
					val4.headModel = component5.headModel;
					if ((Object)(object)val4.headModel == (Object)null)
					{
						val4.headModel = ((Component)component5).transform.GetChild(0);
					}
					val4.headCollider = component5.headCollider;
					if ((Object)(object)val4.headCollider == (Object)null)
					{
						val4.headCollider = ((Component)component5.headModel.GetChild(0)).GetComponent<Collider>();
					}
					val4.mainMesh = component5.mainMesh;
					SpiderLegsController componentInChildren = ((Component)((Component)component5).transform.parent).GetComponentInChildren<SpiderLegsController>(true);
					if ((Object)(object)componentInChildren != (Object)null)
					{
						val4.legController = ((Component)componentInChildren).gameObject;
					}
					val4.legs = (from l in ((Component)((Component)component5).transform.parent).gameObject.GetComponentsInChildren<SpiderLegLines>(true)
						select ((Component)l).gameObject).Concat(from l in ((Component)((Component)component5).transform.parent).gameObject.GetComponentsInChildren<SpiderLeg>(true)
						select ((Component)l).gameObject).ToArray();
					val4.woundedMaterial = component5.woundedMaterial;
					val4.woundedEnrageMaterial = component5.woundedEnrageMaterial;
					val4.woundedParticle = component5.woundedParticle;
					break;
				}
				case 11:
				{
					Machine component3 = ((Component)__instance).GetComponent<Machine>();
					if ((Object)(object)component3 != (Object)null)
					{
						MachineToEnemy(component3, __instance);
					}
					break;
				}
				case 5:
				{
					Machine component3 = ((Component)__instance).GetComponent<Machine>();
					if ((Object)(object)component3 != (Object)null)
					{
						MachineToEnemy(component3, __instance);
					}
					break;
				}
				case 13:
				{
					Zombie component = ((Component)__instance).GetComponent<Zombie>();
					if ((Object)(object)component != (Object)null)
					{
						ZombieToEnemy(component, __instance);
					}
					break;
				}
				case 6:
				{
					Machine component3 = ((Component)__instance).GetComponent<Machine>();
					if ((Object)(object)component3 != (Object)null)
					{
						MachineToEnemy(component3, __instance);
					}
					break;
				}
				case 19:
				{
					Machine component3 = ((Component)__instance).GetComponent<Machine>();
					if ((Object)(object)component3 != (Object)null)
					{
						Enemy mach = MachineToEnemy(component3, __instance);
						Turret val = default(Turret);
						if (((Component)__instance).gameObject.TryGetComponent<Turret>(ref val))
						{
							val.mach = mach;
						}
					}
					break;
				}
				case 7:
				{
					Machine component3 = ((Component)__instance).GetComponent<Machine>();
					if ((Object)(object)component3 != (Object)null)
					{
						MachineToEnemy(component3, __instance);
					}
					break;
				}
				case 2:
				{
					Zombie component = ((Component)__instance).GetComponent<Zombie>();
					if ((Object)(object)component != (Object)null)
					{
						ZombieToEnemy(component, __instance);
					}
					break;
				}
				}
				if (__instance.puppet)
				{
					__instance.permaPuppet = true;
				}
				__instance.health = 999f;
				__instance.InitializeReferences();
				__instance.ForceGetHealth();
				__instance.UpdateModifiers();
				if ((Object)(object)StockMapInfo.Instance != (Object)null && ((MapInfoBase)StockMapInfo.Instance).forceUpdateEnemyRenderers)
				{
					SkinnedMeshRenderer[] componentsInChildren2 = ((Component)__instance).GetComponentsInChildren<SkinnedMeshRenderer>(true);
					for (int j = 0; j < componentsInChildren2.Length; j++)
					{
						componentsInChildren2[j].updateWhenOffscreen = true;
					}
				}
				__instance.bsm = MonoSingleton<BloodsplatterManager>.Instance;
			}
			catch (Exception ex)
			{
				Debug.LogException(ex);
			}
			if (!((Component)__instance).gameObject.activeSelf)
			{
				((Component)__instance).gameObject.SetActive(true);
			}
			return false;
		}

		[HarmonyPatch(typeof(Turret), "Start")]
		[HarmonyPrefix]
		private static void PatchTurretStart(Turret __instance)
		{
			__instance.barrelTip = ((Component)__instance).transform.Find("TurretBot/Armature/Root/Pelvis/Spine_01/Spine_02/Torso/Neck/Head_Main/Barrel/Barrel_end");
		}

		[HarmonyPatch(typeof(Mindflayer), "Start")]
		[HarmonyPrefix]
		private static void PatchMindflayerStart(Mindflayer __instance)
		{
			__instance.lr = ((Component)__instance).GetComponent<LineRenderer>();
			__instance.sweepLineRenderers = (LineRenderer[])(object)new LineRenderer[1] { __instance.lr };
			__instance.beam = MINDFLAYER_BEAM.Get().GetComponent<ContinuousBeam>();
		}
	}
	[LegacyPatch(LegacyPatchState.V7)]
	internal static class V7LegacyPlayerPatches
	{
		private static LazyAddressableAsset<GameObject> PLAYER_PREFAB = new LazyAddressableAsset<GameObject>("Assets/Prefabs/Player/Player.prefab");

		[HarmonyPatch(typeof(NewMovement), "Start")]
		[HarmonyPrefix]
		private static void PatchPlayer(NewMovement __instance)
		{
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)__instance.windStateParticle == (Object)null)
			{
				GameObject val = PLAYER_PREFAB.Get();
				NewMovement val2 = default(NewMovement);
				if ((Object)(object)val != (Object)null && val.TryGetComponent<NewMovement>(ref val2) && (Object)(object)val2.windStateParticle != (Object)null)
				{
					GameObject val3 = Object.Instantiate<GameObject>(((Component)val2.windStateParticle).gameObject);
					val3.transform.SetParent(((Component)__instance).transform);
					val3.transform.localPosition = ((Component)val2.windStateParticle).transform.localPosition;
					val3.transform.localRotation = ((Component)val2.windStateParticle).transform.localRotation;
					val3.transform.localScale = ((Component)val2.windStateParticle).transform.localScale;
					__instance.windStateParticle = val3.GetComponent<ParticleSystem>();
				}
			}
		}
	}
}
namespace AngryLevelLoader.Managers.BannedMods
{
	internal static class BannedModsManager
	{
		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static Func<Type, bool> <>9__2_1;

			public static OpenPanelEventDelegate <>9__2_0;

			internal bool <Init>b__2_1(Type t)
			{
				return t.GetCustomAttribute(typeof(SoftBanClassAttribute)) != null;
			}

			internal void <Init>b__2_0(bool externally)
			{
				bool flag = false;
				ConfigManager.bannedModsText.text = "";
				foreach (SoftBan checker in checkers)
				{
					try
					{
						SoftBanCheckResult softBanCheckResult = checker.Check();
						if (softBanCheckResult.banned)
						{
							if (!string.IsNullOrEmpty(ConfigManager.bannedModsText.text))
							{
								ConfigHeader bannedModsText = ConfigManager.bannedModsText;
								bannedModsText.text += "\n";
							}
							ConfigHeader bannedModsText2 = ConfigManager.bannedModsText;
							bannedModsText2.text = bannedModsText2.text + "<color=red>" + checker.ModName + "</color>\n<size=18>" + softBanCheckResult.message + "</size>\n\n";
							flag = true;
						}
					}
					catch (Exception arg)
					{
						Plugin.logger.LogError((object)$"Exception thrown while checking for soft ban for {checker.ModName}\n{arg}");
						if (!string.IsNullOrEmpty(ConfigManager.bannedModsText.text))
						{
							ConfigHeader bannedModsText3 = ConfigManager.bannedModsText;
							bannedModsText3.text += "\n";
						}
						ConfigHeader bannedModsText4 = ConfigManager.bannedModsText;
						bannedModsText4.text = bannedModsText4.text + "<color=red>" + checker.ModName + "</color>\n<size=18>- Encountered an error while checking for the soft ban status, check console</size>\n\n";
						flag = true;
					}
				}
				((ConfigField)ConfigManager.bannedModsPanel).hidden = !flag;
			}
		}

		public static List<SoftBan> checkers = new List<SoftBan>();

		public static SoftBan GetChecker(string guid)
		{
			return checkers.Where((SoftBan chk) => chk.ModGuid == guid).FirstOrDefault();
		}

		public static void Init()
		{
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: Expected O, but got Unknown
			foreach (Type item in from t in Assembly.GetExecutingAssembly().GetTypes()
				where t.GetCustomAttribute(typeof(SoftBanClassAttribute)) != null
				select t)
			{
				if (!(item.GetConstructor(new Type[0]).Invoke(new object[0]) is SoftBan softBan))
				{
					Plugin.logger.LogWarning((object)("Softban class " + item.Name + " does not inherit SoftBan!"));
				}
				else if (softBan.ModLoaded)
				{
					Plugin.logger.LogInfo((object)("Detected " + softBan.ModName + ", adding soft ban check for leaderboards"));
					try
					{
						softBan.Init();
					}
					catch (Exception ex)
					{
						Plugin.logger.LogError((object)ex);
						continue;
					}
					checkers.Add(softBan);
				}
			}
			ConfigPanel rootPanel = ConfigManager.config.rootPanel;
			object obj = <>c.<>9__2_0;
			if (obj == null)
			{
				OpenPanelEventDelegate val = delegate
				{
					bool flag = false;
					ConfigManager.bannedModsText.text = "";
					foreach (SoftBan checker in checkers)
					{
						try
						{
							SoftBanCheckResult softBanCheckResult = checker.Check();
							if (softBanCheckResult.banned)
							{
								if (!string.IsNullOrEmpty(ConfigManager.bannedModsText.text))
								{
									ConfigHeader bannedModsText = ConfigManager.bannedModsText;
									bannedModsText.text += "\n";
								}
								ConfigHeader bannedModsText2 = ConfigManager.bannedModsText;
								bannedModsText2.text = bannedModsText2.text + "<color=red>" + checker.ModName + "</color>\n<size=18>" + softBanCheckResult.message + "</size>\n\n";
								flag = true;
							}
						}
						catch (Exception arg)
						{
							Plugin.logger.LogError((object)$"Exception thrown while checking for soft ban for {checker.ModName}\n{arg}");
							if (!string.IsNullOrEmpty(ConfigManager.bannedModsText.text))
							{
								ConfigHeader bannedModsText3 = ConfigManager.bannedModsText;
								bannedModsText3.text += "\n";
							}
							ConfigHeader bannedModsText4 = ConfigManager.bannedModsText;
							bannedModsText4.text = bannedModsText4.text + "<color=red>" + checker.ModName + "</color>\n<size=18>- Encountered an error while checking for the soft ban status, check console</size>\n\n";
							flag = true;
						}
					}
					((ConfigField)ConfigManager.bannedModsPanel).hidden = !flag;
				};
				<>c.<>9__2_0 = val;
				obj = (object)val;
			}
			rootPanel.onPannelOpenEvent += (OpenPanelEventDelegate)obj;
		}
	}
	[AttributeUsage(AttributeTargets.Class, AllowMultiple = false)]
	internal class SoftBanClassAttribute : Attribute
	{
	}
	internal struct SoftBanCheckResult
	{
		public bool banned;

		public string message;

		public SoftBanCheckResult()
		{
			banned = false;
			message = "";
		}

		public SoftBanCheckResult(bool banned, string message)
		{
			this.banned = banned;
			this.message = message;
		}
	}
	internal abstract class SoftBan
	{
		public abstract string ModGuid { get; }

		public abstract string ModName { get; }

		public virtual bool ModLoaded => Chainloader.PluginInfos.ContainsKey(ModGuid);

		public virtual void Init()
		{
		}

		public abstract SoftBanCheckResult Check();
	}
}
namespace AngryLevelLoader.Managers.BannedMods.SoftBans
{
	[SoftBanClass]
	internal class BananasDifficultySoftBan : SoftBan
	{
		public override string ModGuid => "com.banana.BananaDifficulty";

		public override string ModName => "Banana Difficulty";

		public override SoftBanCheckResult Check()
		{
			if (BananaDifficultyPlugin.CanUseIt(-1))
			{
				return new SoftBanCheckResult(banned: true, "Bananas difficulty is not allowed in the leaderboards, turn off global difficulty and switch to other difficulties to be able to post records");
			}
			return new SoftBanCheckResult();
		}
	}
	[SoftBanClass]
	internal class BillionDifficultySoftBan : SoftBan
	{
		public override string ModGuid => "billy.billiondifficulty";

		public override string ModName => "Billion Difficulty";

		public override SoftBanCheckResult Check()
		{
			if (Util.IsDifficulty(19))
			{
				return new SoftBanCheckResult(banned: true, "Billion difficulty is not allowed in the leaderboards, turn off global difficulty and switch to other difficulties to be able to post records");
			}
			return new SoftBanCheckResult();
		}
	}
	[SoftBanClass]
	internal class FasterPunchSoftBan : SoftBan
	{
		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static UnityAction<Scene, LoadSceneMode> <>9__5_0;

			public static BoolValueChangeEventDelegate <>9__5_1;

			public static BoolValueChangeEventDelegate <>9__5_2;

			public static BoolValueChangeEventDelegate <>9__5_3;

			public static BoolValueChangeEventDelegate <>9__5_4;

			internal void <Init>b__5_0(Scene scene, LoadSceneMode mode)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_0002: Invalid comparison between Unknown and I4
				if ((int)mode != 1)
				{
					currentlyBanned = false;
				}
			}

			internal void <Init>b__5_1(BoolValueChangeEvent e)
			{
				if (e.value)
				{
					currentlyBanned = true;
				}
			}

			internal void <Init>b__5_2(BoolValueChangeEvent e)
			{
				if (e.value)
				{
					currentlyBanned = true;
				}
			}

			internal void <Init>b__5_3(BoolValueChangeEvent e)
			{
				if (e.value)
				{
					currentlyBanned = true;
				}
			}

			internal void <Init>b__5_4(BoolValueChangeEvent e)
			{
				if (e.value)
				{
					currentlyBanned = true;
				}
			}
		}

		private static bool currentlyBanned;

		public override string ModGuid => "ironfarm.uk.muda";

		public override string ModName => "Faster Punch";

		public override void Init()
		{
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Expected O, but got Unknown
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Expected O, but got Unknown
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Expected O, but got Unknown
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Expected O, but got Unknown
			SceneManager.sceneLoaded += delegate(Scene scene, LoadSceneMode mode)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_0002: Invalid comparison between Unknown and I4
				if ((int)mode != 1)
				{
					currentlyBanned = false;
				}
			};
			BoolField standardEnabled = ConfigManager.StandardEnabled;
			object obj = <>c.<>9__5_1;
			if (obj == null)
			{
				BoolValueChangeEventDelegate val = delegate(BoolValueChangeEvent e)
				{
					if (e.value)
					{
						currentlyBanned = true;
					}
				};
				<>c.<>9__5_1 = val;
				obj = (object)val;
			}
			standardEnabled.onValueChange += (BoolValueChangeEventDelegate)obj;
			BoolField heavyEnabled = ConfigManager.HeavyEnabled;
			object obj2 = <>c.<>9__5_2;
			if (obj2 == null)
			{
				BoolValueChangeEventDelegate val2 = delegate(BoolValueChangeEvent e)
				{
					if (e.value)
					{
						currentlyBanned = true;
					}
				};
				<>c.<>9__5_2 = val2;
				obj2 = (object)val2;
			}
			heavyEnabled.onValueChange += (BoolValueChangeEventDelegate)obj2;
			BoolField hookEnabled = ConfigManager.HookEnabled;
			object obj3 = <>c.<>9__5_3;
			if (obj3 == null)
			{
				BoolValueChangeEventDelegate val3 = delegate(BoolValueChangeEvent e)
				{
					if (e.value)
					{
						currentlyBanned = true;
					}
				};
				<>c.<>9__5_3 = val3;
				obj3 = (object)val3;
			}
			hookEnabled.onValueChange += (BoolValueChangeEventDelegate)obj3;
			BoolField parryUpDamage = ConfigManager.ParryUpDamage;
			object obj4 = <>c.<>9__5_4;
			if (obj4 == null)
			{
				BoolValueChangeEventDelegate val4 = delegate(BoolValueChangeEvent e)
				{
					if (e.value)
					{
						currentlyBanned = true;
					}
				};
				<>c.<>9__5_4 = val4;
				obj4 = (object)val4;
			}
			parryUpDamage.onValueChange += (BoolValueChangeEventDelegate)obj4;
		}

		public override SoftBanCheckResult Check()
		{
			SoftBanCheckResult result = new SoftBanCheckResult();
			if (ConfigManager.StandardEnabled.value)
			{
				result.banned = true;
				result.message = "- Fast feedbacker is banned, disable from settings to be able to post records";
			}
			if (ConfigManager.HeavyEnabled.value)
			{
				result.banned = true;
				if (!string.IsNullOrEmpty(result.message))
				{
					result.message += "\n";
				}
				result.message += "- Fast knuckleblaster is banned, disable from settings to be able to post records";
			}
			if (ConfigManager.HookEnabled.value)
			{
				result.banned = true;
				if (!string.IsNullOrEmpty(result.message))
				{
					result.message += "\n";
				}
				result.message += "- Fast whiplash is banned, disable from settings to be able to post records";
			}
			if (ConfigManager.ParryUpDamage.value)
			{
				result.banned = true;
				if (!string.IsNullOrEmpty(result.message))
				{
					result.message += "\n";
				}
				result.message += "- Parry damage buff is banned, disable from settings to be able to post records";
			}
			if (currentlyBanned)
			{
				result.banned = true;
				if (!string.IsNullOrEmpty(result.message))
				{
					result.message += "\n";
				}
				result.message += "- You enabled the mod at least once during the level, restart the level with the mod disabled in the plugin config";
			}
			return result;
		}
	}
	[SoftBanClass]
	internal class MasqueradeDivinitySoftBan : SoftBan
	{
		public override string ModGuid => "maranara_project_prophet";

		public override string ModName => "Masquerade Divinity";

		public override SoftBanCheckResult Check()
		{
			if (ProjectProphet.gabeOn)
			{
				return new SoftBanCheckResult(banned: true, "Cannot post records on Masquerade Divinity save");
			}
			return new SoftBanCheckResult(banned: false, "");
		}
	}
	[SoftBanClass]
	internal class TimeStopperSoftBan : SoftBan
	{
		private static bool currentlyBanned;

		public override string ModGuid => "dev.galvin.timestopper";

		public override string ModName => "The Timestopper";

		private static void OnStopTime()
		{
			if (AngrySceneManager.isInCustomLevel)
			{
				currentlyBanned = true;
			}
		}

		public override void Init()
		{
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Expected O, but got Unknown
			SceneManager.sceneLoaded += delegate(Scene scene, LoadSceneMode mode)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_0002: Invalid comparison between Unknown and I4
				if ((int)mode != 1)
				{
					currentlyBanned = false;
				}
			};
			Plugin.harmony.Patch((MethodBase)typeof(Timestopper).GetMethod("StopTime", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic), (HarmonyMethod)null, new HarmonyMethod(typeof(TimeStopperSoftBan).GetMethod("OnStopTime", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		}

		public override SoftBanCheckResult Check()
		{
			if (currentlyBanned)
			{
				return new SoftBanCheckResult(banned: true, "Time was stopped while playing the level!");
			}
			return new SoftBanCheckResult();
		}
	}
	[SoftBanClass]
	internal class TimeStopSoftBan : SoftBan
	{
		private static bool currentlyBanned;

		public override string ModGuid => "com.banana.timestop";

		public override string ModName => "TimeStop";

		private static void OnStopTime()
		{
			if (AngrySceneManager.isInCustomLevel && Main.IsActive)
			{
				currentlyBanned = true;
			}
		}

		public override void Init()
		{
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Expected O, but got Unknown
			SceneManager.sceneLoaded += delegate(Scene scene, LoadSceneMode mode)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_0002: Invalid comparison between Unknown and I4
				if ((int)mode != 1)
				{
					currentlyBanned = Main.IsActive;
				}
			};
			Plugin.harmony.Patch((MethodBase)typeof(Main).GetMethod("ToggleTimeStop", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic), (HarmonyMethod)null, new HarmonyMethod(typeof(TimeStopSoftBan).GetMethod("OnStopTime", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		}

		public override SoftBanCheckResult Check()
		{
			if (currentlyBanned)
			{
				return new SoftBanCheckResult(banned: true, "Time was stopped while playing the level!");
			}
			return new SoftBanCheckResult();
		}
	}
	[SoftBanClass]
	internal class UltraCoinsSoftBan : SoftBan
	{
		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static UnityAction<Scene, LoadSceneMode> <>9__5_0;

			public static BoolValueChangeEventDelegate <>9__5_1;

			internal void <Init>b__5_0(Scene scene, LoadSceneMode mode)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_0002: Invalid comparison between Unknown and I4
				if ((int)mode != 1)
				{
					currentlyBanned = false;
				}
			}

			internal void <Init>b__5_1(BoolValueChangeEvent e)
			{
				if (e.value)
				{
					currentlyBanned = true;
				}
			}
		}

		private static bool currentlyBanned;

		public override string ModGuid => "ironfarm.uk.uc";

		public override string ModName => "UltraCoins";

		public override void Init()
		{
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Expected O, but got Unknown
			SceneManager.sceneLoaded += delegate(Scene scene, LoadSceneMode mode)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_0002: Invalid comparison between Unknown and I4
				if ((int)mode != 1)
				{
					currentlyBanned = false;
				}
			};
			BoolField isEnabled = ConfigManager.isEnabled;
			object obj = <>c.<>9__5_1;
			if (obj == null)
			{
				BoolValueChangeEventDelegate val = delegate(BoolValueChangeEvent e)
				{
					if (e.value)
					{
						currentlyBanned = true;
					}
				};
				<>c.<>9__5_1 = val;
				obj = (object)val;
			}
			isEnabled.onValueChange += (BoolValueChangeEventDelegate)obj;
		}

		public override SoftBanCheckResult Check()
		{
			if (currentlyBanned)
			{
				return new SoftBanCheckResult(banned: true, "UltraCoins was enabled while playing the level. Restart the level while UltraCoins is disabled in the config.");
			}
			if (ConfigManager.isEnabled.value)
			{
				return new SoftBanCheckResult(banned: true, "UltraCoins was enabled while playing the level. Restart the level while UltraCoins is disabled in the config.");
			}
			return new SoftBanCheckResult();
		}
	}
	[SoftBanClass]
	internal class UltrapainSoftBan : SoftBan
	{
		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static UnityAction<Scene, LoadSceneMode> <>9__6_0;

			public static BoolValueChangeEventDelegate <>9__6_1;

			internal void <Init>b__6_0(Scene scene, LoadSceneMode mode)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_0002: Invalid comparison between Unknown and I4
				if ((int)mode != 1)
				{
					currentlyBanned = false;
				}
			}

			internal void <Init>b__6_1(BoolValueChangeEvent e)
			{
				if (e.value)
				{
					currentlyBanned = true;
				}
			}
		}

		private static BoolField globalDifficultySwitch;

		private static bool currentlyBanned;

		public override string ModGuid => "com.eternalUnion.ultraPain";

		public override string ModName => "UltraPain";

		public override void Init()
		{
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Expected O, but got Unknown
			SceneManager.sceneLoaded += delegate(Scene scene, LoadSceneMode mode)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_0002: Invalid comparison between Unknown and I4
				if ((int)mode != 1)
				{
					currentlyBanned = false;
				}
			};
			PluginConfigurator config = PluginConfiguratorController.GetConfig("com.eternalUnion.ultraPain");
			if (config != null)
			{
				ConfigField obj = config.rootPanel["globalDifficultySwitch"];
				globalDifficultySwitch = (BoolField)(object)((obj is BoolField) ? obj : null);
			}
			BoolField obj2 = globalDifficultySwitch;
			object obj3 = <>c.<>9__6_1;
			if (obj3 == null)
			{
				BoolValueChangeEventDelegate val = delegate(BoolValueChangeEvent e)
				{
					if (e.value)
					{
						currentlyBanned = true;
					}
				};
				<>c.<>9__6_1 = val;
				obj3 = (object)val;
			}
			obj2.onValueChange += (BoolValueChangeEventDelegate)obj3;
		}

		public override SoftBanCheckResult Check()
		{
			if (globalDifficultySwitch == null)
			{
				PluginConfigurator config = PluginConfiguratorController.GetConfig("com.eternalUnion.ultraPain");
				if (config != null)
				{
					ConfigField obj = config.rootPanel["globalDifficultySwitch"];
					globalDifficultySwitch = (BoolField)(object)((obj is BoolField) ? obj : null);
				}
			}
			if (Plugin.ultrapainDifficulty || (globalDifficultySwitch != null && globalDifficultySwitch.value))
			{
				return new SoftBanCheckResult(banned: true, "Ultrapain is not allowed in the leaderboards, turn off global difficulty and switch to other difficulties to be able to post records");
			}
			if (currentlyBanned)
			{
				return new SoftBanCheckResult(banned: true, "Ultrapain global difficulty tweaks were enabled, restart the level with the global difficulty tweaks turned off");
			}
			return new SoftBanCheckResult();
		}
	}
	[SoftBanClass]
	internal class UnityExplorerSoftBan : SoftBan
	{
		private static bool currentlyBanned;

		public override string ModGuid => "com.sinai.unityexplorer";

		public override string ModName => "Unity Explorer";

		internal static void AngryClassFilterPatch(List<object> __result)
		{
			Assembly thisAssembly = Assembly.GetExecutingAssembly();
			__result.RemoveAll(delegate(object o)
			{
				if (!(o is Type type))
				{
					return false;
				}
				return (type.Assembly == thisAssembly) ? true : false;
			});
		}

		internal static void OnShowUI(bool value)
		{
			if (value && AngrySceneManager.isInCustomLevel)
			{
				currentlyBanned = true;
			}
		}

		public override void Init()
		{
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Expected O, but got Unknown
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Expected O, but got Unknown
			try
			{
				SceneManager.sceneLoaded += delegate(Scene scene, LoadSceneMode mode)
				{
					//IL_0000: Unknown result type (might be due to invalid IL or missing references)
					//IL_0002: Invalid comparison between Unknown and I4
					if ((int)mode != 1 && AngrySceneManager.isInCustomLevel)
					{
						currentlyBanned = UIManager.ShowMenu;
					}
				};
				Plugin.harmony.Patch((MethodBase)typeof(SearchProvider).GetMethod("ClassSearch", BindingFlags.Static | BindingFlags.NonPublic), (HarmonyMethod)null, new HarmonyMethod(typeof(UnityExplorerSoftBan).GetMethod("AngryClassFilterPatch", BindingFlags.Static | BindingFlags.NonPublic)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				Plugin.harmony.Patch((MethodBase)typeof(UIManager).GetProperty("ShowMenu", BindingFlags.Static | BindingFlags.Public).SetMethod, (HarmonyMethod)null, new HarmonyMethod(typeof(UnityExplorerSoftBan).GetMethod("OnShowUI", BindingFlags.Static | BindingFlags.NonPublic)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			}
			catch (Exception ex)
			{
				Plugin.logger.LogError((object)ex);
			}
		}

		public override SoftBanCheckResult Check()
		{
			if (currentlyBanned)
			{
				return new SoftBanCheckResult(banned: true, "Cannot post to leaderboards once Unity Explorer window is opened. Close the window and complete the level without opening UE again to post a record.");
			}
			return new SoftBanCheckResult();
		}
	}
	[SoftBanClass]
	internal class WipFixHardBan : SoftBan
	{
		public override string ModGuid => "maranara_whipfix";

		public override string ModName => "Whiplash buff";

		public override SoftBanCheckResult Check()
		{
			return new SoftBanCheckResult(banned: true, "This mod is not allowed in the leaderboards, unload to be able to post records");
		}
	}
}
namespace AngryLevelLoader.Fields
{
	internal class BundleSortField : CustomConfigField
	{
		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static UnityAction <>9__13_1;

			public static UnityAction <>9__13_2;

			public static UnityAction <>9__13_3;

			public static UnityAction <>9__13_4;

			internal void <OnCreateUI>b__13_1()
			{
				ConfigManager.bundleSortingMode.value = ConfigManager.BundleSorting.Alphabetically;
				ConfigManager.bundleSortingMode.TriggerPostValueChangeEvent();
			}

			internal void <OnCreateUI>b__13_2()
			{
				ConfigManager.bundleSortingMode.value = ConfigManager.BundleSorting.Author;
				ConfigManager.bundleSortingMode.TriggerPostValueChangeEvent();
			}

			internal void <OnCreateUI>b__13_3()
			{
				ConfigManager.bundleSortingMode.value = ConfigManager.BundleSorting.LastUpdate;
				ConfigManager.bundleSortingMode.TriggerPostValueChangeEvent();
			}

			internal void <OnCreateUI>b__13_4()
			{
				ConfigManager.bundleSortingMode.value = ConfigManager.BundleSorting.LastPlayed;
				ConfigManager.bundleSortingMode.TriggerPostValueChangeEvent();
			}
		}

		public const string ASSET_PATH = "AngryLevelLoader/Fields/BundleSortField.prefab";

		private RectTransform fieldUi;

		private AngryBundleSortFieldComponent currentUi;

		private bool _sortFavourites;

		private ConfigManager.BundleSorting _sortingMode;

		private bool inited;

		private bool SortFavourites
		{
			get
			{
				return _sortFavourites;
			}
			set
			{
				_sortFavourites = value;
				if ((Object)(object)currentUi != (Object)null)
				{
					currentUi.favSortIcon.sprite = (_sortFavourites ? AssetManager.favouriteSelected : AssetManager.favouriteUnselected);
				}
			}
		}

		private ConfigManager.BundleSorting SortingMode
		{
			get
			{
				return _sortingMode;
			}
			set
			{
				_sortingMode = value;
				if ((Object)(object)currentUi != (Object)null)
				{
					switch (_sortingMode)
					{
					case ConfigManager.BundleSorting.Alphabetically:
						currentUi.SetButtonSelected(currentUi.nameButton);
						break;
					case ConfigManager.BundleSorting.Author:
						currentUi.SetButtonSelected(currentUi.authorButton);
						break;
					case ConfigManager.BundleSorting.LastUpdate:
						currentUi.SetButtonSelected(currentUi.lastUpdateButton);
						break;
					case ConfigManager.BundleSorting.LastPlayed:
						currentUi.SetButtonSelected(currentUi.lastPlayedButton);
						break;
					}
				}
			}
		}

		public BundleSortField(ConfigPanel parentPanel)
			: base(parentPanel, 600f, 40f)
		{
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Expected O, but got Unknown
			inited = true;
			SortFavourites = ConfigManager.bundleFavSort.value;
			SortingMode = ConfigManager.bundleSortingMode.value;
			ConfigManager.InitializeConfig();
			ConfigManager.bundleFavSort.postValueChangeEvent += (PostBoolValueChangeEvent)delegate(bool fav)
			{
				SortFavourites = fav;
			};
			ConfigManager.bundleSortingMode.postValueChangeEvent += delegate(ConfigManager.BundleSorting sortMode)
			{
				SortingMode = sortMode;
			};
			if ((Object)(object)fieldUi != (Object)null)
			{
				((CustomConfigField)this).OnCreateUI(fieldUi);
			}
		}

		public override void OnCreateUI(RectTransform fieldUI)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: 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_0095: Expected O, but got Unknown
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Expected O, but got Unknown
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: 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)
			//IL_012c: Expected O, but got Unknown
			//IL_0155: Unknown result type (might be due to invalid IL or missing references)
			//IL_015a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0160: Expected O, but got Unknown
			fieldUi = fieldUI;
			if (!inited)
			{
				return;
			}
			currentUi = Addressables.InstantiateAsync((object)"AngryLevelLoader/Fields/BundleSortField.prefab", ((Component)fieldUI).transform, false, true).WaitForCompletion().GetComponent<AngryBundleSortFieldComponent>();
			((Component)currentUi).GetComponent<RectTransform>().anchoredPosition = new Vector2(0f, 0f);
			SortFavourites = ConfigManager.bundleFavSort.value;
			SortingMode = ConfigManager.bundleSortingMode.value;
			((UnityEvent)currentUi.favSortButton.onClick).AddListener((UnityAction)delegate
			{
				ConfigManager.bundleFavSort.value = !SortFavourites;
				ConfigManager.bundleFavSort.TriggerPostValueChangeEvent();
			});
			ButtonClickedEvent onClick = currentUi.nameButton.onClick;
			object obj = <>c.<>9__13_1;
			if (obj == null)
			{
				UnityAction val = delegate
				{
					ConfigManager.bundleSortingMode.value = ConfigManager.BundleSorting.Alphabetically;
					ConfigManager.bundleSortingMode.TriggerPostValueChangeEvent();
				};
				<>c.<>9__13_1 = val;
				obj = (object)val;
			}
			((UnityEvent)onClick).AddListener((UnityAction)obj);
			ButtonClickedEvent onClick2 = currentUi.authorButton.onClick;
			object obj2 = <>c.<>9__13_2;
			if (obj2 == null)
			{
				UnityAction val2 = delegate
				{
					ConfigManager.bundleSortingMode.value = ConfigManager.BundleSorting.Author;
					ConfigManager.bundleSortingMode.TriggerPostValueChangeEvent();
				};
				<>c.<>9__13_2 = val2;
				obj2 = (object)val2;
			}
			((UnityEvent)onClick2).AddListener((UnityAction)obj2);
			ButtonClickedEvent onClick3 = currentUi.lastUpdateButton.onClick;
			object obj3 = <>c.<>9__13_3;
			if (obj3 == null)
			{
				UnityAction val3 = delegate
				{
					ConfigManager.bundleSortingMode.value = ConfigManager.BundleSorting.LastUpdate;
					ConfigManager.bundleSortingMode.TriggerPostValueChangeEvent();
				};
				<>c.<>9__13_3 = val3;
				obj3 = (object)val3;
			}
			((UnityEvent)onClick3).AddListener((UnityAction)obj3);
			ButtonClickedEvent onClick4 = currentUi.lastPlayedButton.onClick;
			object obj4 = <>c.<>9__13_4;
			if (obj4 == null)
			{
				UnityAction val4 = delegate
				{
					ConfigManager.bundleSortingMode.value = ConfigManager.BundleSorting.LastPlayed;
					ConfigManager.bundleSortingMode.TriggerPostValueChangeEvent();
				};
				<>c.<>9__13_4 = val4;
				obj4 = (object)val4;
			}
			((UnityEvent)onClick4).AddListener((UnityAction)obj4);
		}
	}
	internal class ConfigPanelForBundles : ConfigPanel
	{
		private class HideOnDisable : MonoBehaviour
		{
			private void OnDisable()
			{
				((Component)this).gameObject.SetActive(false);
			}
		}

		private class ConditionalHideOnDisable : MonoBehaviour
		{
			public Func<bool> condition;

			private void OnDisable()
			{
				if (condition != null && condition())
				{
					((Component)this).gameObject.SetActive(false);
				}
			}
		}

		private const string ASSET_PATH_FAV_BUTTON = "AngryLevelLoader/Fields/BundlePanelPrefabs/FavButton.prefab";

		private const string ASSET_PATH_RANK_ICON = "AngryLevelLoader/Fields/BundlePanelPrefabs/RankIcon.prefab";

		private const string ASSET_PATH_DELETE_BUTTON = "AngryLevelLoader/Fields/BundlePanelPrefabs/DeleteButton.prefab";

		public readonly BundleContainer callback;

		protected Button favButton;

		protected Image favIcon;

		protected Text rank;

		protected Image rankBg;

		protected Button deleteButton;

		private bool _favourite;

		private string _rankText = " ";

		private Color _rankTextColor = Color.white;

		private Color _rankBgColor = Color.white;

		private bool _fillBgCenter;

		private bool _forceHidden;

		private bool _hidden;

		public bool Favourite
		{
			get
			{
				return _favourite;
			}
			set
			{
				_favourite = value;
				if ((Object)(object)favIcon != (Object)null)
				{
					favIcon.sprite = (_favourite ? AssetManager.favouriteSelected : AssetManager.favouriteUnselected);
					if (_favourite)
					{
						((Component)favButton).gameObject.SetActive(true);
					}
				}
			}
		}

		public string rankText
		{
			get
			{
				return _rankText;
			}
			set
			{
				_rankText = value;
				if ((Object)(object)rank != (Object)null)
				{
					rank.text = _rankText;
				}
			}
		}

		public Color rankTextColor
		{
			get
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				return _rankTextColor;
			}
			set
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_001c: Unknown result type (might be due to invalid IL or missing references)
				_rankTextColor = value;
				if ((Object)(object)rank != (Object)null)
				{
					((Graphic)rank).color = _rankTextColor;
				}
			}
		}

		public Color rankBgColor
		{
			get
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				return _rankBgColor;
			}
			set
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_001b: Unknown result type (might be due to invalid IL or missing references)
				_rankBgColor = value;
				if ((Object)(object)rankBg != (Object)null)
				{
					((Graphic)rankBg).color = value;
				}
			}
		}

		public bool fillBgCenter
		{
			get
			{
				return _fillBgCenter;
			}
			set
			{
				_fillBgCenter = value;
				if (!((Object)(object)rankBg == (Object)null))
				{
					rankBg.fillCenter = value;
				}
			}
		}

		public bool forceHidden
		{
			get
			{
				return _forceHidden;
			}
			set
			{
				_forceHidden = value;
				((ConfigPanel)this).hidden = forceHidden || _hidden;
			}
		}

		public override bool hidden
		{
			get
			{
				return ((ConfigPanel)this).hidden;
			}
			set
			{
				_hidden = value;
				((ConfigPanel)this).hidden = forceHidden || _hidden;
			}
		}

		public ConfigPanelForBundles(BundleContainer creator, ConfigPanel parentPanel, string name, string guid)
			: base(parentPanel, name, guid, (PanelFieldType)2)
		{
			//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_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)
			callback = creator;
		}

		public override GameObject CreateUI(Transform content)
		{
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: 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_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_0147: Unknown result type (might be due to invalid IL or missing references)
			//IL_0151: Expected O, but got Unknown
			//IL_0162: Unknown result type (might be due to invalid IL or missing references)
			//IL_0167: Unknown result type (might be due to invalid IL or missing references)
			//IL_0171: Unknown result type (might be due to invalid IL or missing references)
			//IL_0176: Unknown result type (might be due to invalid IL or missing references)
			//IL_0191: Unknown result type (might be due to invalid IL or missing references)
			//IL_0196: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0229: Unknown result type (might be due to invalid IL or missing references)
			//IL_0257: Unknown result type (might be due to invalid IL or missing references)
			//IL_025c: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02da: Expected O, but got Unknown
			((ConfigPanel)this).CreateUI(content);
			if ((Object)(object)base.currentMenu != (Object)null)
			{
				RectTransform component = ((Component)base.currentMenu.button).GetComponent<RectTransform>();
				Vector2 val = default(Vector2);
				((Vector2)(ref val))..ctor(1f, 0.5f);
				component.anchorMax = val;
				component.anchorMin = val;
				component.pivot = new Vector2(1f, 0.5f);
				component.anchoredPosition = new Vector2(-150f, 0f);
				favButton = Addressables.InstantiateAsync((object)"AngryLevelLoader/Fields/BundlePanelPrefabs/FavButton.prefab", ((Component)base.currentMenu).transform, false, true).WaitForCompletion().GetComponentInChildren<Button>();
				favIcon = ((Component)favButton).gameObject.GetComponent<Image>();
				favIcon.sprite = (Favourite ? AssetManager.favouriteSelected : AssetManager.favouriteUnselected);
				AngryUIUtils.AddMouseEvents(((Component)base.currentMenu).gameObject, favButton, delegate
				{
					((Component)favButton).gameObject.SetActive(true);
				}, delegate
				{
					((Component)favButton).gameObject.SetActive(Favourite);
				});
				((Component)favButton).gameObject.SetActive(Favourite);
				((Component)favButton).gameObject.AddComponent<ConditionalHideOnDisable>().condition = () => !Favourite;
				((UnityEvent)favButton.onClick).AddListener((UnityAction)delegate
				{
					Favourite = !Favourite;
					callback.Favourite = Favourite;
				});
				RectTransform component2 = ((Component)base.currentMenu.icon).GetComponent<RectTransform>();
				component2.anchoredPosition += Vector2.right * 15f;
				RectTransform component3 = ((Component)base.currentMenu.name).GetComponent<RectTransform>();
				component3.anchoredPosition += Vector2.right * 15f;
				rank = Addressables.InstantiateAsync((object)"AngryLevelLoader/Fields/BundlePanelPrefabs/RankIcon.prefab", ((Component)base.currentMenu).transform, false, true).WaitForCompletion().GetComponentInChildren<Text>();
				rank.text = _rankText;
				((Graphic)rank).color = _rankTextColor;
				rank.alignByGeometry = true;
				rankBg = ((Component)((Component)rank).transform.parent).GetComponent<Image>();
				((Graphic)rankBg).color = _rankBgColor;
				rankBg.fillCenter = _fillBgCenter;
				deleteButton = Addressables.InstantiateAsync((object)"AngryLevelLoader/Fields/BundlePanelPrefabs/DeleteButton.prefab", ((Component)base.currentMenu).transform, false, true).WaitForCompletion().GetComponent<Button>();
				AngryUIUtils.AddMouseEvents(((Component)base.currentMenu).gameObject, deleteButton, delegate
				{
					((Component)deleteButton).gameObject.SetActive(true);
				}, delegate
				{
					((Component)deleteButton).gameObject.SetActive(false);
				});
				((Component)deleteButton).gameObject.SetActive(false);
				((Component)deleteButton).gameObject.AddComponent<HideOnDisable>();
				((UnityEvent)deleteButton.onClick).AddListener((UnityAction)delegate
				{
					if (callback != null)
					{
						callback.OpenDeletePanel();
					}
					else
					{
						Plugin.logger.LogError((object)"Delete bundle button pressed but callback is null");
					}
				});
				return ((Component)base.currentMenu).gameObject;
			}
			return null;
		}
	}
	internal class DifficultyField : CustomConfigField
	{
		public const string ASSET_PATH = "AngryLevelLoader/Fields/DifficultyField.prefab";

		private bool inited;

		private RectTransform fieldUi;

		private AngryDifficultyFieldComponent currentUi;

		private StringListField internalDifficultyField;

		private bool _difficultyInteractable = true;

		public PostStringListValueChangeEvent postDifficultyChange;

		private StringListField internalGamemodeField;

		private bool _gamemodeInteractable = true;

		public PostStringListValueChangeEvent postGamemodeChange;

		public string difficultyListValue
		{
			get
			{
				return internalDifficultyField.value;
			}
			set
			{
				internalDifficultyField.value = value;
				if ((Object)(object)currentUi != (Object)null)
				{
					currentUi.difficultyList.SetValueWithoutNotify(internalDifficultyField.valueIndex);
				}
			}
		}

		public int difficultyListValueIndex
		{
			get
			{
				return internalDifficultyField.valueIndex;
			}
			set
			{
				internalDifficultyField.valueIndex = value;
				if ((Object)(object)currentUi != (Object)null)
				{
					currentUi.difficultyList.SetValueWithoutNotify(internalDifficultyField.valueIndex);
				}
			}
		}

		public bool difficultyInteractable
		{
			get
			{
				return _difficultyInteractable;
			}
			set
			{
				_difficultyInteractable = value;
				if ((Object)(object)currentUi != (Object)null)
				{
					((Selectable)currentUi.difficultyList).interactable = value;
				}
			}
		}

		public string gamemodeListValue
		{
			get
			{
				return internalGamemodeField.value;
			}
			set
			{
				internalGamemodeField.value = value;
				if ((Object)(object)currentUi != (Object)null)
				{
					currentUi.gamemodeList.SetValueWithoutNotify(internalGamemodeField.valueIndex);
				}
			}
		}

		public int gamemodeListValueIndex
		{
			get
			{
				return internalGamemodeField.valueIndex;
			}
			set
			{
				internalGamemodeField.valueIndex = value;
				if ((Object)(object)currentUi != (Object)null)
				{
					currentUi.gamemodeList.SetValueWithoutNotify(internalGamemodeField.valueIndex);
				}
			}
		}

		public bool gamemodeInteractable
		{
			get
			{
				return _gamemodeInteractable;
			}
			set
			{
				_gamemodeInteractable = value;
				if ((Object)(object)currentUi != (Object)null)
				{
					((Selectable)currentUi.gamemodeList).interactable = value;
				}
			}
		}

		public void ForceSetDifficultyUI(int index)
		{
			if ((Object)(object)currentUi != (Object)null)
			{
				currentUi.difficultyList.SetValueWithoutNotify(index);
			}
		}

		public void TriggerPostDifficultyChangeEvent()
		{
			postDifficultyChange.Invoke(internalDifficultyField.value, internalDifficultyField.valueIndex);
		}

		public void TriggerPostGamemodeChangeEvent()
		{
			postGamemodeChange.Invoke(internalGamemodeField.value, internalGamemodeField.valueIndex);
		}

		public override void OnHiddenChange(bool selfHidden, bool hierarchyHidden)
		{
			if ((Object)(object)currentUi != (Object)null)
			{
				((Component)currentUi).gameObject.SetActive(!hierarchyHidden);
			}
		}

		public override void OnInteractableChange(bool selfInteractable, bool hierarchyInteractable)
		{
			if ((Object)(object)currentUi != (Object)null)
			{
				currentUi.group.interactable = hierarchyInteractable;
			}
		}

		public DifficultyField(ConfigPanel rootPanel)
			: base(rootPanel)
		{
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Expected O, but got Unknown
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Expected O, but got Unknown
			inited = true;
			AngryDifficultyManager.Init();
			internalDifficultyField = new StringListField(InternalConfigManager.internalConfig.rootPanel, "Difficulty", "difficultySelect", AngryDifficultyManager.DifficultyNames, AngryDifficultyManager.VIOLENT.name);
			internalGamemodeField = new StringListField(InternalConfigManager.internalConfig.rootPanel, "Gamemode", "gamemode", (IEnumerable<string>)AngryGamemodeManager.gamemodeList, "None");
			if ((Object)(object)fieldUi != (Object)null)
			{
				((CustomConfigField)this).OnCreateUI(fieldUi);
			}
		}

		public override void OnCreateUI(RectTransform fieldUI)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			fieldUi = fieldUI;
			if (!inited)
			{
				return;
			}
			currentUi = Addressables.InstantiateAsync((object)"AngryLevelLoader/Fields/DifficultyField.prefab", ((Component)fieldUI).transform, false, true).WaitForCompletion().GetComponent<AngryDifficultyFieldComponent>();
			RectTransform component = ((Component)currentUi).GetComponent<RectTransform>();
			fieldUI.sizeDelta = component.sizeDelta;
			component.pivot = new Vector2(0f, 1f);
			component.anchorMin = new Vector2(0f, 1f);
			component.anchorMax = new Vector2(0f, 1f);
			component.anchoredPosition = new Vector2(0f, 0f);
			currentUi.difficultyList.AddOptions(AngryDifficultyManager.DifficultyNames.ToList());
			currentUi.gamemodeList.AddOptions(AngryGamemodeManager.gamemodeList.ToList());
			currentUi.difficultyList.value = internalDifficultyField.valueIndex;
			currentUi.gamemodeList.value = internalGamemodeField.valueIndex;
			((UnityEvent<int>)(object)currentUi.difficultyList.onValueChanged).AddListener((UnityAction<int>)delegate(int newIndex)
			{
				internalDifficultyField.valueIndex = newIndex;
				if (postDifficultyChange != null)
				{
					postDifficultyChange.Invoke(internalDifficultyField.value, internalDifficultyField.valueIndex);
				}
			});
			((UnityEvent<int>)(object)currentUi.gamemodeList.onValueChanged).AddListener((UnityAction<int>)delegate(int newIndex)
			{
				internalGamemodeField.valueIndex = newIndex;
				if (postGamemodeChange != null)
				{
					postGamemodeChange.Invoke(internalGamemodeField.value, internalGamemodeField.valueIndex);
				}
			});
			((Selectable)currentUi.difficultyList).interactable = _difficultyInteractable;
			((Selectable)currentUi.gamemodeList).interactable = _gamemodeInteractable;
			currentUi.group.interactable = ((CustomConfigField)this).hierarchyInteractable;
			((Component)currentUi).gameObject.SetActive(!((CustomConfigField)this).hierarchyHidden);
		}
	}
	internal class FolderButtonField : CustomConfigField, IEnumerable<BundleContainer>, IEnumerable
	{
		[CompilerGenerated]
		private sealed class <FolderEnumerator>d__0 : IEnumerator<BundleContainer>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private BundleContainer <>2__current;

			public FolderButtonField folder;

			public FolderButtonField <>4__this;

			private List<BundleContainer>.Enumerator <>7__wrap1;

			private List<FolderButtonField>.Enumerator <>7__wrap2;

			private IEnumerator<BundleContainer> <subfolderEnumerator>5__4;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				switch (<>1__state)
				{
				case -3:
				case 1:
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
					break;
				case -4:
				case 2:
					try
					{
					}
					finally
					{
						<>m__Finally2();
					}
					break;
				}
				<>7__wrap1 = default(List<BundleContainer>.Enumerator);
				<>7__wrap2 = default(List<FolderButtonField>.Enumerator);
				<subfolderEnumerator>5__4 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				try
				{
					int num = <>1__state;
					FolderButtonField folderButtonField = <>4__this;
					switch (num)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<>7__wrap1 = folder.bundles.GetEnumerator();
						<>1__state = -3;
						goto IL_0077;
					case 1:
						<>1__state = -3;
						goto IL_0077;
					case 2:
						{
							<>1__state = -4;
							goto IL_00f7;
						}
						IL_0077:
						if (<>7__wrap1.MoveNext())
						{
							BundleContainer current = <>7__wrap1.Current;
							<>2__current = current;
							<>1__state = 1;
							return true;
						}
						<>m__Finally1();
						<>7__wrap1 = default(List<BundleContainer>.Enumerator);
						<>7__wrap2 = folder.folders.GetEnumerator();
						<>1__state = -4;
						goto IL_010b;
						IL_010b:
						if (<>7__wrap2.MoveNext())
						{
							FolderButtonField current2 = <>7__wrap2.Current;
							<subfolderEnumerator>5__4 = folderButtonField.FolderEnumerator(current2);
							goto IL_00f7;
						}
						<>m__Finally2();
						<>7__wrap2 = default(List<FolderButtonField>.Enumerator);
						return false;
						IL_00f7:
						if (<subfolderEnumerator>5__4.MoveNext())
						{
							<>2__current = <subfolderEnumerator>5__4.Current;
							<>1__state = 2;
							return true;
						}
						<subfolderEnumerator>5__4 = null;
						goto IL_010b;
					}
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

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

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

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

		internal readonly string folderName;

		internal readonly FolderButtonField parent;

		private readonly List<FolderButtonField> folders = new List<FolderButtonField>();

		internal readonly List<BundleContainer> bundles = new List<BundleContainer>();

		private const string ASSET_PATH = "AngryLevelLoader/Fields/FolderButtonField.prefab";

		private const int ICON_SIZE = 128;

		private const int ICON_GAP = 8;

		private static RenderTexture rt = new RenderTexture(128, 128, 24);

		public RectTransform currentContainer;

		private AngryFolderButtonComponent currentUi;

		private static Texture2D blankIcon = null;

		private Texture2D icon;

		public UnityEvent onPressed = new UnityEvent();

		private readonly bool _inited;

		[IteratorStateMachine(typeof(<FolderEnumerator>d__0))]
		private IEnumerator<BundleContainer> FolderEnumerator(FolderButtonField folder)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <FolderEnumerator>d__0(0)
			{
				<>4__this = this,
				folder = folder
			};
		}

		internal IEnumerable<FolderButtonField> GetAllSubfolders()
		{
			return folders;
		}

		internal FolderButtonField GetOrCreateFolder(string subfolderName)
		{
			FolderButtonField folderButtonField = folders.FirstOrDefault((FolderButtonField f) => f.folderName == subfolderName);
			if (folderButtonField == null)
			{
				folderButtonField = new FolderButtonField(subfolderName, this);
				folders.Add(folderButtonField);
			}
			return folderButtonField;
		}

		public string GetRelativeFolderPath()
		{
			if (parent == null)
			{
				return "/";
			}
			StringBuilder stringBuilder = new StringBuilder();
			FolderButtonField folderButtonField = this;
			while (folderButtonField != null && folderButtonField.parent != null)
			{
				stringBuilder.Insert(0, '/');
				stringBuilder.Insert(1, folderButtonField.folderName);
				folderButtonField = folderButtonField.parent;
			}
			return stringBuilder.ToString();
		}

		public string GetAbsoluteFolderPath(string prefixPath)
		{
			List<FolderButtonField> list = new List<FolderButtonField>();
			FolderButtonField folderButtonField = this;
			while (folderButtonField != null && folderButtonField != AngryBundleList.rootFolder)
			{
				list.Add(folderButtonField);
				folderButtonField = folderButtonField.parent;
			}
			list.Reverse();
			string text = prefixPath;
			foreach (FolderButtonField item in list)
			{
				text = Path.Combine(text, item.folderName);
			}
			return text;
		}

		public void CreateIcon(IEnumerable<BundleContainer> bundles)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Expected O, but got Unknown
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Expected O, but got Unknown
			//IL_01c0: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)blankIcon == (Object)null)
			{
				blankIcon = new Texture2D(264, 264);
				((Texture)blankIcon).filterMode = (FilterMode)0;
				for (int i = 0; i < ((Texture)blankIcon).width; i++)
				{
					for (int j = 0; j < ((Texture)blankIcon).height; j++)
					{
						blankIcon.SetPixel(i, j, Color.black);
					}
				}
				blankIcon.Apply();
			}
			if ((Object)(object)icon != (Object)null)
			{
				Object.Destroy((Object)(object)icon);
			}
			icon = Object.Instantiate<Texture2D>(blankIcon);
			List<Texture2D> list = new List<Texture2D>();
			foreach (BundleContainer bundle in bundles)
			{
				string path = Path.Combine(Plugin.tempFolderPath, bundle.bundleGuid, "icon.png");
				if (File.Exists(path))
				{
					Texture2D val = new Texture2D(1, 1);
					ImageConversion.LoadImage(val, File.ReadAllBytes(path));
					list.Add(val);
					if (list.Count == 4)
					{
						break;
					}
				}
			}
			Stack<(int, int)> stack = new Stack<(int, int)>();
			stack.Push((136, 0));
			stack.Push((0, 0));
			stack.Push((136, 136));
			stack.Push((0, 136));
			RenderTexture active = RenderTexture.active;
			RenderTexture.active = rt;
			foreach (Texture2D item in list)
			{
				var (num, num2) = stack.Pop();
				Graphics.Blit((Texture)(object)item, rt);
				icon.ReadPixels(new Rect(0f, 0f, 128f, 128f), num, num2);
				Object.Destroy((Object)(object)item);
			}
			RenderTexture.active = active;
			icon.Apply();
			if ((Object)(object)currentUi != (Object)null)
			{
				currentUi.folderIcon.texture = (Texture)(object)icon;
			}
		}

		public void CreateIcon(string imagePath)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Expected O, but got Unknown
			if ((Object)(object)icon != (Object)null)
			{
				Object.Destroy((Object)(object)icon);
			}
			icon = new Texture2D(2, 2);
			ImageConversion.LoadImage(icon, File.ReadAllBytes(imagePath));
			if ((Object)(object)currentUi != (Object)null)
			{
				currentUi.folderIcon.texture = (Texture)(object)icon;
			}
		}

		public FolderButtonField(string folderName, FolderButtonField parent)
			: base((ConfigPanel)(object)ConfigManager.folderDivision)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Expected O, but got Unknown
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Expected O, but got Unknown
			_inited = true;
			this.folderName = folderName;
			this.parent = parent;
			onPressed.AddListener((UnityAction)delegate
			{
				AngryBundleList.DisplayFolder(this);
			});
			if ((Object)(object)currentContainer != (Object)null)
			{
				((CustomConfigField)this).OnCreateUI(currentContainer);
			}
			CreateIcon(Enumerable.Empty<BundleContainer>());
		}

		public override void OnCreateUI(RectTransform fieldUI)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Expected O, but got Unknown
			currentContainer = fieldUI;
			if (_inited)
			{
				GameObject val = Addressables.InstantiateAsync((object)"AngryLevelLoader/Fields/FolderButtonField.prefab", (Transform)(object)fieldUI, false, true).WaitForCompletion();
				currentUi = val.GetComponent<AngryFolderButtonComponent>();
				RectTransform component = val.GetComponent<RectTransform>();
				fieldUI.sizeDelta = component.sizeDelta;
				component.pivot = new Vector2(0f, 1f);
				component.anchorMin = new Vector2(0f, 1f);
				component.anchorMax = new Vector2(0f, 1f);
				component.anchoredPosition = new Vector2(0f, 0f);
				((TMP_Text)currentUi.folderName).text = folderName;
				((UnityEvent)currentUi.folderButton.onClick).AddListener((UnityAction)delegate
				{
					onPressed.Invoke();
				});
				currentUi.folderIcon.texture = (Texture)(object)icon;
				((Component)fieldUI).gameObject.SetActive(!((ConfigField)this).hidden && !((CustomConfigField)this).hierarchyHidden);
				((Selectable)currentUi.folderButton).interactable = ((ConfigField)this).interactable && ((CustomConfigField)this).hierarchyInteractable;
			}
		}

		public override void OnHiddenChange(bool selfHidden, bool hierarchyHidden)
		{
			if ((Object)(object)currentUi != (Object)null)
			{
				((Component)currentContainer).gameObject.SetActive(!selfHidden && !hierarchyHidden);
			}
		}

		public override void OnInteractableChange(bool selfInteractable, bool hierarchyInteractable)
		{
			if ((Object)(object)currentUi != (Object)null)
			{
				((Selectable)currentUi.folderButton).interactable = selfInteractable && hierarchyInteractable;
			}
		}

		public IEnumerator<BundleContainer> GetEnumerator()
		{
			return FolderEnumerator(this);
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return GetEnumerator();
		}
	}
	internal class LevelField : CustomConfigField
	{
		internal delegate void onLevelButtonPressDelegate();

		private const string ASSET_PATH = "AngryLevelLoader/Fields/LevelField.prefab";

		private bool inited;

		public readonly BundleContainer bundleContainer;

		public readonly string levelId;

		private string _levelName;

		private Sprite _previewImage;

		private bool _discovered = true;

		private bool _hideIfNotPlayed;

		private bool _doNotHideLevelPreviewWhenNotCompleted;

		private bool _locked;

		private bool _isSecretLevel;

		private float _time;

		private char _timeRank = '-';

		private int _kills;

		private char _killsRank = '-';

		private int _style;

		private char _styleRank = '-';

		private char _finalRank = '-';

		private string _secretsString = "";

		private bool _challengeEnabled;

		private string _challengeText = "";

		private bool _challengeDone;

		internal Action onResetStats;

		internal Action onResetSecrets;

		internal Action onResetChallenge;

		private RectTransform container;

		private AngryLevelFieldComponent currentUi;

		private static Color perfectUiColor = new Color(57f / 85f, 36f / 85f, 0.007843138f);

		private static Color perfectStatsColor = new Color(0.88235295f, 0.6039216f, 0f);

		private static Color perfectRankColor = new Color(0.94509804f, 56f / 85f, 0.03137255f);

		private static Color colorSilver = new Color(64f / 85f, 64f / 85f, 64f / 85f);

		private bool _forceHidden;

		private static GameObject lastActiveSettingsPanel = null;

		public string LevelName
		{
			get
			{
				return _levelName;
			}
			set
			{
				_levelName = value;
				if ((Object)(object)currentUi != (Object)null)
				{
					currentUi.levelHeader.text = (Locked ? "???" : _levelName);
				}
			}
		}

		public Sprite PreviewImage
		{
			get
			{
				return _previewImage;
			}
			set
			{
				_previewImage = value;
				if ((Object)(object)currentUi != (Object)null && !Locked && (PlayedBefore || DoNotHideLevelPreviewWhenNotCompleted))
				{
					currentUi.levelThumbnail.sprite = _previewImage;
				}
			}
		}

		public bool PlayedBefore => FinalRank != '-';

		public bool Discovered
		{
			get
			{
				return _discovered;
			}
			set
			{
				_discovered = value;
				((ConfigField)this).hidden = !_discovered && HideIfNotPlayed;
			}
		}

		public bool HideIfNotPlayed
		{
			get
			{
				return _hideIfNotPlayed;
			}
			set
			{
				_hideIfNotPlayed = value;
				((ConfigField)this).hidden = !Discovered && _hideIfNotPlayed;
			}
		}

		public bool DoNotHideLevelPreviewWhenNotCompleted
		{
			get
			{
				return _doNotHideLevelPreviewWhenNotCompleted;
			}
			set
			{
				_doNotHideLevelPreviewWhenNotCompleted = value;
				if ((Object)(object)currentUi != (Object)null && !Locked)
				{
					if (!PlayedBefore && !_doNotHideLevelPreviewWhenNotCompleted)
					{
						currentUi.levelThumbnail.sprite = AssetManager.notPlayedPreview;
					}
					else
					{
						currentUi.levelThumbnail.sprite = PreviewImage;
					}
				}
			}
		}

		public bool Locked
		{
			get
			{
				return _locked;
			}
			set
			{
				_locked = value;
				if (!((Object)(object)currentUi != (Object)null))
				{
					return;
				}
				if (_locked)
				{
					currentUi.levelThumbnail.sprite = AssetManager.lockedPreview;
					currentUi.levelHeader.text = "???";
					((Component)currentUi.statContainer).gameObject.SetActive(false);
					((Component)currentUi.challengeContainer).gameObject.SetActive(false);
					((Selectable)currentUi.leaderboardsButton).interactable = false;
					((Selectable)currentUi.openSettingsButton).interactable = false;
					currentUi.settingsPanel.SetActive(false);
				}
				else
				{
					currentUi.levelHeader.text = LevelName;
					if (!PlayedBefore && !DoNotHideLevelPreviewWhenNotCompleted)
					{
						currentUi.levelThumbnail.sprite = AssetManager.notPlayedPreview;
					}
					else
					{
						currentUi.levelThumbnail.sprite = PreviewImage;
					}
					((Selectable)currentUi.leaderboardsButton).interactable = true;
					((Selectable)currentUi.openSettingsButton).interactable = true;
				}
			}
		}

		public bool IsSecretLevel
		{
			get
			{
				return _isSecretLevel;
			}
			set
			{
				_isSecretLevel = value;
				if ((Object)(object)currentUi != (Object)null)
				{
					((Component)currentUi.statContainer).gameObject.SetActive(!_isSecretLevel);
					((Component)currentUi.challengeContainer).gameObject.SetActive(!_isSecretLevel);
				}
			}
		}

		public float Time
		{
			get
			{
				return _time;
			}
			set
			{
				_time = value;
				if ((Object)(object)currentUi != (Object)null)
				{
					currentUi.timeText.text = GetTimeStringFromSeconds(_time) + " " + AngryRankUtils.GetFormattedRankText(TimeRank);
				}
			}
		}

		public char TimeRank
		{
			get
			{
				return _timeRank;
			}
			set
			{
				_timeRank = value;
				if ((Object)(object)currentUi != (Object)null)
				{
					currentUi.timeText.text = GetTimeStringFromSeconds(Time) + " " + AngryRankUtils.GetFormattedRankText(_timeRank);
				}
			}
		}

		public int Kills
		{
			get
			{
				return _kills;
			}
			set
			{
				_kills = value;
				if ((Object)(object)currentUi != (Object)null)
				{
					currentUi.killText.text = $"{_kills} {AngryRankUtils.GetFormattedRankText(KillsRank)}";
				}
			}
		}

		public char KillsRank
		{
			get
			{
				return _killsRank;
			}
			set
			{
				_killsRank = value;
				if ((Object)(object)currentUi != (Object)null)
				{
					currentUi.killText.text = $"{Kills} {AngryRankUtils.GetFormattedRankText(_killsRank)}";
				}
			}
		}

		public int Style
		{
			get
			{
				return _style;
			}
			set
			{
				_style = value;
				if ((Object)(object)currentUi != (Object)null)
				{
					currentUi.styleText.text = $"{_style} {AngryRankUtils.GetFormattedRankText(StyleRank)}";
				}
			}
		}

		public char StyleRank
		{
			get
			{
				return _styleRank;
			}
			set
			{
				_styleRank = value;
				if ((Object)(object)currentUi != (Object)null)
				{
					currentUi.styleText.text = $"{Style} {AngryRankUtils.GetFormattedRankText(_styleRank)}";
				}
			}
		}

		public char FinalRank
		{
			get
			{
				return _finalRank;
			}
			set
			{
				//IL_00af: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
				//IL_0101: 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_005d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0072: Unknown result type (might be due to invalid IL or missing references)
				//IL_011e: Unknown result type (might be due to invalid IL or missing references)
				//IL_008f: Unknown result type (might be due to invalid IL or missing references)
				_finalRank = value;
				if (!((Object)(object)currentUi != (Object)null))
				{
					return;
				}
				currentUi.finalRankText.text = AngryRankUtils.GetFormattedRankText(_finalRank);
				if (_finalRank == 'P')
				{
					((Graphic)currentUi.fieldImage).color = perfectUiColor;
					((Graphic)currentUi.statContainerImage).color = perfectStatsColor;
					((Graphic)currentUi.finalRankContainerImage).color = perfectRankColor;
					Text[] headers = currentUi.headers;
					for (int i = 0; i < headers.Length; i++)
					{
						((Graphic)headers[i]).color = Color.white;
					}
				}
				else
				{
					((Graphic)currentUi.fieldImage).color = Color.black;
					((Graphic)currentUi.statContainerImage).color = new Color(0f, 0f, 0f, 0.8f);
					((Graphic)currentUi.finalRankContainerImage).color = new Color(0f, 0f, 0f, 0.8f);
					Text[] headers = currentUi.headers;
					for (int i = 0; i < headers.Length; i++)
					{
						((Graphic)headers[i]).color = colorSilver;
					}
				}
			}
		}

		public int SecretCount => SecretsString.Length;

		public string SecretsString
		{
			get
			{
				return _secretsString;
			}
			set
			{
				_secretsString = value;
				if (!((Object)(object)currentUi != (Object)null))
				{
					return;
				}
				if (SecretCount == 0)
				{
					((Component)currentUi.secretsHeader).gameObject.SetActive(false);
					((Component)currentUi.secretsText).gameObject.SetActive(false);
					currentUi.secretsIconContainer.gameObject.SetActive(false);
				}
				else if (SecretCount >= 1 && SecretCount <= 5)
				{
					((Component)currentUi.secretsHeader).gameObject.SetActive(true);
					((Component)currentUi.secretsText).gameObject.SetActive(false);
					currentUi.secretsIconContainer.gameObject.SetActive(true);
					for (int i = 0; i < SecretCount; i++)
					{
						((Component)currentUi.secretsIcons[i]).gameObject.SetActive(true);
						currentUi.secretsIcons[i].fillCenter = _secretsString[i] == 'T';
					}
					for (int j = SecretCount; j < 5; j++)
					{
						((Component)currentUi.secretsIcons[j]).gameObject.SetActive(false);
					}
				}
				else
				{
					((Component)currentUi.secretsHeader).gameObject.SetActive(true);
					((Component)currentUi.secretsText).gameObject.SetActive(true);
					currentUi.secretsIconContainer.gameObject.SetActive(false);
					currentUi.secretsText.text = $"{DiscoveredSecrets} / {SecretCount}";
					if (DiscoveredSecrets == SecretCount)
					{
						currentUi.secretsText.text = "<color=aqua>" + currentUi.secretsText.text + "</color>";
					}
				}
			}
		}

		public int DiscoveredSecrets => SecretsString.ToCharArray().Count((char c) => c == 'T');

		public bool ChallengeEnabled
		{
			get
			{
				return _challengeEnabled;
			}
			set
			{
				_challengeEnabled = value;
				if ((Object)(object)currentUi != (Object)null)
				{
					((Component)currentUi.challengeContainer).gameObject.SetActive(_challengeEnabled);
				}
			}
		}

		public string ChallengeText
		{
			get
			{
				return _challengeText;
			}
			set
			{
				_challengeText = value;
				if ((Object)(object)currentUi != (Object)null)
				{
					currentUi.challengeText.text = (ChallengeEnabled ? _challengeText : "No challenge available for the level");
				}
			}
		}

		public bool ChallengeDone
		{
			get
			{
				return _challengeDone;
			}
			set
			{
				//IL_0057: 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)
				_challengeDone = value;
				if ((Object)(object)currentUi != (Object)null)
				{
					((Graphic)currentUi.challengeContainerImage).color = (_challengeDone ? new Color(1f, 0.64705884f, 0f, 0.8f) : new Color(0f, 0f, 0f, 0.8f));
				}
			}
		}

		public bool forceHidden
		{
			get
			{
				return _forceHidden;
			}
			set
			{
				_forceHidden = value;
				((ConfigField)this).hidden = ((ConfigField)this).hidden;
			}
		}

		public override bool hidden
		{
			get
			{
				return ((CustomConfigField)this).hidden;
			}
			set
			{
				((CustomConfigField)this).hidden = value;
				if ((Object)(object)container != (Object)null)
				{
					((Component)container).gameObject.SetActive(!((CustomConfigField)this).hierarchyHidden && !forceHidden);
				}
			}
		}

		internal event onLevelButtonPressDelegate onLevelButtonPress;

		internal LevelField(ConfigPanel panel, BundleContainer parentContainer, string levelId)
			: base(panel, 600f, 170f)
		{
			bundleContainer = parentContainer;
			this.levelId = levelId;
			inited = true;
			if ((Object)(object)container != (Object)null)
			{
				((CustomConfigField)this).OnCreateUI(container);
			}
		}

		private void UpdateUI()
		{
			//IL_0309: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_03fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0425: Unknown result type (might be due to invalid IL or missing references)
			//IL_0368: Unknown result type (might be due to invalid IL or missing references)
			//IL_037d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0392: Unknown result type (might be due to invalid IL or missing references)
			//IL_0442: Unknown result type (might be due to invalid IL or missing references)
			//IL_03af: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)currentUi == (Object)null)
			{
				return;
			}
			((Component)currentUi.statContainer).gameObject.SetActive(!IsSecretLevel);
			((Component)currentUi.challengeContainer).gameObject.SetActive(!IsSecretLevel);
			currentUi.timeText.text = GetTimeStringFromSeconds(Time) + " " + AngryRankUtils.GetFormattedRankText(TimeRank);
			currentUi.killText.text = $"{Kills} {AngryRankUtils.GetFormattedRankText(KillsRank)}";
			currentUi.styleText.text = $"{Style} {AngryRankUtils.GetFormattedRankText(StyleRank)}";
			if (SecretCount == 0)
			{
				((Component)currentUi.secretsHeader).gameObject.SetActive(false);
				((Component)currentUi.secretsText).gameObject.SetActive(false);
				currentUi.secretsIconContainer.gameObject.SetActive(false);
			}
			else if (SecretCount >= 1 && SecretCount <= 5)
			{
				((Component)currentUi.secretsHeader).gameObject.SetActive(true);
				((Component)currentUi.secretsText).gameObject.SetActive(false);
				currentUi.secretsIconContainer.gameObject.SetActive(true);
				for (int i = 0; i < SecretCount; i++)
				{
					((Component)currentUi.secretsIcons[i]).gameObject.SetActive(true);
					currentUi.secretsIcons[i].fillCenter = SecretsString[i] == 'T';
				}
				for (int j = SecretCount; j < 5; j++)
				{
					((Component)currentUi.secretsIcons[j]).gameObject.SetActive(false);
				}
			}
			else
			{
				((Component)currentUi.secretsHeader).gameObject.SetActive(true);
				((Component)currentUi.secretsText).gameObject.SetActive(true);
				currentUi.secretsIconContainer.gameObject.SetActive(false);
				currentUi.secretsText.text = $"{DiscoveredSecrets} / {SecretCount}";
				if (DiscoveredSecrets == SecretCount)
				{
					currentUi.secretsText.text = "<color=aqua>" + currentUi.secretsText.text + "</color>";
				}
			}
			currentUi.finalRankText.text = AngryRankUtils.GetFormattedRankText(FinalRank);
			((Graphic)currentUi.challengeContainerImage).color = (ChallengeDone ? new Color(1f, 0.64705884f, 0f, 0.8f) : new Color(0f, 0f, 0f, 0.8f));
			((Component)currentUi.challengeContainer).gameObject.SetActive(ChallengeEnabled);
			currentUi.challengeText.text = (ChallengeEnabled ? ChallengeText : "No challenge available for the level");
			if (FinalRank == 'P')
			{
				((Graphic)currentUi.fieldImage).color = perfectUiColor;
				((Graphic)currentUi.statContainerImage).color = perfectStatsColor;
				((Graphic)currentUi.finalRankContainerImage).color = perfectRankColor;
				Text[] headers = currentUi.headers;
				for (int k = 0; k < headers.Length; k++)
				{
					((Graphic)headers[k]).color = Color.white;
				}
			}
			else
			{
				((Graphic)currentUi.fieldImage).color = Color.black;
				((Graphic)currentUi.statContainerImage).color = new Color(0f, 0f, 0f, 0.8f);
				((Graphic)currentUi.finalRankContainerImage).color = new Color(0f, 0f, 0f, 0.8f);
				Text[] headers = currentUi.headers;
				for (int k = 0; k < headers.Length; k++)
				{
					((Graphic)headers[k]).color = colorSilver;
				}
			}
			if (Locked)
			{
				currentUi.levelThumbnail.sprite = AssetManager.lockedPreview;
				currentUi.levelHeader.text = "???";
				((Component)currentUi.statContainer).gameObject.SetActive(false);
				((Component)currentUi.challengeContainer).gameObject.SetActive(false);
				((Selectable)currentUi.leaderboardsButton).interactable = false;
				((Selectable)currentUi.openSettingsButton).interactable = false;
				currentUi.settingsPanel.SetActive(false);
			}
			else
			{
				currentUi.levelHeader.text = LevelName;
				if (!PlayedBefore && !DoNotHideLevelPreviewWhenNotCompleted)
				{
					currentUi.levelThumbnail.sprite = AssetManager.notPlayedPreview;
				}
				else
				{
					currentUi.levelThumbnail.sprite = PreviewImage;
				}
				((Selectable)currentUi.leaderboardsButton).interactable = true;
				((Selectable)currentUi.openSettingsButton).interactable = true;
			}
			((Component)container).gameObject.SetActive(!((ConfigField)this).hidden && !forceHidden);
		}

		public override void OnCreateUI(RectTransform fieldUI)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Expected O, but got Unknown
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Expected O, but got Unknown
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: Expected O, but got Unknown
			//IL_011b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0125: Expected O, but got Unknown
			container = fieldUI;
			if (!inited)
			{
				return;
			}
			currentUi = Addressables.InstantiateAsync((object)"AngryLevelLoader/Fields/LevelField.prefab", ((Component)fieldUI).transform, false, true).WaitForCompletion().GetComponent<AngryLevelFieldComponent>();
			RectTransform component = ((Component)currentUi).GetComponent<RectTransform>();
			fieldUI.sizeDelta = component.sizeDelta;
			component.pivot = new Vector2(0f, 1f);
			component.anchorMin = new Vector2(0f, 1f);
			component.anchorMax = new Vector2(0f, 1f);
			component.anchoredPosition = new Vector2(0f, 0f);
			((UnityEvent)currentUi.levelButton.onClick).AddListener((UnityAction)delegate
			{
				if (!Locked && this.onLevelButtonPress != null)
				{
					this.onLevelButtonPress();
				}
			});
			((UnityEvent)currentUi.leaderboardsButton.onClick).AddListener((UnityAction)delegate
			{
				NotificationPanel.Open((Notification)(object)new LeaderboardNotification(bundleContainer.BundleName, LevelName, bundleContainer.bundleGuid, levelId));
			});
			((UnityEvent)currentUi.openSettingsButton.onClick).AddListener((UnityAction)delegate
			{
				if ((Object)(object)lastActiveSettingsPanel != (Object)null)
				{
					lastActiveSettingsPanel.SetActive(false);
				}
				lastActiveSettingsPanel = currentUi.settingsPanel;
				currentUi.settingsPanel.SetActive(true);
				((MonoBehaviour)currentUi).StopAllCoroutines();
				((TMP_Text)currentUi.resetStatsText).text = "Reset Stats";
				((TMP_Text)currentUi.resetSecretsText).text = "Reset Secrets";
				((TMP_Text)currentUi.resetChallengeText).text = "Reset Challenge";
				((TMP_Text)currentUi.resetLevelVarsText).text = "Reset Level Variables";
				((TMP_Text)currentUi.resetBundleVarsText).text = "Reset Bundle Variables";
				((TMP_Text)currentUi.resetUserVarsText).text = "Reset User Variables";
				((Selectable)currentUi.resetStatsButton).interactable = FinalRank != '-';
				((Selectable)currentUi.resetSecretsButton).interactable = !IsSecretLevel && SecretCount != 0 && DiscoveredSecrets != 0;
				((Selectable)currentUi.resetChallengeButton).interactable = !IsSecretLevel && ChallengeEnabled && ChallengeDone;
				string path3 = Path.Combine(AngryMapVarManager.GetCurrentMapVarsDirectory(), "BundleDefined", bundleContainer.bundleGuid, "Levels", levelId + ".vars.json");
				string path4 = Path.Combine(AngryMapVarManager.GetCurrentMapVarsDirectory(), "BundleDefined", bundleContainer.bundleGuid, bundleContainer.bundleGuid + ".vars.json");
				((Selectable)currentUi.resetLevelVarsButton).interactable = File.Exists(path3);
				((Selectable)currentUi.resetBundleVarsButton).interactable = File.Exists(path4);
				((Selectable)currentUi.resetUserVarsButton).interactable = true;
				currentUi.ResetSettingsButtons();
			});
			((UnityEvent)currentUi.closeSettingsButton.onClick).AddListener((UnityAction)delegate
			{
				currentUi.settingsPanel.SetActive(false);
			});
			currentUi.onResetStats = delegate
			{
				((Selectable)currentUi.resetStatsButton).interactable = false;
				((TMP_Text)currentUi.resetStatsText).text = "Reset Stats";
				if (onResetStats != null)
				{
					onResetStats();
				}
			};
			currentUi.onResetSecrets = delegate
			{
				((Selectable)currentUi.resetSecretsButton).interactable = false;
				((TMP_Text)currentUi.resetSecretsText).text = "Reset Secrets";
				if (onResetSecrets != null)
				{
					onResetSecrets();
				}
			};
			currentUi.onResetChallenge = delegate
			{
				((Selectable)currentUi.resetChallengeButton).interactable = false;
				((TMP_Text)currentUi.resetChallengeText).text = "Reset Challenge";
				if (onResetChallenge != null)
				{
					onResetChallenge();
				}
			};
			currentUi.onResetLevelVars = delegate
			{
				((Selectable)currentUi.resetLevelVarsButton).interactable = false;
				((TMP_Text)currentUi.resetLevelVarsText).text = "Reset Level Variables";
				string path2 = Path.Combine(AngryMapVarManager.GetCurrentMapVarsDirectory(), "BundleDefined", bundleContainer.bundleGuid, "Levels", levelId + ".vars.json");
				if (File.Exists(path2))
				{
					File.Delete(path2);
				}
			};
			currentUi.onResetBundleVars = delegate
			{
				((Selectable)currentUi.resetBundleVarsButton).interactable = false;
				((TMP_Text)currentUi.resetBundleVarsText).text = "Reset Bundle Variables";
				string path = Path.Combine(AngryMapVarManager.GetCurrentMapVarsDirectory(), "BundleDefined", bundleContainer.bundleGuid, bundleContainer.bundleGuid + ".vars.json");
				if (File.Exists(path))
				{
					File.Delete(path);
				}
			};
			currentUi.onResetUserVars = delegate
			{
				((TMP_Text)currentUi.resetUserVarsText).text = "Reset User Variables";
				NotificationPanel.Open((Notification)(object)new ResetUserMapVarNotification());
			};
			UpdateUI();
		}

		private static string GetTimeStringFromSeconds(float s)
		{
			float num = s % 60f;
			return (int)(s / 60f) + ":" + num.ToString("00.000");
		}
	}
	internal class LoadingCircleField : CustomConfigField
	{
		internal class LoadingBarSpin : MonoBehaviour
		{
			private void Update()
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				((Component)this).transform.Rotate(Vector3.forward, Time.unscaledDeltaTime * 360f);
			}
		}

		public static Sprite loadingIcon;

		private static bool _spriteInit;

		private bool initialized;

		private RectTransform currentContainer;

		private GameObject currentUi;

		private static Image currentImage;

		public static void SpriteInit()
		{
			if (_spriteInit)
			{
				return;
			}
			_spriteInit = true;
			UnityWebRequest spriteReq = UnityWebRequestTexture.GetTexture("file://" + Path.Combine(Plugin.workingDir, "loading-icon.png"));
			((AsyncOperation)spriteReq.SendWebRequest()).completed += delegate
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: Invalid comparison between Unknown and I4
				//IL_0035: Unknown result type (might be due to invalid IL or missing references)
				//IL_0044: Unknown result type (might be due to invalid IL or missing references)
				try
				{
					if ((int)spriteReq.result == 1)
					{
						Texture2D content = DownloadHandlerTexture.GetContent(spriteReq);
						loadingIcon = Sprite.Create(content, new Rect(0f, 0f, (float)((Texture)content).width, (float)((Texture)content).height), new Vector2(0.5f, 0.5f));
						if ((Object)(object)currentImage != (Object)null)
						{
							currentImage.sprite = loadingIcon;
						}
					}
				}
				finally
				{
					spriteReq.Dispose();
				}
			};
		}

		public LoadingCircleField(ConfigPanel parentPanel)
			: base(parentPanel, 600f, 60f)
		{
			initialized = true;
			if ((Object)(object)currentContainer != (Object)null)
			{
				((CustomConfigField)this).OnCreateUI(currentContainer);
			}
		}

		public override void OnCreateUI(RectTransform fieldUI)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Expected O, but got Unknown
			//IL_0022: Expected O, but got Unknown
			//IL_0035: 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_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			currentContainer = fieldUI;
			if (initialized)
			{
				SpriteInit();
				GameObject val = new GameObject();
				GameObject val2 = val;
				currentUi = val;
				val2.transform.SetParent((Transform)(object)fieldUI);
				RectTransform obj = val2.AddComponent<RectTransform>();
				((Transform)obj).localScale = Vector3.one;
				obj.sizeDelta = new Vector2(60f, 60f);
				Vector2 val3 = default(Vector2);
				((Vector2)(ref val3))..ctor(0.5f, 0.5f);
				obj.anchorMax = val3;
				obj.anchorMin = val3;
				obj.pivot = new Vector2(0.5f, 0.5f);
				obj.anchoredPosition = Vector2.zero;
				((Component)obj).gameObject.AddComponent<LoadingBarSpin>();
				currentImage = ((Component)obj).gameObject.AddComponent<Image>();
				currentImage.sprite = loadingIcon;
				if (((CustomConfigField)this).hierarchyHidden)
				{
					((Component)currentContainer).gameObject.SetActive(false);
				}
			}
		}

		public override void OnHiddenChange(bool selfHidden, bool hierarchyHidden)
		{
			if ((Object)(object)currentContainer != (Object)null)
			{
				((Component)currentContainer).gameObject.SetActive(!hierarchyHidden);
			}
		}
	}
	internal class DisableWhenHidden : MonoBehaviour
	{
		private void OnDisable()
		{
			((Component)this).gameObject.SetActive(false);
		}
	}
	public class OnlineLevelField : CustomConfigField
	{
		public enum VoteStat
		{
			Upvoted,
			Downvoted,
			Cleared,
			Disabled
		}

		public enum OnlineLevelStatus
		{
			Installed,
			NotInstalled,
			UpdateAvailable
		}

		public enum ErrorStat
		{
			NoError,
			NetworkError,
			ValidationError
		}

		private const string ASSET_PATH = "AngryLevelLoader/Fields/OnlineLevelField.prefab";

		private static Sprite arrow;

		private static Sprite arrowFilled;

		private BundleInfo _onlineBundle;

		private BundleContainer _bundle;

		private Texture2D _previewImage;

		private VoteStat _voteStatus = VoteStat.Disabled;

		private int _voteCount;

		private OnlineLevelStatus _status = OnlineLevelStatus.NotInstalled;

		private ErrorStat _errorStatus;

		private static Regex richText;

		private string[] _searchKeywords = new string[0];

		private bool inited;

		private AngryOnlineLevelFieldComponent currentUi;

		private RectTransform currentContainer;

		private UnityEvent onCancel = new UnityEvent();

		private Task downloadTask;

		public BundleInfo OnlineBundle
		{
			get
			{
				return _onlineBundle;
			}
			internal set
			{
				if (value == null)
				{
					throw new ArgumentException("Parameter is null");
				}
				if (_onlineBundle != null && _onlineBundle.Guid != value.Guid)
				{
					throw new ArgumentException("Guid mismatch when updating online bundle info");
				}
				_onlineBundle = value;
				UpdateStatus();
				if ((Object)(object)currentUi != (Object)null)
				{
					bool locked = OnlineBundle.Locked;
					((Selectable)currentUi.install).interactable = !locked;
					((Selectable)currentUi.update).interactable = !locked;
					((Component)currentUi.votes).gameObject.SetActive(!locked);
				}
			}
		}

		public BundleContainer Bundle
		{
			get
			{
				if (_bundle == null)
				{
					Plugin.TryGetAngryBundleByGuid(OnlineBundle.Guid, out _bundle);
				}
				return _bundle;
			}
		}

		public Texture2D PreviewImage
		{
			get
			{
				return _previewImage;
			}
			internal set
			{
				_previewImage = value;
				if ((Object)(object)currentUi != (Object)null)
				{
					currentUi.thumbnail.texture = (Texture)(object)(OnlineBundle.Locked ? AssetManager.lockedPreview.texture : _previewImage);
				}
			}
		}

		public VoteStat VoteStatus
		{
			get
			{
				return _voteStatus;
			}
			internal set
			{
				//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
				//IL_0047: Unknown result type (might be due to invalid IL or missing references)
				_voteStatus = value;
				if (!((Object)(object)currentUi == (Object)null))
				{
					if (value == VoteStat.Disabled)
					{
						((Selectable)currentUi.upvoteButton).interactable = false;
						((Selectable)currentUi.downvoteButton).interactable = false;
						((Graphic)currentUi.votes).color = Color.gray;
						currentUi.upvoteImage.sprite = arrowFilled;
						currentUi.downvoteImage.sprite = arrowFilled;
					}
					else
					{
						((Selectable)currentUi.upvoteButton).interactable = true;
						((Selectable)currentUi.downvoteButton).interactable = true;
						((Graphic)currentUi.votes).color = Color.white;
						currentUi.upvoteImage.sprite = ((value == VoteStat.Upvoted) ? arrowFilled : arrow);
						currentUi.downvoteImage.sprite = ((value == VoteStat.Downvoted) ? arrowFilled : arrow);
					}
				}
			}
		}

		public int VoteCount
		{
			get
			{
				return _voteCount;
			}
			internal set
			{
				_voteCount = value;
				if (!((Object)(object)currentUi == (Object)null))
				{
					currentUi.votes.text = value.ToString();
				}
			}
		}

		public OnlineLevelStatus Status
		{
			get
			{
				return _status;
			}
			private set
			{
				_status = value;
				SearchKeywords = SearchKeywords;
				switch (_status)
				{
				case OnlineLevelStatus.Installed:
					((ConfigField)this).hidden = !SearchMatch || !OnlineLevelsList.showInstalledLevels.value;
					break;
				case OnlineLevelStatus.NotInstalled:
					((ConfigField)this).hidden = !SearchMatch || !OnlineLevelsList.showNotInstalledLevels.value;
					break;
				case OnlineLevelStatus.UpdateAvailable:
					((ConfigField)this).hidden = !SearchMatch || !OnlineLevelsList.showUpdateAvailableLevels.value;
					break;
				default:
					((ConfigField)this).hidden = true;
					break;
				}
			}
		}

		public ErrorStat ErrorStatus
		{
			get
			{
				return _errorStatus;
			}
			private set
			{
				_errorStatus = value;
				OnlineBundle = OnlineBundle;
			}
		}

		internal bool SearchMatch { get; private set; } = true;


		internal string[] SearchKeywords
		{
			get
			{
				return _searchKeywords;
			}
			set
			{
				_searchKeywords = value;
				SearchMatch = true;
				string text = richText.Replace(OnlineBundle.Name, string.Empty);
				string text2 = richText.Replace(OnlineBundle.Author, string.Empty);
				WordHighlighter wordHighlighter = new WordHighlighter(text);
				WordHighlighter wordHighlighter2 = new WordHighlighter(text2);
				text = text.ToLower();
				text2 = text2.ToLower();
				foreach (string text3 in value)
				{
					bool flag = false;
					for (int num = text.IndexOf(text3); num != -1; num = text.IndexOf(text3, num + text3.Length))
					{
						flag = true;
						wordHighlighter.Highlight(num, num + text3.Length - 1);
					}
					for (int num = text2.IndexOf(text3); num != -1; num = text2.IndexOf(text3, num + text3.Length))
					{
						flag = true;
						wordHighlighter2.Highlight(num, num + text3.Length - 1);
					}
					if (!flag)
					{
						SearchMatch = false;
						break;
					}
				}
				if ((Object)(object)currentUi != (Object)null)
				{
					if (OnlineBundle.Locked)
					{
						currentUi.infoText.text = wordHighlighter.GenerateFormattedText("<color=yellow><b>", "</b></color>") + " <color=red>(OUTDATED/LOCKED)</color>\n<color=#909090>Author: " + wordHighlighter2.GenerateFormattedText("<color=yellow><b>", "</b></color>") + "\nSize: " + GetFileSizeString() + "</color>\n" + GetStatusString();
					}
					else
					{
						currentUi.infoText.text = wordHighlighter.GenerateFormattedText("<color=yellow><b>", "</b></color>") + "\n<color=#909090>Author: " + wordHighlighter2.GenerateFormattedText("<color=yellow><b>", "</b></color>") + "\nSize: " + GetFileSizeString() + "</color>\n" + GetStatusString();
					}
				}
			}
		}

		private bool InstallActive
		{
			get
			{
				if (!OnlineBundle.Locked && !Downloading)
				{
					return Status == OnlineLevelStatus.NotInstalled;
				}
				return false;
			}
		}

		private bool UpdateActive
		{
			get
			{
				if (!OnlineBundle.Locked && !Downloading)
				{
					return Status == OnlineLevelStatus.UpdateAvailable;
				}
				return false;
			}
		}

		public bool Downloading
		{
			get
			{
				if (downloadTask != null)
				{
					return !downloadTask.IsCompleted;
				}
				return false;
			}
		}

		public float DownloadProgress { get; private set; } = -1f;


		static OnlineLevelField()
		{
			richText = new Regex("<[^>]*>");
			arrow = AssetManager.arrow;
			arrowFilled = AssetManager.arrowFilled;
		}

		private string GetFileSizeString()
		{
			int size = OnlineBundle.Size;
			if (size >= 1048576)
			{
				return ((float)size / 1048576f).ToString("0.00") + " MB";
			}
			if (size >= 1024)
			{
				return ((float)size / 1024f).ToString("0.00") + " KB";
			}
			return $"{size} B";
		}

		internal void UpdateStatus()
		{
			if (Bundle == null || string.IsNullOrEmpty(Bundle.pathToAngryBundle) || !File.Exists(Bundle.pathToAngryBundle))
			{
				Status = OnlineLevelStatus.NotInstalled;
			}
			else if (Bundle.BuildHash != OnlineBundle.Hash)
			{
				Status = OnlineLevelStatus.UpdateAvailable;
			}
			else
			{
				Status = OnlineLevelStatus.Installed;
			}
		}

		private string GetStatusString()
		{
			if (ErrorStatus != 0)
			{
				if (ErrorStatus == ErrorStat.NetworkError)
				{
					return "<color=red><b>Network error</b></color>";
				}
				if (ErrorStatus == ErrorStat.ValidationError)
				{
					return "<color=red><b>Validation error</b></color>";
				}
			}
			if (OnlineBundle.Locked)
			{
				return "<color=red><b>Locked</b></color>";
			}
			if (Status == OnlineLevelStatus.NotInstalled)
			{
				return "<color=red>Not installed</color>";
			}
			if (Status == OnlineLevelStatus.UpdateAvailable)
			{
				return "<color=#00FFFF>Update available</color>";
			}
			return "<color=#00FF00>Installed</color>";
		}

		internal OnlineLevelField(ConfigPanel parentPanel, BundleInfo onlineBundle)
			: base(parentPanel, 600f, 170f)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Expected O, but got Unknown
			inited = true;
			OnlineBundle = onlineBundle;
			UpdateStatus();
			if ((Object)(object)currentContainer != (Object)null)
			{
				((CustomConfigField)this).OnCreateUI(currentContainer);
			}
		}

		public override void OnCreateUI(RectTransform fieldUI)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Expected O, but got Unknown
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Expected O, but got Unknown
			//IL_01a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ac: Expected O, but got Unknown
			//IL_0222: Unknown result type (might be due to invalid IL or missing references)
			//IL_022c: Expected O, but got Unknown
			//IL_02a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ac: Expected O, but got Unknown
			//IL_033d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0347: Expected O, but got Unknown
			currentContainer = fieldUI;
			if (!inited)
			{
				return;
			}
			currentUi = Addressables.InstantiateAsync((object)"AngryLevelLoader/Fields/OnlineLevelField.prefab", ((Component)fieldUI).transform, false, true).WaitForCompletion().GetComponent<AngryOnlineLevelFieldComponent>();
			RectTransform component = ((Component)currentUi).GetComponent<RectTransform>();
			fieldUI.sizeDelta = component.sizeDelta;
			component.pivot = new Vector2(0f, 1f);
			component.anchorMin = new Vector2(0f, 1f);
			component.anchorMax = new Vector2(0f, 1f);
			component.anchoredPosition = new Vector2(0f, 0f);
			((UnityEvent)currentUi.install.onClick).AddListener((UnityAction)delegate
			{
				if (OnlineBundle.EpilepsyWarning && !InternalConfigManager.ignoreEpilepsyWarning.value)
				{
					NotificationPanel.Open((Notification)(object)new EpilepsyWarningNotification(Download, "Download", "Download and do not ask again"));
				}
				else
				{
					Download();
				}
			});
			((Component)currentUi.install).gameObject.AddComponent<DisableWhenHidden>();
			AngryUIUtils.AddMouseEvents(((Component)currentUi).gameObject, currentUi.install, delegate
			{
				if (InstallActive)
				{
					((Component)currentUi.install).gameObject.SetActive(true);
				}
			}, delegate
			{
				((Component)currentUi.install).gameObject.SetActive(false);
			});
			((UnityEvent)currentUi.upvoteButton.onClick).AddListener((UnityAction)delegate
			{
				AngryVotes.VoteOperation operation2 = ((VoteStatus == VoteStat.Upvoted) ? AngryVotes.VoteOperation.CLEAR : AngryVotes.VoteOperation.UPVOTE);
				VoteStatus = VoteStat.Disabled;
				AngryVotes.VoteTask(OnlineBundle.Guid, operation2).ContinueWith(delegate(Task<AngryVotes.VoteResult> resTask)
				{
					AngryVotes.VoteResult result2 = resTask.Result;
					if (result2.completedSuccessfully && result2.status == AngryVotes.VoteStatus.VOTE_OK)
					{
						if (result2.operation == AngryVotes.VoteOperation.UPVOTE)
						{
							VoteStatus = VoteStat.Upvoted;
						}
						else if (result2.operation == AngryVotes.VoteOperation.DOWNVOTE)
						{
							VoteStatus = VoteStat.Downvoted;
						}
						else
						{
							VoteStatus = VoteStat.Cleared;
						}
						VoteCount = result2.response.upvotes - result2.response.downvotes;
					}
					else
					{
						Plugin.logger.LogError((object)$"Could not vote! Message: {result2.message}. Status: {result2.status}.");
						VoteStatus = VoteStat.Disabled;
						VoteCount = 0;
					}
				}, TaskScheduler.FromCurrentSynchronizationContext());
			});
			((Component)currentUi.upvoteButton).gameObject.AddComponent<DisableWhenHidden>();
			((Component)currentUi.upvoteButton).gameObject.SetActive(false);
			AngryUIUtils.AddMouseEvents(((Component)currentUi).gameObject, currentUi.upvoteButton, delegate
			{
				((Component)currentUi.upvoteButton).gameObject.SetActive(!OnlineBundle.Locked);
			}, delegate
			{
				((Component)currentUi.upvoteButton).gameObject.SetActive(false);
			});
			((UnityEvent)currentUi.downvoteButton.onClick).AddListener((UnityAction)delegate
			{
				AngryVotes.VoteOperation operation = ((VoteStatus != VoteStat.Downvoted) ? AngryVotes.VoteOperation.DOWNVOTE : AngryVotes.VoteOperation.CLEAR);
				VoteStatus = VoteStat.Disabled;
				AngryVotes.VoteTask(OnlineBundle.Guid, operation).ContinueWith(delegate(Task<AngryVotes.VoteResult> resTask)
				{
					AngryVotes.VoteResult result = resTask.Result;
					if (result.completedSuccessfully && result.status == AngryVotes.VoteStatus.VOTE_OK)
					{
						if (result.operation == AngryVotes.VoteOperation.UPVOTE)
						{
							VoteStatus = VoteStat.Upvoted;
						}
						else if (result.operation == AngryVotes.VoteOperation.DOWNVOTE)
						{
							VoteStatus = VoteStat.Downvoted;
						}
						else
						{
							VoteStatus = VoteStat.Cleared;
						}
						VoteCount = result.response.upvotes - result.response.downvotes;
					}
					else
					{
						Plugin.logger.LogError((object)$"Could not vote! Message: {result.message}. Status: {result.status}.");
						VoteStatus = VoteStat.Disabled;
						VoteCount = 0;
					}
				}, TaskScheduler.FromCurrentSynchronizationContext());
			});
			((Component)currentUi.downvoteButton).gameObject.AddComponent<DisableWhenHidden>();
			((Component)currentUi.downvoteButton).gameObject.SetActive(false);
			AngryUIUtils.AddMouseEvents(((Component)currentUi).gameObject, currentUi.downvoteButton, delegate
			{
				((Component)currentUi.downvoteButton).gameObject.SetActive(!OnlineBundle.Locked);
			}, delegate
			{
				((Component)currentUi.downvoteButton).gameObject.SetActive(false);
			});
			((UnityEvent)currentUi.changelog.onClick).AddListener((UnityAction)delegate
			{
				NotificationPanel.Open((Notification)(object)new LevelUpdateNotification
				{
					currentHash = ((Bundle == null || Status == OnlineLevelStatus.NotInstalled) ? "" : Bundle.BuildHash),
					onlineInfo = OnlineBundle,
					callback = this
				});
			});
			((Component)currentUi.changelog).gameObject.AddComponent<DisableWhenHidden>();
			((Component)currentUi.changelog).gameObject.SetActive(false);
			AngryUIUtils.AddMouseEvents(((Component)currentUi).gameObject, currentUi.changelog, delegate
			{
				if (!Downloading && !OnlineBundle.Locked)
				{
					((Component)currentUi.changelog).gameObject.SetActive(true);
				}
			}, delegate
			{
				((Component)currentUi.changelog).gameObject.SetActive(false);
			});
			((UnityEvent)currentUi.update.onClick).AddListener((UnityAction)delegate
			{
				if (OnlineBundle.Updates == null)
				{
					Download();
				}
				else if (Bundle == null || string.IsNullOrEmpty(Bundle.pathToAngryBundle) || !File.Exists(Bundle.pathToAngryBundle))
				{
					Download();
				}
				else
				{
					NotificationPanel.Open((Notification)(object)new LevelUpdateNotification
					{
						currentHash = Bundle.BuildHash,
						onlineInfo = OnlineBundle,
						callback = this
					});
				}
			});
			((Component)currentUi.update).gameObject.AddComponent<DisableWhenHidden>();
			AngryUIUtils.AddMouseEvents(((Component)currentUi).gameObject, currentUi.update, delegate
			{
				if (UpdateActive)
				{
					((Component)currentUi.update).gameObject.SetActive(true);
				}
			}, delegate
			{
				((Component)currentUi.update).gameObject.SetActive(false);
			});
			currentUi.progressText.resizeTextForBestFit = true;
			currentUi.progressText.resizeTextMaxSize = currentUi.progressText.fontSize;
			((UnityEvent)currentUi.cancel.onClick).AddListener((UnityAction)delegate
			{
				if (onCancel != null)
				{
					onCancel.Invoke();
				}
			});
			if (((CustomConfigField)this).hierarchyHidden)
			{
				((Component)currentContainer).gameObject.SetActive(false);
			}
			PreviewImage = PreviewImage;
			OnlineBundle = OnlineBundle;
			VoteCount = VoteCount;
			VoteStatus = VoteStatus;
		}

		public override void OnHiddenChange(bool selfHidden, bool hierarchyHidden)
		{
			if ((Object)(object)currentContainer != (Object)null)
			{
				((Component)currentContainer).gameObject.SetActive(!hierarchyHidden);
			}
		}

		public void Download()
		{
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			if (Downloading)
			{
				return;
			}
			if ((Object)(object)currentUi != (Object)null)
			{
				((Component)currentUi.downloadContainer).gameObject.SetActive(true);
				((Transform)currentUi.progressBar).localScale = new Vector3(0f, 1f, 1f);
			}
			downloadTask = DownloadTask().ContinueWith(delegate
			{
				DownloadProgress = -1f;
				UpdateStatus();
				if ((Object)(object)currentUi != (Object)null)
				{
					((Component)currentUi.downloadContainer).gameObject.SetActive(false);
				}
				OnlineLevelsList.CheckLevelUpdateText();
			}, TaskScheduler.FromCurrentSynchronizationContext());
		}

		public bool AbortDownload()
		{
			if (!Downloading)
			{
				return false;
			}
			if (onCancel == null)
			{
				return false;
			}
			onCancel.Invoke();
			return true;
		}

		private async Task DownloadTask()
		{
			BundleInfo bundle = OnlineBundle;
			ErrorStatus = ErrorStat.NoError;
			DownloadProgress = 0f;
			if ((Object)(object)currentUi != (Object)null)
			{
				((Component)currentUi.changelog).gameObject.SetActive(false);
				((Component)currentUi.install).gameObject.SetActive(false);
				((Component)currentUi.update).gameObject.SetActive(false);
			}
			List<string> downloadedParts = new List<string>();
			string fileMegabytes = ((float)bundle.Size / 1048576f).ToString("0.0");
			ulong downloadedBytes = 0uL;
			string tempDownloadDir = Path.Combine(Plugin.dataPath, "TempDownloads");
			if (!Directory.Exists(tempDownloadDir))
			{
				Directory.CreateDirectory(tempDownloadDir);
			}
			int partCount = bundle.Parts.Count;
			for (int i = 0; i < partCount; i++)
			{
				string text = Path.Combine(tempDownloadDir, $"{bundle.Guid}.angry{i}");
				if (File.Exists(text))
				{
					File.Delete(text);
				}
				downloadedParts.Add(text);
				UnityWebRequest req = new UnityWebRequest(bundle.Parts[i]);
				req.downloadHandler = (DownloadHandler)new DownloadHandlerFile(text);
				UnityWebRequestAsyncOperation handle = req.SendWebRequest();
				CancellationTokenSource abortToken = new CancellationTokenSource();
				onCancel = new UnityEvent();
				onCancel.AddListener((UnityAction)delegate
				{
					if (Downloading)
					{
						req.Abort();
						abortToken.Cancel();
					}
				});
				while (!((AsyncOperation)handle).isDone)
				{
					if ((Object)(object)currentUi != (Object)null)
					{
						DownloadProgress = Mathf.Clamp01((float)(req.downloadedBytes + downloadedBytes) / (float)bundle.Size);
						((Component)currentUi.progressBar).transform.localScale = new Vector3(DownloadProgress, 1f, 1f);
						string text2 = ((float)(req.downloadedBytes + downloadedBytes) / 1048576f).ToString("0.0");
						currentUi.progressText.text = $"{text2}/{fileMegabytes}\nMB\n(Part {i + 1}/{partCount})";
					}
					await Task.Delay(500, abortToken.Token);
				}
				onCancel = new UnityEvent();
				if ((int)req.result != 1)
				{
					if (!abortToken.Token.IsCancellationRequested)
					{
						ErrorStatus = ErrorStat.NetworkError;
					}
					{
						foreach (string item in downloadedParts)
						{
							if (File.Exists(item))
							{
								File.Delete(item);
							}
						}
						return;
					}
				}
				downloadedBytes += req.downloadedBytes;
				req.Dispose();
			}
			string text3 = Path.Combine(tempDownloadDir, AngryIOUtils.GetUniqueFileName(tempDownloadDir, "combined_file"));
			using (FileStream fileStream = File.Open(text3, FileMode.OpenOrCreate, FileAccess.Write))
			{
				fileStream.Position = 0L;
				fileStream.SetLength(0L);
				foreach (string item2 in downloadedParts)
				{
					using (FileStream fileStream2 = File.Open(item2, FileMode.Open, FileAccess.Read))
					{
						fileStream2.CopyTo(fileStream);
					}
					File.Delete(item2);
				}
			}
			bool flag = true;
			if (AngryFileUtils.TryGetAngryBundleData(text3, out var data, out var error))
			{
				if (data.bundleGuid != bundle.Guid)
				{
					flag = false;
				}
				else if (data.buildHash != bundle.Hash)
				{
					Plugin.logger.LogWarning((object)("Downloaded bundle has hash " + data.buildHash + " but most recent one is " + bundle.Hash));
				}
			}
			else
			{
				Plugin.logger.LogError((object)$"Threw error while validating downloaded file\n{error}");
				flag = false;
			}
			if (!flag)
			{
				File.Delete(text3);
				ErrorStatus = ErrorStat.ValidationError;
				return;
			}
			string levelsPath = Plugin.levelsPath;
			if (!Directory.Exists(levelsPath))
			{
				Directory.CreateDirectory(levelsPath);
			}
			string text4 = Path.Combine(levelsPath, AngryIOUtils.GetUniqueFileName(levelsPath, AngryIOUtils.GetPathSafeName(bundle.Name) + ".angry"));
			if (Bundle != null && !string.IsNullOrEmpty(Bundle.pathToAngryBundle) && File.Exists(Bundle.pathToAngryBundle))
			{
				text4 = Bundle.pathToAngryBundle;
			}
			if (File.Exists(text4))
			{
				using (FileStream fileStream3 = File.Open(text4, FileMode.OpenOrCreate, FileAccess.Write))
				{
					fileStream3.Seek(0L, SeekOrigin.Begin);
					fileStream3.SetLength(0L);
					using FileStream fileStream4 = File.Open(text3, FileMode.Open, FileAccess.Read);
					fileStream4.CopyTo(fileStream3);
				}
				File.Delete(text3);
			}
			else
			{
				File.Move(text3, text4);
			}
			if (Bundle == null || !AngryIOUtils.PathEquals(Bundle.pathToAngryBundle, text4))
			{
				Plugin.ScanForLevels();
				return;
			}
			LastPlayedMapManager.UpdateLastUpdate(Bundle);
			if (!AngrySceneManager.isInCustomLevel || AngrySceneManager.currentBundleContainer != Bundle)
			{
				Bundle.ReloadBundle(forceReload: false, lazyLoad: false);
			}
		}
	}
	internal class OnlineSortField : CustomConfigField
	{
		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static UnityAction <>9__9_0;

			public static UnityAction <>9__9_1;

			public static UnityAction <>9__9_2;

			public static UnityAction <>9__9_3;

			public static UnityAction <>9__9_4;

			internal void <OnCreateUI>b__9_0()
			{
				OnlineLevelsList.RefreshAsync();
			}

			internal void <OnCreateUI>b__9_1()
			{
				OnlineLevelsList.sortFilter.value = OnlineLevelsList.SortFilter.Name;
				OnlineLevelsList.sortFilter.TriggerPostValueChangeEvent();
			}

			internal void <OnCreateUI>b__9_2()
			{
				OnlineLevelsList.sortFilter.value = OnlineLevelsList.SortFilter.Author;
				OnlineLevelsList.sortFilter.TriggerPostValueChangeEvent();
			}

			internal void <OnCreateUI>b__9_3()
			{
				OnlineLevelsList.sortFilter.value = OnlineLevelsList.SortFilter.LastUpdate;
				OnlineLevelsList.sortFilter.TriggerPostValueChangeEvent();
			}

			internal void <OnCreateUI>b__9_4()
			{
				OnlineLevelsList.sortFilter.value = OnlineLevelsList.SortFilter.Votes;
				OnlineLevelsList.sortFilter.TriggerPostValueChangeEvent();
			}
		}

		public const string ASSET_PATH = "AngryLevelLoader/Fields/OnlineSortField.prefab";

		private RectTransform fieldUi;

		private AngryOnlineSortFieldComponent currentUi;

		private OnlineLevelsList.SortFilter _sortingMode;

		private bool inited;

		private OnlineLevelsList.SortFilter SortingMode
		{
			get
			{
				return _sortingMode;
			}
			set
			{
				_sortingMode = value;
				if ((Object)(object)currentUi != (Object)null)
				{
					switch (_sortingMode)
					{
					case OnlineLevelsList.SortFilter.Name:
						currentUi.SetButtonSelected(currentUi.nameButton);
						break;
					case OnlineLevelsList.SortFilter.Author:
						currentUi.SetButtonSelected(currentUi.authorButton);
						break;
					case OnlineLevelsList.SortFilter.LastUpdate:
						currentUi.SetButtonSelected(currentUi.lastUpdateButton);
						break;
					case OnlineLevelsList.SortFilter.Votes:
						currentUi.SetButtonSelected(currentUi.votesButton);
						break;
					}
				}
			}
		}

		public OnlineSortField(ConfigPanel parentPanel)
			: base(parentPanel, 600f, 40f)
		{
			inited = true;
			OnlineLevelsList.Init();
			SortingMode = OnlineLevelsList.sortFilter.value;
			OnlineLevelsList.sortFilter.postValueChangeEvent += delegate(OnlineLevelsList.SortFilter mode)
			{
				SortingMode = mode;
			};
			if ((Object)(object)fieldUi != (Object)null)
			{
				((CustomConfigField)this).OnCreateUI(fieldUi);
			}
		}

		public override void OnCreateUI(RectTransform fieldUI)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Expected O, but got Unknown
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Expected O, but got Unknown
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Expected O, but got Unknown
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_012f: Expected O, but got Unknown
			//IL_0158: Unknown result type (might be due to invalid IL or missing references)
			//IL_015d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0163: Expected O, but got Unknown
			fieldUi = fieldUI;
			if (!inited)
			{
				return;
			}
			currentUi = Addressables.InstantiateAsync((object)"AngryLevelLoader/Fields/OnlineSortField.prefab", ((Component)fieldUI).transform, false, true).WaitForCompletion().GetComponent<AngryOnlineSortFieldComponent>();
			((Component)currentUi).GetComponent<RectTransform>().anchoredPosition = new Vector2(0f, 0f);
			SortingMode = OnlineLevelsList.sortFilter.value;
			ButtonClickedEvent onClick = currentUi.refreshButton.onClick;
			object obj = <>c.<>9__9_0;
			if (obj == null)
			{
				UnityAction val = delegate
				{
					OnlineLevelsList.RefreshAsync();
				};
				<>c.<>9__9_0 = val;
				obj = (object)val;
			}
			((UnityEvent)onClick).AddListener((UnityAction)obj);
			ButtonClickedEvent onClick2 = currentUi.nameButton.onClick;
			object obj2 = <>c.<>9__9_1;
			if (obj2 == null)
			{
				UnityAction val2 = delegate
				{
					OnlineLevelsList.sortFilter.value = OnlineLevelsList.SortFilter.Name;
					OnlineLevelsList.sortFilter.TriggerPostValueChangeEvent();
				};
				<>c.<>9__9_1 = val2;
				obj2 = (object)val2;
			}
			((UnityEvent)onClick2).AddListener((UnityAction)obj2);
			ButtonClickedEvent onClick3 = currentUi.authorButton.onClick;
			object obj3 = <>c.<>9__9_2;
			if (obj3 == null)
			{
				UnityAction val3 = delegate
				{
					OnlineLevelsList.sortFilter.value = OnlineLevelsList.SortFilter.Author;
					OnlineLevelsList.sortFilter.TriggerPostValueChangeEvent();
				};
				<>c.<>9__9_2 = val3;
				obj3 = (object)val3;
			}
			((UnityEvent)onClick3).AddListener((UnityAction)obj3);
			ButtonClickedEvent onClick4 = currentUi.lastUpdateButton.onClick;
			object obj4 = <>c.<>9__9_3;
			if (obj4 == null)
			{
				UnityAction val4 = delegate
				{
					OnlineLevelsList.sortFilter.value = OnlineLevelsList.SortFilter.LastUpdate;
					OnlineLevelsList.sortFilter.TriggerPostValueChangeEvent();
				};
				<>c.<>9__9_3 = val4;
				obj4 = (object)val4;
			}
			((UnityEvent)onClick4).AddListener((UnityAction)obj4);
			ButtonClickedEvent onClick5 = currentUi.votesButton.onClick;
			object obj5 = <>c.<>9__9_4;
			if (obj5 == null)
			{
				UnityAction val5 = delegate
				{
					OnlineLevelsList.sortFilter.value = OnlineLevelsList.SortFilter.Votes;
					OnlineLevelsList.sortFilter.TriggerPostValueChangeEvent();
				};
				<>c.<>9__9_4 = val5;
				obj5 = (object)val5;
			}
			((UnityEvent)onClick5).AddListener((UnityAction)obj5);
		}
	}
	internal class OnlineStatusFilterField : CustomConfigField
	{
		public const string ASSET_PATH = "AngryLevelLoader/Fields/OnlineStatusFilter.prefab";

		private RectTransform fieldUi;

		private AngryOnlineStatusFilterComponent currentUi;

		private bool _showInstalled;

		private bool _showNotInstalled;

		private bool _showUpdateAvailable;

		private bool inited;

		private bool ShowInstalled
		{
			get
			{
				return _showInstalled;
			}
			set
			{
				_showInstalled = value;
				if ((Object)(object)currentUi != (Object)null)
				{
					currentUi.installed.Set(_showInstalled, false);
				}
			}
		}

		private bool ShowNotInstalled
		{
			get
			{
				return _showNotInstalled;
			}
			set
			{
				_showNotInstalled = value;
				if ((Object)(object)currentUi != (Object)null)
				{
					currentUi.notInstalled.Set(_showNotInstalled, false);
				}
			}
		}

		private bool ShowUpdateAvailable
		{
			get
			{
				return _showUpdateAvailable;
			}
			set
			{
				_showUpdateAvailable = value;
				if ((Object)(object)currentUi != (Object)null)
				{
					currentUi.updateAvailable.Set(_showUpdateAvailable, false);
				}
			}
		}

		public OnlineStatusFilterField(ConfigPanel parentPanel)
			: base(parentPanel, 600f, 40f)
		{
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Expected O, but got Unknown
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Expected O, but got Unknown
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Expected O, but got Unknown
			inited = true;
			OnlineLevelsList.Init();
			ShowInstalled = OnlineLevelsList.showInstalledLevels.value;
			ShowNotInstalled = OnlineLevelsList.showNotInstalledLevels.value;
			ShowUpdateAvailable = OnlineLevelsList.showUpdateAvailableLevels.value;
			OnlineLevelsList.showInstalledLevels.postValueChangeEvent += (PostBoolValueChangeEvent)delegate(bool val)
			{
				ShowInstalled = val;
			};
			OnlineLevelsList.showNotInstalledLevels.postValueChangeEvent += (PostBoolValueChangeEvent)delegate(bool val)
			{
				ShowNotInstalled = val;
			};
			OnlineLevelsList.showUpdateAvailableLevels.postValueChangeEvent += (PostBoolValueChangeEvent)delegate(bool val)
			{
				ShowUpdateAvailable = val;
			};
			if ((Object)(object)fieldUi != (Object)null)
			{
				((CustomConfigField)this).OnCreateUI(fieldUi);
			}
		}

		public override void OnCreateUI(RectTransform fieldUI)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			fieldUi = fieldUI;
			if (inited)
			{
				currentUi = Addressables.InstantiateAsync((object)"AngryLevelLoader/Fields/OnlineStatusFilter.prefab", ((Component)fieldUI).transform, false, true).WaitForCompletion().GetComponent<AngryOnlineStatusFilterComponent>();
				((Component)currentUi).GetComponent<RectTransform>().anchoredPosition = new Vector2(0f, 0f);
				ShowInstalled = OnlineLevelsList.showInstalledLevels.value;
				ShowNotInstalled = OnlineLevelsList.showNotInstalledLevels.value;
				ShowUpdateAvailable = OnlineLevelsList.showUpdateAvailableLevels.value;
				((UnityEvent<bool>)(object)currentUi.installed.onValueChanged).AddListener((UnityAction<bool>)delegate(bool val)
				{
					OnlineLevelsList.showInstalledLevels.value = val;
					OnlineLevelsList.showInstalledLevels.TriggerPostValueChangeEvent();
				});
				((UnityEvent<bool>)(object)currentUi.notInstalled.onValueChanged).AddListener((UnityAction<bool>)delegate(bool val)
				{
					OnlineLevelsList.showNotInstalledLevels.value = val;
					OnlineLevelsList.showNotInstalledLevels.TriggerPostValueChangeEvent();
				});
				((UnityEvent<bool>)(object)currentUi.updateAvailable.onValueChanged).AddListener((UnityAction<bool>)delegate(bool val)
				{
					OnlineLevelsList.showUpdateAvailableLevels.value = val;
					OnlineLevelsList.showUpdateAvailableLevels.TriggerPostValueChangeEvent();
				});
			}
		}
	}
	internal class SearchBarField : CustomConfigField
	{
		private class SelectOnEnabled : MonoBehaviour
		{
			public bool selectOnEnable;

			private Selectable _selectable;

			private void Awake()
			{
				_selectable = ((Component)this).GetComponent<Selectable>();
				if ((Object)(object)_selectable == (Object)null)
				{
					Debug.LogError((object)("Object " + ((Object)((Component)this).gameObject).name + " has SelectOnEnabled but is not a Selectable!"));
					((Behaviour)this).enabled = false;
				}
				else
				{
					_selectable.Select();
				}
			}

			private void OnEnable()
			{
				if (selectOnEnable && (Object)(object)_selectable != (Object)null)
				{
					_selectable.Select();
				}
			}
		}

		private const string ASSET_PATH = "AngryLevelLoader/Fields/SearchBar.prefab";

		private string _value;

		private RectTransform fieldContainer;

		private TMP_InputField currentInput;

		private SelectOnEnabled currentSelector;

		private Button resetButton;

		public Action<string> onValueChange;

		public Action onReset;

		public Action<bool> onEndEdit;

		private bool _selectOnEnable = true;

		private bool _inited;

		public string value
		{
			get
			{
				return _value;
			}
			set
			{
				_value = value;
				if ((Object)(object)currentInput != (Object)null)
				{
					currentInput.text = value;
				}
			}
		}

		public bool selectOnEnable
		{
			get
			{
				return _selectOnEnable;
			}
			set
			{
				_selectOnEnable = value;
				if ((Object)(object)currentSelector != (Object)null)
				{
					currentSelector.selectOnEnable = value;
				}
			}
		}

		public SearchBarField(ConfigPanel rootPanel)
			: base(rootPanel)
		{
			_inited = true;
			if ((Object)(object)fieldContainer != (Object)null)
			{
				((CustomConfigField)this).OnCreateUI(fieldContainer);
			}
		}

		public override void OnCreateUI(RectTransform fieldUI)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Expected O, but got Unknown
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Expected O, but got Unknown
			fieldContainer = fieldUI;
			if (!_inited)
			{
				return;
			}
			GameObject val = Addressables.InstantiateAsync((object)"AngryLevelLoader/Fields/SearchBar.prefab", (Transform)(object)fieldUI, false, true).WaitForCompletion();
			fieldUI.sizeDelta = val.GetComponent<RectTransform>().sizeDelta;
			currentInput = val.GetComponent<TMP_InputField>();
			currentInput.text = _value;
			((UnityEvent<string>)(object)currentInput.onValueChanged).AddListener((UnityAction<string>)delegate(string newVal)
			{
				_value = newVal;
				if (onValueChange != null)
				{
					onValueChange(newVal);
				}
			});
			((UnityEvent<string>)(object)currentInput.onEndEdit).AddListener((UnityAction<string>)delegate
			{
				if (onEndEdit != null)
				{
					onEndEdit(currentInput.wasCanceled);
				}
			});
			currentSelector = ((Component)currentInput).gameObject.AddComponent<SelectOnEnabled>();
			currentSelector.selectOnEnable = _selectOnEnable;
			if (_selectOnEnable)
			{
				((Selectable)currentInput).Select();
			}
			resetButton = val.GetComponentInChildren<Button>();
			resetButton.onClick = new ButtonClickedEvent();
			((UnityEvent)resetButton.onClick).AddListener((UnityAction)delegate
			{
				if (onReset != null)
				{
					onReset();
				}
			});
			((Component)fieldContainer).gameObject.SetActive(!((ConfigField)this).hidden && !((CustomConfigField)this).hierarchyHidden);
			((Selectable)currentInput).interactable = ((ConfigField)this).interactable && ((CustomConfigField)this).hierarchyInteractable;
			((Selectable)resetButton).interactable = ((ConfigField)this).interactable && ((CustomConfigField)this).hierarchyInteractable;
		}

		public override void OnHiddenChange(bool selfHidden, bool hierarchyHidden)
		{
			if (!((Object)(object)fieldContainer == (Object)null))
			{
				((Component)fieldContainer).gameObject.SetActive(!((ConfigField)this).hidden && !hierarchyHidden);
			}
		}

		public override void OnInteractableChange(bool selfInteractable, bool hierarchyInteractable)
		{
			if (!((Object)(object)currentInput == (Object)null))
			{
				((Selectable)currentInput).interactable = ((ConfigField)this).interactable && hierarchyInteractable;
				((Selectable)resetButton).interactable = ((ConfigField)this).interactable && hierarchyInteractable;
			}
		}

		public void SetValueWithoutNotify(string newVal)
		{
			_value = newVal;
			if ((Object)(object)currentInput != (Object)null)
			{
				currentInput.SetTextWithoutNotify(newVal);
			}
		}

		public bool FocusOnField()
		{
			if ((Object)(object)currentInput != (Object)null && ((Component)currentInput).gameObject.activeInHierarchy)
			{
				((Selectable)currentInput).Select();
				return true;
			}
			return false;
		}
	}
}
namespace AngryLevelLoader.Extensions
{
	public static class AsyncExtensions
	{
		public static TaskAwaiter GetAwaiter(this AsyncOperation asyncOp)
		{
			TaskCompletionSource<object> tcs = new TaskCompletionSource<object>();
			asyncOp.completed += delegate
			{
				tcs.SetResult(null);
			};
			return ((Task)tcs.Task).GetAwaiter();
		}

		public static TaskAwaiter GetAwaiter<T>(this AsyncOperationHandle<T> asyncOp)
		{
			TaskCompletionSource<object> tcs = new TaskCompletionSource<object>();
			asyncOp.Completed += delegate
			{
				tcs.SetResult(null);
			};
			return ((Task)tcs.Task).GetAwaiter();
		}

		public static TaskAwaiter GetAwaiter(this AsyncOperationHandle asyncOp)
		{
			TaskCompletionSource<object> tcs = new TaskCompletionSource<object>();
			((AsyncOperationHandle)(ref asyncOp)).Completed += delegate
			{
				tcs.SetResult(null);
			};
			return ((Task)tcs.Task).GetAwaiter();
		}
	}
	internal static class GameObjectExtensions
	{
		public static T GetComponentInParent<T>(this GameObject go, bool includeInactive) where T : Component
		{
			if (!includeInactive)
			{
				return go.GetComponentInParent<T>();
			}
			Transform val = go.transform;
			while ((Object)(object)val != (Object)null)
			{
				T component = ((Component)val).gameObject.GetComponent<T>();
				if ((Object)(object)component != (Object)null)
				{
					return component;
				}
				val = val.parent;
			}
			return default(T);
		}
	}
	internal static class VarStoreExtensions
	{
		public static void AppendDistinct(this VarStore target, VarStore source)
		{
			foreach (KeyValuePair<string, bool> item in source.boolStore)
			{
				if (!target.boolStore.ContainsKey(item.Key))
				{
					target.boolStore.Add(item.Key, item.Value);
				}
			}
			foreach (KeyValuePair<string, int> item2 in source.intStore)
			{
				if (!target.intStore.ContainsKey(item2.Key))
				{
					target.intStore.Add(item2.Key, item2.Value);
				}
			}
			foreach (KeyValuePair<string, float> item3 in source.floatStore)
			{
				if (!target.floatStore.ContainsKey(item3.Key))
				{
					target.floatStore.Add(item3.Key, item3.Value);
				}
			}
			foreach (KeyValuePair<string, string> item4 in source.stringStore)
			{
				if (!target.stringStore.ContainsKey(item4.Key))
				{
					target.stringStore.Add(item4.Key, item4.Value);
				}
			}
		}

		public static VarStore ExtractSet(this VarStore store, HashSet<string> keys)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Expected O, but got Unknown
			VarStore val = new VarStore();
			foreach (string key in keys)
			{
				if (store.boolStore.ContainsKey(key))
				{
					val.boolStore.Add(key, store.boolStore[key]);
				}
				if (store.intStore.ContainsKey(key))
				{
					val.intStore.Add(key, store.intStore[key]);
				}
				if (store.floatStore.ContainsKey(key))
				{
					val.floatStore.Add(key, store.floatStore[key]);
				}
				if (store.stringStore.ContainsKey(key))
				{
					val.stringStore.Add(key, store.stringStore[key]);
				}
			}
			return val;
		}

		public static HashSet<string> ExtractAllKeys(this VarStore varstore)
		{
			HashSet<string> hashSet = new HashSet<string>();
			hashSet.UnionWith(varstore.boolStore.Keys);
			hashSet.UnionWith(varstore.intStore.Keys);
			hashSet.UnionWith(varstore.floatStore.Keys);
			hashSet.UnionWith(varstore.stringStore.Keys);
			return hashSet;
		}

		public static bool ContainsKey(this VarStore store, string key)
		{
			if (store.ContainsBoolKey(key))
			{
				return true;
			}
			if (store.ContainsIntKey(key))
			{
				return true;
			}
			if (store.ContainsFloatKey(key))
			{
				return true;
			}
			if (store.ContainsStringKey(key))
			{
				return true;
			}
			return false;
		}

		public static bool ContainsBoolKey(this VarStore store, string key)
		{
			foreach (KeyValuePair<string, bool> item in store.boolStore)
			{
				if (item.Key == key)
				{
					return true;
				}
			}
			return false;
		}

		public static bool ContainsIntKey(this VarStore store, string key)
		{
			foreach (KeyValuePair<string, int> item in store.intStore)
			{
				if (item.Key == key)
				{
					return true;
				}
			}
			return false;
		}

		public static bool ContainsFloatKey(this VarStore store, string key)
		{
			foreach (KeyValuePair<string, float> item in store.floatStore)
			{
				if (item.Key == key)
				{
					return true;
				}
			}
			return false;
		}

		public static bool ContainsStringKey(this VarStore store, string key)
		{
			foreach (KeyValuePair<string, string> item in store.stringStore)
			{
				if (item.Key == key)
				{
					return true;
				}
			}
			return false;
		}

		public static void Update(this VarStore target, VarStore source)
		{
			foreach (KeyValuePair<string, bool> item in source.boolStore)
			{
				if (!target.boolStore.ContainsKey(item.Key))
				{
					target.boolStore.Add(item.Key, item.Value);
				}
				else
				{
					target.boolStore[item.Key] = item.Value;
				}
			}
			foreach (KeyValuePair<string, int> item2 in source.intStore)
			{
				if (!target.intStore.ContainsKey(item2.Key))
				{
					target.intStore.Add(item2.Key, item2.Value);
				}
				else
				{
					target.intStore[item2.Key] = item2.Value;
				}
			}
			foreach (KeyValuePair<string, float> item3 in source.floatStore)
			{
				if (!target.floatStore.ContainsKey(item3.Key))
				{
					target.floatStore.Add(item3.Key, item3.Value);
				}
				else
				{
					target.floatStore[item3.Key] = item3.Value;
				}
			}
			foreach (KeyValuePair<string, string> item4 in source.stringStore)
			{
				if (!target.stringStore.ContainsKey(item4.Key))
				{
					target.stringStore.Add(item4.Key, item4.Value);
				}
				else
				{
					target.stringStore[item4.Key] = item4.Value;
				}
			}
		}
	}
}
namespace AngryLevelLoader.DataTypes
{
	public class AngryBundleData
	{
		public List<string> levelDataPaths;

		[DefaultValue(null)]
		public List<AngryLevelData> levels;

		public string bundleName { get; set; }

		public string bundleAuthor { get; set; }

		public string bundleGuid { get; set; }

		public string buildHash { get; set; }

		[DefaultValue(-1)]
		[JsonProperty(/*Could not decode attribute arguments.*/)]
		public int bundleVersion { get; set; }

		public string bundleDataPath { get; set; }

		[DefaultValue(false)]
		public bool epilepsyWarning { get; set; }
	}
	public class AngryLevelData
	{
		public string[] requiredDllNames;

		public string uniqueIdentifier { get; set; }

		public string levelName { get; set; }

		public bool isSecretLevel { get; set; }

		public int prefferedLevelOrder { get; set; }

		public bool hideIfNotPlayed { get; set; }

		public string[] requiredCompletedLevelIdsForUnlock { get; set; }

		public bool levelChallengeEnabled { get; set; }

		public string levelChallengeText { get; set; }

		public int secretCount { get; set; }

		public bool doNotHideLevelPreviewWhenNotCompleted { get; set; }

		[DefaultValue(false)]
		public bool doesNotSupportNoMo { get; set; }

		internal static AngryLevelData FromRudeLevelData(RudeLevelData levelData)
		{
			return new AngryLevelData
			{
				requiredDllNames = levelData.requiredDllNames,
				uniqueIdentifier = levelData.uniqueIdentifier,
				levelName = levelData.levelName,
				isSecretLevel = levelData.isSecretLevel,
				prefferedLevelOrder = levelData.prefferedLevelOrder,
				hideIfNotPlayed = levelData.hideIfNotPlayed,
				requiredCompletedLevelIdsForUnlock = levelData.requiredCompletedLevelIdsForUnlock,
				levelChallengeEnabled = levelData.levelChallengeEnabled,
				levelChallengeText = levelData.levelChallengeText,
				secretCount = levelData.secretCount,
				doNotHideLevelPreviewWhenNotCompleted = levelData.doNotHideLevelPreviewWhenNotCompleted,
				doesNotSupportNoMo = levelData.doesNotSupportNoMo
			};
		}
	}
	public class LevelInfo
	{
		public List<string> requiredCompletedLevelIdsForUnlock;

		public List<string> requiredDllNames;

		public string LevelName { get; set; }

		public string LevelId { get; set; }

		public bool isSecretLevel { get; set; }

		public int secretCount { get; set; }

		public bool levelChallengeEnabled { get; set; }

		public string levelChallengeText { get; set; }
	}
	public class BundleInfo
	{
		public class UpdateInfo
		{
			public long Date { get; set; }

			public string Hash { get; set; }

			public string Message { get; set; }
		}

		public List<string> Parts;

		public List<UpdateInfo> Updates;

		public List<LevelInfo> Levels;

		public string Name { get; set; }

		public string Author { get; set; }

		public int Size { get; set; }

		public string Guid { get; set; }

		public string Hash { get; set; }

		public string ThumbnailHash { get; set; }

		public bool Locked { get; set; }

		public bool EpilepsyWarning { get; set; }

		public long LastUpdate { get; set; }
	}
	public class LevelCatalog
	{
		public List<BundleInfo> Levels;
	}
	public class ScriptInfo
	{
		public List<string> Updates;

		public string FileName { get; set; }

		public string Hash { get; set; }

		public int Size { get; set; }
	}
	public class ScriptCatalog
	{
		public List<ScriptInfo> Scripts;
	}
}
namespace AngryLevelLoader.DataTypes.MapVarHandlers
{
	internal class AngryMapVarHandler : PersistentMapVarHandler
	{
		public RudeMapVarHandler RudeMapVarHandler { get; private set; }

		public AngryMapVarHandler(string filePath, RudeMapVarHandler rudeMapVarHandler)
			: base(filePath)
		{
			RudeMapVarHandler = rudeMapVarHandler;
		}
	}
	internal class MapVarHandler
	{
		protected VarStore currentStore;

		protected VarStore stashedStore;

		public MapVarHandler()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Expected O, but got Unknown
			currentStore = new VarStore();
		}

		public VarStore GetStore()
		{
			return currentStore;
		}

		public void StashStore()
		{
			if (currentStore.intStore.Count == 0 && currentStore.boolStore.Count == 0 && currentStore.floatStore.Count == 0 && currentStore.stringStore.Count == 0)
			{
				stashedStore = null;
			}
			else
			{
				stashedStore = currentStore.DuplicateStore();
			}
		}

		public void RestoreStashedStore()
		{
			if (stashedStore != null)
			{
				currentStore = stashedStore.DuplicateStore();
			}
		}

		public List<VariableSnapshot> GetAllVariables()
		{
			//IL_0024: 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_009b: 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_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_014a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0189: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bc: Unknown result type (might be due to invalid IL or missing references)
			List<VariableSnapshot> list = new List<VariableSnapshot>();
			foreach (KeyValuePair<string, bool> item in currentStore.boolStore)
			{
				list.Add(new VariableSnapshot
				{
					type = typeof(bool),
					value = item.Value,
					name = item.Key
				});
			}
			foreach (KeyValuePair<string, int> item2 in currentStore.intStore)
			{
				list.Add(new VariableSnapshot
				{
					type = typeof(int),
					value = item2.Value,
					name = item2.Key
				});
			}
			foreach (KeyValuePair<string, float> item3 in currentStore.floatStore)
			{
				list.Add(new VariableSnapshot
				{
					type = typeof(float),
					value = item3.Value,
					name = item3.Key
				});
			}
			foreach (KeyValuePair<string, string> item4 in currentStore.stringStore)
			{
				list.Add(new VariableSnapshot
				{
					type = typeof(string),
					value = item4.Value,
					name = item4.Key
				});
			}
			return list;
		}

		public virtual void ReloadMapVars()
		{
			ResetStores();
		}

		public virtual void ResetStores()
		{
			currentStore.Clear();
			stashedStore = null;
		}

		public bool? GetBool(string key)
		{
			if (currentStore.boolStore.TryGetValue(key, out var value))
			{
				return value;
			}
			return null;
		}

		public int? GetInt(string key)
		{
			if (currentStore.intStore.TryGetValue(key, out var value))
			{
				return value;
			}
			return null;
		}

		public float? GetFloat(string key)
		{
			if (currentStore.floatStore.TryGetValue(key, out var value))
			{
				return value;
			}
			return null;
		}

		public string GetString(string key)
		{
			if (currentStore.stringStore.TryGetValue(key, out var value))
			{
				return value;
			}
			return null;
		}

		public virtual void SetBool(string key, bool value)
		{
			currentStore.boolStore[key] = value;
			if (MonoSingleton<MapVarManager>.Instance.boolSubscribers.ContainsKey(key))
			{
				foreach (UnityAction<bool> item in MonoSingleton<MapVarManager>.Instance.boolSubscribers[key])
				{
					item?.Invoke(value);
				}
			}
			if (MonoSingleton<MapVarManager>.Instance.globalSubscribers.Count <= 0)
			{
				return;
			}
			foreach (UnityAction<string, object> globalSubscriber in MonoSingleton<MapVarManager>.Instance.globalSubscribers)
			{
				globalSubscriber?.Invoke(key, (object)value);
			}
		}

		public virtual void SetInt(string key, int value)
		{
			currentStore.intStore[key] = value;
			if (MonoSingleton<MapVarManager>.Instance.intSubscribers.ContainsKey(key))
			{
				foreach (UnityAction<int> item in MonoSingleton<MapVarManager>.Instance.intSubscribers[key])
				{
					item?.Invoke(value);
				}
			}
			if (MonoSingleton<MapVarManager>.Instance.globalSubscribers.Count <= 0)
			{
				return;
			}
			foreach (UnityAction<string, object> globalSubscriber in MonoSingleton<MapVarManager>.Instance.globalSubscribers)
			{
				globalSubscriber?.Invoke(key, (object)value);
			}
		}

		public virtual void SetFloat(string key, float value)
		{
			currentStore.floatStore[key] = value;
			if (MonoSingleton<MapVarManager>.Instance.floatSubscribers.ContainsKey(key))
			{
				foreach (UnityAction<float> item in MonoSingleton<MapVarManager>.Instance.floatSubscribers[key])
				{
					item?.Invoke(value);
				}
			}
			if (MonoSingleton<MapVarManager>.Instance.globalSubscribers.Count <= 0)
			{
				return;
			}
			foreach (UnityAction<string, object> globalSubscriber in MonoSingleton<MapVarManager>.Instance.globalSubscribers)
			{
				globalSubscriber?.Invoke(key, (object)value);
			}
		}

		public virtual void SetString(string key, string value)
		{
			currentStore.stringStore[key] = value;
			if (MonoSingleton<MapVarManager>.Instance.stringSubscribers.ContainsKey(key))
			{
				foreach (UnityAction<string> item in MonoSingleton<MapVarManager>.Instance.stringSubscribers[key])
				{
					item?.Invoke(value);
				}
			}
			if (MonoSingleton<MapVarManager>.Instance.globalSubscribers.Count <= 0)
			{
				return;
			}
			foreach (UnityAction<string, object> globalSubscriber in MonoSingleton<MapVarManager>.Instance.globalSubscribers)
			{
				globalSubscriber?.Invoke(key, (object)value);
			}
		}
	}
	internal class PersistentMapVarHandler : MapVarHandler
	{
		public string FilePath;

		public PersistentMapVarHandler(string filePath)
		{
			FilePath = filePath;
		}

		public override void SetBool(string key, bool value)
		{
			bool flag = true;
			if (currentStore.boolStore.ContainsKey(key) && currentStore.boolStore[key] == value)
			{
				flag = false;
			}
			base.SetBool(key, value);
			if (flag)
			{
				Save();
			}
		}

		public override void SetInt(string key, int value)
		{
			bool flag = true;
			if (currentStore.intStore.ContainsKey(key) && currentStore.intStore[key] == value)
			{
				flag = false;
			}
			base.SetInt(key, value);
			if (flag)
			{
				Save();
			}
		}

		public override void SetFloat(string key, float value)
		{
			bool flag = true;
			if (currentStore.floatStore.ContainsKey(key) && currentStore.floatStore[key] == value)
			{
				flag = false;
			}
			base.SetFloat(key, value);
			if (flag)
			{
				Save();
			}
		}

		public override void SetString(string key, string value)
		{
			bool flag = true;
			if (currentStore.stringStore.ContainsKey(key) && currentStore.stringStore[key] == value)
			{
				flag = false;
			}
			base.SetString(key, value);
			if (flag)
			{
				Save();
			}
		}

		public override void ReloadMapVars()
		{
			base.ReloadMapVars();
			RestorePersistent();
		}

		public void RestorePersistent()
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Expected O, but got Unknown
			VarStore store = null;
			if (!TryLoadAtPath(GetFilePath(), out store))
			{
				store = new VarStore();
			}
			currentStore = store;
		}

		private bool TryLoadAtPath(string filePath, out VarStore store)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Expected O, but got Unknown
			store = null;
			if (!File.Exists(filePath))
			{
				return false;
			}
			try
			{
				PersistentSavedStore val = JsonConvert.DeserializeObject<PersistentSavedStore>(File.ReadAllText(filePath));
				if (val == null)
				{
					return false;
				}
				store = new VarStore();
				foreach (SavedVariable variable in val.variables)
				{
					if (variable != null)
					{
						LoadVariable(variable, store);
					}
				}
				return true;
			}
			catch (Exception ex)
			{
				Plugin.logger.LogError((object)("Failed to load mapvars at " + filePath + " with exception: " + ex));
			}
			return false;
		}

		private static void LoadVariable(SavedVariable variable, VarStore store)
		{
			switch (variable.value.type)
			{
			case "System.Boolean":
				store.boolStore[variable.name] = bool.Parse(variable.value.value.ToString());
				break;
			case "System.Int32":
				store.intStore[variable.name] = int.Parse(variable.value.value.ToString());
				break;
			case "System.Single":
				store.floatStore[variable.name] = float.Parse(variable.value.value.ToString());
				break;
			case "System.String":
				store.stringStore[variable.name] = variable.value.value.ToString();
				break;
			}
		}

		private void WriteStore(string filePath, VarStore store)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Expected O, but got Unknown
			//IL_0066: Expected O, but got Unknown
			//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_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Expected O, but got Unknown
			//IL_00e0: Expected O, but got Unknown
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0156: Expected O, but got Unknown
			//IL_015b: Expected O, but got Unknown
			//IL_018d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0192: Unknown result type (might be due to invalid IL or missing references)
			//IL_019f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cc: Expected O, but got Unknown
			//IL_01d1: Expected O, but got Unknown
			//IL_01f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0205: Expected O, but got Unknown
			List<SavedVariable> list = new List<SavedVariable>();
			foreach (KeyValuePair<string, bool> item in store.boolStore)
			{
				list.Add(new SavedVariable
				{
					name = item.Key,
					value = new SavedValue
					{
						type = typeof(bool).FullName,
						value = item.Value
					}
				});
			}
			foreach (KeyValuePair<string, int> item2 in store.intStore)
			{
				list.Add(new SavedVariable
				{
					name = item2.Key,
					value = new SavedValue
					{
						type = typeof(int).FullName,
						value = item2.Value
					}
				});
			}
			foreach (KeyValuePair<string, float> item3 in store.floatStore)
			{
				list.Add(new SavedVariable
				{
					name = item3.Key,
					value = new SavedValue
					{
						type = typeof(float).FullName,
						value = item3.Value
					}
				});
			}
			foreach (KeyValuePair<string, string> item4 in store.stringStore)
			{
				list.Add(new SavedVariable
				{
					name = item4.Key,
					value = new SavedValue
					{
						type = typeof(string).FullName,
						value = item4.Value
					}
				});
			}
			if (list.Count == 0)
			{
				return;
			}
			try
			{
				string contents = JsonConvert.SerializeObject((object)new PersistentSavedStore
				{
					variables = list
				});
				File.WriteAllText(filePath, contents);
			}
			catch (Exception ex)
			{
				Plugin.logger.LogError((object)("Failed to save mapvars at " + filePath + " with exception: " + ex));
			}
		}

		public virtual string GetFilePath()
		{
			return FilePath;
		}

		private string GetFolder()
		{
			return Path.GetDirectoryName(GetFilePath());
		}

		public void Save()
		{
			AngryIOUtils.TryCreateDirectory(GetFolder());
			UpdateWriteVarStore(GetFilePath(), currentStore);
		}

		private void UpdateWriteVarStore(string filePath, VarStore store)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Expected O, but got Unknown
			if (!TryLoadAtPath(filePath, out var store2))
			{
				store2 = new VarStore();
			}
			store2.Update(store);
			WriteStore(filePath, store2);
		}
	}
}
namespace AngryLevelLoader.Containers
{
	public class BundleContainer
	{
		public const int MIN_ANGRY_FILE_VERSION = 6;

		public const int MAX_ANGRY_FILE_VERSION = 7;

		private IResourceLocator locator;

		private Dictionary<string, AsyncOperationHandle<RudeLevelData>> dataDictionary = new Dictionary<string, AsyncOperationHandle<RudeLevelData>>();

		private string pathToTempFolder;

		internal string pathToAngryBundle;

		public readonly string bundleGuid;

		private AngryBundleData bundleData;

		private Dictionary<string, LevelContainer> levels = new Dictionary<string, LevelContainer>();

		private static Regex richText = new Regex("<[^>]*>");

		private string[] _searchKeywords = new string[0];

		private BoolField favourite;

		private ConfigPanelForBundles rootPanel;

		private LoadingCircleField loadingCircle;

		private ConfigHeader statusText;

		private ConfigDivision sceneDiv;

		private IntField finalRankScore;

		private Task<bool> updateTask;

		public bool Loaded => locator != null;

		public bool LazyLoaded => bundleData != null;

		public bool HasValidAngryFile
		{
			get
			{
				if (!string.IsNullOrEmpty(pathToAngryBundle))
				{
					return File.Exists(pathToAngryBundle);
				}
				return false;
			}
		}

		public bool AngryFileSupported
		{
			get
			{
				if (bundleData != null)
				{
					if (bundleData.bundleVersion >= 6)
					{
						return bundleData.bundleVersion <= 7;
					}
					return false;
				}
				return false;
			}
		}

		internal bool IgnoreFileChange { get; set; }

		public bool FileChangeDetected { get; private set; }

		public int BundleVersion
		{
			get
			{
				if (bundleData != null)
				{
					return bundleData.bundleVersion;
				}
				return 0;
			}
		}

		public string BundleName
		{
			get
			{
				if (bundleData != null)
				{
					return bundleData.bundleName;
				}
				return "<invalid>";
			}
		}

		public string BundleAuthor
		{
			get
			{
				if (bundleData != null)
				{
					return bundleData.bundleAuthor;
				}
				return "<invalid>";
			}
		}

		public bool EpilepsyWarning
		{
			get
			{
				if (bundleData != null)
				{
					return bundleData.epilepsyWarning;
				}
				return false;
			}
		}

		public string BuildHash
		{
			get
			{
				if (bundleData != null)
				{
					return bundleData.buildHash;
				}
				return string.Empty;
			}
		}

		internal bool Favourite
		{
			get
			{
				return favourite.value;
			}
			set
			{
				if (favourite.value != value)
				{
					favourite.value = value;
					AngryBundleList.SortBundles();
				}
			}
		}

		internal bool SearchMatch { get; private set; } = true;


		internal string[] SearchKeywords
		{
			get
			{
				return _searchKeywords;
			}
			set
			{
				_searchKeywords = value;
				SearchMatch = true;
				((ConfigField)rootPanel).displayName = BundleName;
				ConfigPanelForBundles configPanelForBundles = rootPanel;
				((ConfigField)configPanelForBundles).displayName = ((ConfigField)configPanelForBundles).displayName + "\n<color=#909090>by " + BundleAuthor + "</color>";
				((ConfigField)rootPanel).hidden = false;
				if (_searchKeywords.Length == 0)
				{
					return;
				}
				string text = richText.Replace(BundleName, string.Empty);
				string text2 = richText.Replace(BundleAuthor, string.Empty);
				WordHighlighter wordHighlighter = new WordHighlighter(text);
				WordHighlighter wordHighlighter2 = new WordHighlighter(text2);
				text = text.ToLower();
				text2 = text2.ToLower();
				string[] searchKeywords = _searchKeywords;
				foreach (string text3 in searchKeywords)
				{
					bool flag = false;
					for (int num = text.IndexOf(text3); num != -1; num = text.IndexOf(text3, num + text3.Length))
					{
						flag = true;
						wordHighlighter.Highlight(num, num + text3.Length - 1);
					}
					for (int num = text2.IndexOf(text3); num != -1; num = text2.IndexOf(text3, num + text3.Length))
					{
						flag = true;
						wordHighlighter2.Highlight(num, num + text3.Length - 1);
					}
					if (!flag)
					{
						SearchMatch = false;
						((ConfigField)rootPanel).hidden = true;
						return;
					}
				}
				((ConfigField)rootPanel).displayName = wordHighlighter.GenerateFormattedText("<color=yellow><b>", "</b></color>");
				ConfigPanelForBundles configPanelForBundles2 = rootPanel;
				((ConfigField)configPanelForBundles2).displayName = ((ConfigField)configPanelForBundles2).displayName + "\n<color=#909090>by " + wordHighlighter2.GenerateFormattedText("<color=yellow><b>", "</b></color>") + "</color>";
			}
		}

		internal Sprite Icon => ((ConfigPanel)rootPanel).icon;

		internal bool Hidden
		{
			get
			{
				return ((ConfigField)rootPanel).hidden;
			}
			set
			{
				((ConfigField)rootPanel).hidden = value;
			}
		}

		internal int SiblingIndex
		{
			get
			{
				return ((ConfigField)rootPanel).siblingIndex;
			}
			set
			{
				((ConfigField)rootPanel).siblingIndex = value;
			}
		}

		public bool LazyUILoadingSupported => BundleVersion > 7;

		public bool Updating
		{
			get
			{
				if (updateTask != null)
				{
					return !updateTask.IsCompleted;
				}
				return false;
			}
		}

		internal bool TryGetRudeLevelData(string levelId, out RudeLevelData rudeLevelData)
		{
			if (dataDictionary.TryGetValue(levelId, out var value))
			{
				rudeLevelData = value.Result;
				return true;
			}
			rudeLevelData = null;
			return false;
		}

		internal IEnumerable<RudeLevelData> GetAllRudeLevelData()
		{
			return dataDictionary.Values.Select((AsyncOperationHandle<RudeLevelData> handler) => handler.Result);
		}

		internal IEnumerable<string> GetAllScenePaths()
		{
			return from data in GetAllRudeLevelData()
				select data.scenePath;
		}

		public IEnumerable<LevelContainer> GetAllLevelContainers()
		{
			return levels.Values;
		}

		public bool TryGetLevelContainer(string levelId, out LevelContainer levelContainer)
		{
			return levels.TryGetValue(levelId, out levelContainer);
		}

		internal bool RecalculateFinalRank()
		{
			int num = 0;
			int num2 = 0;
			if (LazyUILoadingSupported)
			{
				if (!LazyLoaded)
				{
					return false;
				}
				foreach (AngryLevelData level in bundleData.levels)
				{
					if (!level.isSecretLevel)
					{
						num += 6;
						if (levels.TryGetValue(level.uniqueIdentifier, out var value))
						{
							num2 += Math.Max(0, AngryRankUtils.GetRankScore(value.FinalRank));
						}
					}
				}
			}
			else
			{
				if (!Loaded)
				{
					return false;
				}
				foreach (RudeLevelData allRudeLevelDatum in GetAllRudeLevelData())
				{
					if (!allRudeLevelDatum.isSecretLevel)
					{
						num += 6;
						if (levels.TryGetValue(allRudeLevelDatum.uniqueIdentifier, out var value2))
						{
							num2 += Math.Max(0, AngryRankUtils.GetRankScore(value2.FinalRank));
						}
					}
				}
			}
			finalRankScore.value = ((num > 0) ? ((int)((float)num2 / (float)num * 6f)) : 0);
			return true;
		}

		internal void UpdateAllUI()
		{
			foreach (KeyValuePair<string, LevelContainer> level in levels)
			{
				level.Deconstruct(out var key, out var value);
				string text = key;
				LevelContainer levelContainer = value;
				bool locked = false;
				string[] requiredCompletedLevelIdsForUnlock = levelContainer.LevelData.requiredCompletedLevelIdsForUnlock;
				foreach (string text2 in requiredCompletedLevelIdsForUnlock)
				{
					if (levels.TryGetValue(text2, out var value2))
					{
						if (value2.FinalRank == '-')
						{
							locked = true;
							break;
						}
						continue;
					}
					Plugin.logger.LogWarning((object)("Could not find level unlock requirement id for " + text + ", requested id was " + text2));
					locked = true;
					break;
				}
				levelContainer.Locked = locked;
			}
			RecalculateFinalRank();
		}

		private async Task Unload()
		{
			foreach (AsyncOperationHandle<RudeLevelData> value in dataDictionary.Values)
			{
				Addressables.Release<RudeLevelData>(value);
			}
			dataDictionary.Clear();
			if (locator != null)
			{
				Addressables.RemoveResourceLocator(locator);
				while (!Caching.ready)
				{
					await Task.Yield();
				}
				await AssetManager.CleanBundleCache();
			}
			locator = null;
			FileChangeDetected = false;
		}

		private async Task<bool> ReloadData(bool forceReload, bool lazyLoad)
		{
			if (!AngryFileUtils.TryGetAngryBundleData(pathToAngryBundle, out var latestData, out var error))
			{
				statusText.text = "<color=red>Invalid angry file!</color>";
				if (error != null)
				{
					ConfigHeader val = statusText;
					val.text = val.text + "\n" + error.GetType().Name + ": " + error.Message + "\n" + error.StackTrace;
				}
				((ConfigField)statusText).hidden = false;
				return false;
			}
			await Unload();
			bool flag = true;
			bool fileChanged = false;
			pathToTempFolder = Path.Combine(Plugin.tempFolderPath, latestData.bundleGuid);
			((ConfigField)rootPanel).displayName = (string.IsNullOrEmpty(latestData.bundleName) ? Path.GetFileNameWithoutExtension(pathToAngryBundle) : latestData.bundleName);
			((ConfigPanel)rootPanel).headerText = "--" + ((ConfigField)rootPanel).displayName + "--";
			ConfigPanelForBundles configPanelForBundles = rootPanel;
			((ConfigField)configPanelForBundles).displayName = ((ConfigField)configPanelForBundles).displayName + "\n<color=#909090>by " + latestData.bundleAuthor + "</color>";
			if (Directory.Exists(pathToTempFolder) && File.Exists(Path.Combine(pathToTempFolder, "data.json")) && File.Exists(Path.Combine(pathToTempFolder, "catalog.json")))
			{
				if (JsonConvert.DeserializeObject<AngryBundleData>(File.ReadAllText(Path.Combine(pathToTempFolder, "data.json"))).buildHash == latestData.buildHash)
				{
					if (!forceReload)
					{
						flag = false;
					}
				}
				else
				{
					fileChanged = true;
				}
			}
			else
			{
				fileChanged = true;
			}
			if (flag)
			{
				if (Directory.Exists(pathToTempFolder))
				{
					Directory.Delete(pathToTempFolder, recursive: true);
				}
				int retries = 50;
				while (Directory.Exists(pathToTempFolder) && retries-- > 0)
				{
					await Task.Delay(100);
					Directory.Delete(pathToTempFolder, recursive: true);
				}
				if (retries <= 0 && Directory.Exists(pathToTempFolder))
				{
					statusText.text = "<color=red>Failed to clear temporary folder, try reloading again</color>";
					((ConfigField)statusText).hidden = false;
					return false;
				}
				Directory.CreateDirectory(pathToTempFolder);
				using ZipArchive source = new ZipArchive(File.Open(pathToAngryBundle, FileMode.Open, FileAccess.Read));
				source.ExtractToDirectory(pathToTempFolder);
			}
			if (fileChanged)
			{
				LastPlayedMapManager.UpdateLastUpdate(this);
			}
			bundleData = JsonConvert.DeserializeObject<AngryBundleData>(File.ReadAllText(Path.Combine(pathToTempFolder, "data.json")));
			((ConfigPanel)rootPanel).SetIconWithURL("file://" + Path.Combine(pathToTempFolder, "icon.png"));
			rootPanel.forceHidden = !AngryFileSupported;
			((ConfigPanel)rootPanel).headerText = "--" + BundleName + "--";
			SearchKeywords = SearchKeywords;
			if (!AngryFileSupported && (Object)(object)((ConfigPanel)rootPanel).currentPanel != (Object)null && (Object)(object)PluginConfiguratorController.activePanel == (Object)(object)((Component)((ConfigPanel)rootPanel).currentPanel).gameObject)
			{
				ConfigManager.config.rootPanel.OpenPanel();
			}
			if (!AngryFileSupported)
			{
				return false;
			}
			if (lazyLoad)
			{
				return true;
			}
			AsyncOperationHandle<IResourceLocator> addressableHandle = Addressables.LoadContentCatalogAsync(Path.Combine(pathToTempFolder, "catalog.json"), false, (string)null);
			await addressableHandle;
			locator = addressableHandle.Result;
			statusText.text = "";
			((ConfigField)statusText).hidden = true;
			foreach (string levelDataPath in bundleData.levelDataPaths)
			{
				AsyncOperationHandle<RudeLevelData> handle = Addressables.LoadAssetAsync<RudeLevelData>((object)levelDataPath);
				await handle;
				RudeLevelData result = handle.Result;
				if ((Object)(object)result == (Object)null)
				{
					handle.Release();
				}
				else
				{
					dataDictionary[result.uniqueIdentifier] = handle;
				}
			}
			if (bundleData.bundleVersion < 7)
			{
				((ConfigField)statusText).hidden = false;
				if (!string.IsNullOrEmpty(statusText.text))
				{
					ConfigHeader obj = statusText;
					obj.text += "\n";
				}
				if (bundleData.bundleVersion == 6)
				{
					ConfigHeader obj2 = statusText;
					obj2.text += "<color=yellow>Warning: </color>Bundle was made for the Revamp update of Ultrakill. Expect issues.";
				}
				else
				{
					ConfigHeader obj3 = statusText;
					obj3.text += "<color=yellow>Warning: </color>Bundle was made for an older version of Ultrakill. Expect issues.";
				}
			}
			return true;
		}

		private async Task<bool> ReloadBundleTask(bool forceReload, bool lazyLoad)
		{
			if (!File.Exists(pathToAngryBundle))
			{
				statusText.text = "<color=red>Could not find the file</color>";
				return false;
			}
			if (AngryFileUtils.TryGetAngryBundleData(pathToAngryBundle, out var data, out var _) && data.bundleGuid != bundleData.bundleGuid)
			{
				statusText.text = "<color=red>Target file has a different guid</color>";
				return false;
			}
			bool inTempScene = false;
			Scene activeScene = SceneManager.GetActiveScene();
			string path = ((Scene)(ref activeScene)).path;
			activeScene = SceneManager.GetActiveScene();
			_ = ((Scene)(ref activeScene)).name;
			string previousId = (AngrySceneManager.isInCustomLevel ? AngrySceneManager.currentLevelData.uniqueIdentifier : "");
			if (GetAllScenePaths().Contains(path))
			{
				await AngryAsyncUtils.LoadSceneAsync(ConfigManager.reloadAlwaysGoToMainMenu.value ? "Main Menu" : "AngryLevelLoader/Blank");
				await Task.Yield();
				if (AngrySceneManager.isInCustomLevel)
				{
					Plugin.logger.LogError((object)"Failed to switch to blank scene, have no other option other than returning to main menu");
					await AngryAsyncUtils.LoadSceneAsync("Main Menu");
					SceneHelper.ShowLoadingBlocker();
					await Task.Yield();
				}
				inTempScene = true;
			}
			bool flag = await ReloadData(forceReload, lazyLoad);
			foreach (KeyValuePair<string, LevelContainer> level in levels)
			{
				level.Value.ForceHidden = true;
			}
			if (!flag)
			{
				if (inTempScene)
				{
					await AngryAsyncUtils.LoadSceneAsync("Main Menu");
				}
				return false;
			}
			if (OnlineLevelsList.onlineLevels.TryGetValue(bundleGuid, out var value))
			{
				value.UpdateStatus();
				OnlineLevelsList.CheckLevelUpdateText();
			}
			if (LazyUILoadingSupported)
			{
				((ConfigField)sceneDiv).hidden = true;
				int num = 0;
				foreach (AngryLevelData item in bundleData.levels.OrderBy((AngryLevelData d) => d.prefferedLevelOrder))
				{
					if (!levels.TryGetValue(item.uniqueIdentifier, out var value2))
					{
						value2 = (levels[item.uniqueIdentifier] = new LevelContainer((ConfigPanel)(object)sceneDiv, this, item));
					}
					else
					{
						value2.UpdateData(item);
					}
					if (lazyLoad || !dataDictionary.TryGetValue(item.uniqueIdentifier, out var value3))
					{
						value2.LoadPreviewImageFromUrl("file://" + Path.Combine(pathToTempFolder, "LevelThumbnails", AngryCryptographyUtils.GetMD5String(item.uniqueIdentifier)) + ".png");
					}
					else
					{
						value2.PreviewImage = value3.Result.levelPreviewImage;
					}
					value2.SiblingIndex = num++;
					value2.ForceHidden = false;
				}
				((ConfigField)sceneDiv).hidden = false;
				UpdateAllUI();
			}
			if (lazyLoad)
			{
				if (inTempScene)
				{
					SceneHelper.LoadScene("Main Menu", true);
				}
				return true;
			}
			if (!LazyUILoadingSupported)
			{
				((ConfigField)sceneDiv).hidden = true;
				int num2 = 0;
				foreach (RudeLevelData item2 in from d in GetAllRudeLevelData()
					orderby d.prefferedLevelOrder
					select d)
				{
					if (levels.TryGetValue(item2.uniqueIdentifier, out var value4))
					{
						value4.UpdateData(AngryLevelData.FromRudeLevelData(item2));
					}
					else
					{
						value4 = (levels[item2.uniqueIdentifier] = new LevelContainer((ConfigPanel)(object)sceneDiv, this, AngryLevelData.FromRudeLevelData(item2)));
					}
					value4.PreviewImage = item2.levelPreviewImage;
					value4.SiblingIndex = num2++;
					value4.ForceHidden = false;
				}
				((ConfigField)sceneDiv).hidden = false;
				UpdateAllUI();
			}
			if (inTempScene)
			{
				RudeLevelData val = (from l in GetAllRudeLevelData()
					where l.uniqueIdentifier == previousId
					select l).FirstOrDefault();
				if ((Object)(object)val == (Object)null)
				{
					SceneHelper.LoadScene("Main Menu", true);
				}
				else
				{
					SceneHelper.LoadScene(val.scenePath, true);
				}
			}
			return true;
		}

		public Task<bool> ReloadBundle(bool forceReload, bool lazyLoad)
		{
			if (Updating)
			{
				return updateTask;
			}
			((ConfigField)statusText).hidden = true;
			statusText.text = "";
			updateTask = ReloadBundleTask(forceReload, lazyLoad);
			return updateTask;
		}

		internal async Task DeleteBundle()
		{
			if (File.Exists(pathToAngryBundle))
			{
				File.Delete(pathToAngryBundle);
			}
			if (Directory.Exists(pathToTempFolder))
			{
				Directory.Delete(pathToTempFolder, recursive: true);
			}
			if (OnlineLevelsList.onlineLevels.TryGetValue(bundleData.bundleGuid, out var value))
			{
				value.UpdateStatus();
			}
			pathToAngryBundle = "";
			pathToTempFolder = "";
			bundleData = null;
			rootPanel.forceHidden = true;
			await Unload();
		}

		internal void OpenDeletePanel()
		{
			NotificationPanel.Open((Notification)(object)new DeleteBundleNotification(this));
		}

		internal void FileChanged()
		{
			IgnoreFileChange = false;
			if (!AngryFileUtils.TryGetAngryBundleData(pathToAngryBundle, out var data, out var _))
			{
				return;
			}
			if (data.bundleGuid != bundleGuid)
			{
				Plugin.logger.LogError((object)("File " + Path.GetFileName(pathToAngryBundle) + " was changed, but the new file's guid does not match its container! Unlinking"));
				FileChangeDetected = false;
				pathToAngryBundle = "";
				return;
			}
			FileChangeDetected = data.buildHash != bundleData.buildHash;
			if (FileChangeDetected)
			{
				LastPlayedMapManager.UpdateLastUpdate(this);
				if (AngrySceneManager.isInCustomLevel && AngrySceneManager.currentBundleContainer == this)
				{
					AngryUI.ShowReloadBundlePrompt();
				}
			}
		}

		internal BundleContainer(string path, AngryBundleData data)
		{
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Expected O, but got Unknown
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Expected O, but got Unknown
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: Expected O, but got Unknown
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_012f: Expected O, but got Unknown
			//IL_0187: Unknown result type (might be due to invalid IL or missing references)
			//IL_018c: Unknown result type (might be due to invalid IL or missing references)
			//IL_019a: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a4: Expected O, but got Unknown
			//IL_01b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bb: Expected O, but got Unknown
			//IL_01d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fc: Expected O, but got Unknown
			//IL_0241: Unknown result type (might be due to invalid IL or missing references)
			//IL_024b: Expected O, but got Unknown
			Plugin.logger.LogInfo((object)("Creating bundle container for " + path));
			pathToAngryBundle = path;
			bundleData = data;
			bundleGuid = bundleData.bundleGuid;
			favourite = new BoolField(InternalConfigManager.internalConfig.rootPanel, bundleGuid + "_fav", bundleGuid + "_fav", false);
			rootPanel = new ConfigPanelForBundles(this, (ConfigPanel)(object)ConfigManager.bundleDivision, data.bundleName, data.bundleGuid);
			rootPanel.Favourite = Favourite;
			rootPanel.forceHidden = true;
			((ConfigPanel)rootPanel).onPannelOpenEvent += (OpenPanelEventDelegate)delegate
			{
				if (!LazyUILoadingSupported && !Loaded && (updateTask == null || !updateTask.IsCompleted || updateTask.Result))
				{
					ReloadBundle(forceReload: false, lazyLoad: false);
				}
			};
			finalRankScore = new IntField((ConfigPanel)(object)rootPanel, "final bundle rank", ((ConfigField)rootPanel).guid + "_finalRankCache", 0, true, false);
			finalRankScore.postValueChangeEvent += (PostIntValueChangeEvent)delegate(int val)
			{
				//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_0095: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
				//IL_0049: Unknown result type (might be due to invalid IL or missing references)
				//IL_0074: Unknown result type (might be due to invalid IL or missing references)
				//IL_0084: Unknown result type (might be due to invalid IL or missing references)
				char rankChar = AngryRankUtils.GetRankChar(val);
				rootPanel.rankText = rankChar.ToString();
				rootPanel.rankTextColor = AngryRankUtils.GetRankColor(rankChar, Color.white);
				if (rankChar == 'P')
				{
					((ConfigPanel)rootPanel).fieldColor = new Color(57f / 85f, 36f / 85f, 0.007843138f);
					rootPanel.fillBgCenter = true;
					rootPanel.rankBgColor = new Color(0.94509804f, 56f / 85f, 0.03137255f);
					rootPanel.rankTextColor = Color.white;
				}
				else
				{
					((ConfigPanel)rootPanel).fieldColor = Color.black;
					rootPanel.fillBgCenter = false;
					rootPanel.rankBgColor = Color.white;
				}
			};
			finalRankScore.TriggerPostValueChangeEvent();
			ButtonArrayField val2 = new ButtonArrayField((ConfigPanel)(object)rootPanel, ((ConfigField)rootPanel).guid + "_reloadButtons", 2, new float[2] { 0.5f, 0.5f }, new string[2] { "Reload File", "Force Reload File" }, 5f);
			val2.OnClickEventHandler(0).onClick += (OnClick)delegate
			{
				ReloadBundle(forceReload: false, lazyLoad: false);
			};
			val2.OnClickEventHandler(1).onClick += (OnClick)delegate
			{
				ReloadBundle(forceReload: true, lazyLoad: false);
			};
			new SpaceField((ConfigPanel)(object)rootPanel, 5f);
			new ConfigHeader((ConfigPanel)(object)rootPanel, "Levels", 24);
			statusText = new ConfigHeader((ConfigPanel)(object)rootPanel, "", 16, (TextAlignmentOptions)513);
			((ConfigField)statusText).hidden = true;
			loadingCircle = new LoadingCircleField((ConfigPanel)(object)rootPanel);
			((ConfigField)loadingCircle).hidden = true;
			sceneDiv = new ConfigDivision((ConfigPanel)(object)rootPanel, "sceneDiv_" + ((ConfigField)rootPanel).guid);
		}
	}
	public class LevelContainer
	{
		public readonly BundleContainer bundleContainer;

		public readonly string levelId;

		private readonly LevelField field;

		private AngryLevelData data;

		private FloatField time;

		private StringField timeRank;

		private IntField kills;

		private StringField killsRank;

		private IntField style;

		private StringField styleRank;

		private StringField finalRank;

		private StringField secrets;

		private BoolField challenge;

		private BoolField discovered;

		private Texture2D _previewImageTexture;

		private Sprite _previewImageSprite;

		private bool _locked;

		internal AngryLevelData LevelData => data;

		public string LevelName
		{
			get
			{
				if (data != null)
				{
					return data.levelName;
				}
				return string.Empty;
			}
		}

		public string[] RequiredScripts
		{
			get
			{
				if (data != null)
				{
					return data.requiredDllNames;
				}
				return new string[0];
			}
		}

		public Sprite PreviewImage
		{
			get
			{
				return field.PreviewImage;
			}
			internal set
			{
				field.PreviewImage = value;
			}
		}

		public Texture2D PreviewImageTexture
		{
			get
			{
				if (!((Object)(object)field.PreviewImage == (Object)null))
				{
					return field.PreviewImage.texture;
				}
				return null;
			}
			internal set
			{
				//IL_008a: 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)
				if ((Object)(object)_previewImageTexture != (Object)null)
				{
					Object.Destroy((Object)(object)_previewImageTexture);
				}
				if ((Object)(object)_previewImageSprite != (Object)null)
				{
					Object.Destroy((Object)(object)_previewImageSprite);
				}
				_previewImageTexture = value;
				if ((Object)(object)_previewImageTexture != (Object)null)
				{
					((Texture)_previewImageTexture).filterMode = (FilterMode)0;
				}
				_previewImageSprite = (((Object)(object)_previewImageTexture == (Object)null) ? null : Sprite.Create(_previewImageTexture, new Rect(0f, 0f, (float)((Texture)_previewImageTexture).width, (float)((Texture)_previewImageTexture).height), new Vector2(0.5f, 0.5f)));
				PreviewImage = _previewImageSprite;
			}
		}

		public float Time
		{
			get
			{
				return time.value;
			}
			internal set
			{
				time.value = value;
				time.TriggerPostValueChangeEvent();
			}
		}

		public char TimeRank
		{
			get
			{
				if (timeRank.value.Length != 0)
				{
					return timeRank.value[0];
				}
				return '-';
			}
			internal set
			{
				timeRank.value = $"{value}";
				timeRank.TriggerPostValueChangeEvent();
			}
		}

		public int Kills
		{
			get
			{
				return kills.value;
			}
			internal set
			{
				kills.value = value;
				kills.TriggerPostValueChangeEvent();
			}
		}

		public char KillsRank
		{
			get
			{
				if (killsRank.value.Length != 0)
				{
					return killsRank.value[0];
				}
				return '-';
			}
			internal set
			{
				killsRank.value = $"{value}";
				killsRank.TriggerPostValueChangeEvent();
			}
		}

		public int Style
		{
			get
			{
				return style.value;
			}
			internal set
			{
				style.value = value;
				style.TriggerPostValueChangeEvent();
			}
		}

		public char StyleRank
		{
			get
			{
				if (styleRank.value.Length != 0)
				{
					return styleRank.value[0];
				}
				return '-';
			}
			internal set
			{
				styleRank.value = $"{value}";
				styleRank.TriggerPostValueChangeEvent();
			}
		}

		public char FinalRank
		{
			get
			{
				if (finalRank.value.Length != 0)
				{
					return finalRank.value[0];
				}
				return '-';
			}
			set
			{
				finalRank.value = $"{value}";
				finalRank.TriggerPostValueChangeEvent();
				bundleContainer.RecalculateFinalRank();
			}
		}

		public int SecretCount
		{
			get
			{
				if (data != null)
				{
					return data.secretCount;
				}
				return 0;
			}
		}

		public bool ChallengeSupported
		{
			get
			{
				if (data != null)
				{
					return data.levelChallengeEnabled;
				}
				return false;
			}
		}

		public string ChallengeText
		{
			get
			{
				if (data != null)
				{
					return data.levelChallengeText;
				}
				return string.Empty;
			}
		}

		public bool ChallengeDone
		{
			get
			{
				return challenge.value;
			}
			internal set
			{
				challenge.value = value;
				challenge.TriggerPostValueChangeEvent();
			}
		}

		public bool LevelDiscovered
		{
			get
			{
				return discovered.value;
			}
			internal set
			{
				discovered.value = value;
				discovered.TriggerPostValueChangeEvent();
			}
		}

		public bool Locked
		{
			get
			{
				return _locked;
			}
			internal set
			{
				_locked = value;
				field.Locked = value;
			}
		}

		internal int SiblingIndex
		{
			get
			{
				return ((ConfigField)field).siblingIndex;
			}
			set
			{
				((ConfigField)field).siblingIndex = value;
			}
		}

		internal bool ForceHidden
		{
			get
			{
				return field.forceHidden;
			}
			set
			{
				field.forceHidden = value;
			}
		}

		internal void LoadPreviewImageFromUrl(string url)
		{
			UnityWebRequest req = UnityWebRequestTexture.GetTexture(url);
			((AsyncOperation)req.SendWebRequest()).completed += delegate
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: Invalid comparison between Unknown and I4
				if ((int)req.result == 1)
				{
					PreviewImageTexture = DownloadHandlerTexture.GetContent(req);
				}
				req.Dispose();
			};
		}

		private void AssureSecretsSize()
		{
			int length = secrets.value.Length;
			if (length == data.secretCount)
			{
				return;
			}
			Plugin.logger.LogWarning((object)"Inconsistent secrets data detected");
			string text = secrets.value;
			if (length < data.secretCount)
			{
				while (text.Length != data.secretCount)
				{
					text += "F";
				}
				secrets.value = text;
				secrets.defaultValue = text.Replace('T', 'F');
			}
			else
			{
				secrets.value = secrets.value.Substring(0, data.secretCount);
				secrets.defaultValue = secrets.value.Replace('T', 'F');
			}
		}

		public bool SecretDiscovered(int secretNum)
		{
			if (secretNum < 0 || secretNum >= SecretCount)
			{
				return false;
			}
			AssureSecretsSize();
			return secrets.value[secretNum] == 'T';
		}

		internal bool SetSecretDiscovered(int secretNum, bool discovered)
		{
			if (secretNum < 0 || secretNum >= SecretCount)
			{
				return false;
			}
			AssureSecretsSize();
			StringBuilder stringBuilder = new StringBuilder(secrets.value);
			stringBuilder[secretNum] = (discovered ? 'T' : 'F');
			secrets.value = stringBuilder.ToString();
			secrets.TriggerPostValueChangeEvent();
			return true;
		}

		internal void UpdateData(AngryLevelData data)
		{
			if (data.uniqueIdentifier != levelId)
			{
				throw new Exception("Attempted to update data of a level container with another RudeLevelData having wrong unique id");
			}
			this.data = data;
			string text = "";
			for (int i = 0; i < data.secretCount; i++)
			{
				text += "F";
			}
			secrets.defaultValue = text;
			AssureSecretsSize();
			field.LevelName = data.levelName;
			field.IsSecretLevel = data.isSecretLevel;
			field.HideIfNotPlayed = data.hideIfNotPlayed;
			field.DoNotHideLevelPreviewWhenNotCompleted = data.doNotHideLevelPreviewWhenNotCompleted;
			field.ChallengeEnabled = data.levelChallengeEnabled;
			field.ChallengeText = data.levelChallengeText;
		}

		internal LevelContainer(ConfigPanel panel, BundleContainer container, AngryLevelData data)
		{
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Expected O, but got Unknown
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Expected O, but got Unknown
			//IL_0172: Unknown result type (might be due to invalid IL or missing references)
			//IL_0177: Unknown result type (might be due to invalid IL or missing references)
			//IL_0183: Expected O, but got Unknown
			//IL_0190: Unknown result type (might be due to invalid IL or missing references)
			//IL_019a: Expected O, but got Unknown
			//IL_01c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_01da: Expected O, but got Unknown
			//IL_01e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f1: Expected O, but got Unknown
			//IL_0225: Unknown result type (might be due to invalid IL or missing references)
			//IL_022a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0236: Expected O, but got Unknown
			//IL_0243: Unknown result type (might be due to invalid IL or missing references)
			//IL_024d: Expected O, but got Unknown
			//IL_027c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0281: Unknown result type (might be due to invalid IL or missing references)
			//IL_028d: Expected O, but got Unknown
			//IL_029a: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a4: Expected O, but got Unknown
			//IL_02d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e9: Expected O, but got Unknown
			//IL_02f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0300: Expected O, but got Unknown
			//IL_0334: Unknown result type (might be due to invalid IL or missing references)
			//IL_0339: Unknown result type (might be due to invalid IL or missing references)
			//IL_0345: Expected O, but got Unknown
			//IL_0352: Unknown result type (might be due to invalid IL or missing references)
			//IL_035c: Expected O, but got Unknown
			//IL_03b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c5: Expected O, but got Unknown
			//IL_03d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_03dc: Expected O, but got Unknown
			//IL_040b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0410: Unknown result type (might be due to invalid IL or missing references)
			//IL_041c: Expected O, but got Unknown
			//IL_0429: Unknown result type (might be due to invalid IL or missing references)
			//IL_0433: Expected O, but got Unknown
			//IL_0462: Unknown result type (might be due to invalid IL or missing references)
			//IL_0467: Unknown result type (might be due to invalid IL or missing references)
			//IL_0473: Expected O, but got Unknown
			//IL_0480: Unknown result type (might be due to invalid IL or missing references)
			//IL_048a: Expected O, but got Unknown
			LevelContainer levelContainer = this;
			levelId = data.uniqueIdentifier;
			bundleContainer = container;
			field = new LevelField(panel, container, data.uniqueIdentifier);
			field.onLevelButtonPress += delegate
			{
				AngrySceneManager.LevelButtonPressed(levelContainer);
			};
			LevelField levelField = field;
			levelField.onResetStats = (Action)Delegate.Combine(levelField.onResetStats, (Action)delegate
			{
				levelContainer.Time = 0f;
				levelContainer.TimeRank = '-';
				levelContainer.Kills = 0;
				levelContainer.KillsRank = '-';
				levelContainer.Style = 0;
				levelContainer.StyleRank = '-';
				levelContainer.FinalRank = '-';
				container.UpdateAllUI();
			});
			LevelField levelField2 = field;
			levelField2.onResetSecrets = (Action)Delegate.Combine(levelField2.onResetSecrets, (Action)delegate
			{
				levelContainer.secrets.value = "".PadRight(data.secretCount, 'F');
				levelContainer.secrets.TriggerPostValueChangeEvent();
			});
			LevelField levelField3 = field;
			levelField3.onResetChallenge = (Action)Delegate.Combine(levelField3.onResetChallenge, (Action)delegate
			{
				levelContainer.ChallengeDone = false;
			});
			time = new FloatField(panel, "", "l_" + data.uniqueIdentifier + "_time", 0f, true, false)
			{
				hidden = true,
				presetLoadPriority = -1
			};
			time.postValueChangeEvent += (PostFloatValueChangeEvent)delegate(float e)
			{
				levelContainer.field.Time = e;
			};
			time.TriggerPostValueChangeEvent();
			timeRank = new StringField(panel, "", "l_" + data.uniqueIdentifier + "_timeRank", "-", true, true, false)
			{
				hidden = true
			};
			timeRank.postValueChangeEvent += (PostStringValueChangeEvent)delegate(string e)
			{
				levelContainer.field.TimeRank = ((e.Length == 0) ? '-' : e[0]);
			};
			timeRank.TriggerPostValueChangeEvent();
			kills = new IntField(panel, "", "l_" + data.uniqueIdentifier + "_kills", 0, true, false)
			{
				hidden = true
			};
			kills.postValueChangeEvent += (PostIntValueChangeEvent)delegate(int e)
			{
				levelContainer.field.Kills = e;
			};
			kills.TriggerPostValueChangeEvent();
			killsRank = new StringField(panel, "", "l_" + data.uniqueIdentifier + "_killsRank", "-", true, true, false)
			{
				hidden = true
			};
			killsRank.postValueChangeEvent += (PostStringValueChangeEvent)delegate(string e)
			{
				levelContainer.field.KillsRank = ((e.Length == 0) ? '-' : e[0]);
			};
			killsRank.TriggerPostValueChangeEvent();
			style = new IntField(panel, "", "l_" + data.uniqueIdentifier + "_style", 0, true, false)
			{
				hidden = true
			};
			style.postValueChangeEvent += (PostIntValueChangeEvent)delegate(int e)
			{
				levelContainer.field.Style = e;
			};
			style.TriggerPostValueChangeEvent();
			styleRank = new StringField(panel, "", "l_" + data.uniqueIdentifier + "_styleRank", "-", true, true, false)
			{
				hidden = true
			};
			styleRank.postValueChangeEvent += (PostStringValueChangeEvent)delegate(string e)
			{
				levelContainer.field.StyleRank = ((e.Length == 0) ? '-' : e[0]);
			};
			styleRank.TriggerPostValueChangeEvent();
			finalRank = new StringField(panel, "", "l_" + data.uniqueIdentifier + "_finalRank", "-", true, true, false)
			{
				hidden = true
			};
			finalRank.postValueChangeEvent += (PostStringValueChangeEvent)delegate(string e)
			{
				levelContainer.field.FinalRank = ((e.Length == 0) ? '-' : e[0]);
			};
			finalRank.TriggerPostValueChangeEvent();
			string text = "";
			for (int i = 0; i < data.secretCount; i++)
			{
				text += "F";
			}
			secrets = new StringField(panel, "", "l_" + data.uniqueIdentifier + "_secrets", text, true, true, false)
			{
				hidden = true
			};
			secrets.postValueChangeEvent += (PostStringValueChangeEvent)delegate(string e)
			{
				levelContainer.field.SecretsString = e;
			};
			secrets.TriggerPostValueChangeEvent();
			challenge = new BoolField(panel, "", "l_" + data.uniqueIdentifier + "_challenge", false, true, false)
			{
				hidden = true
			};
			challenge.postValueChangeEvent += (PostBoolValueChangeEvent)delegate(bool e)
			{
				levelContainer.field.ChallengeDone = e;
			};
			challenge.TriggerPostValueChangeEvent();
			discovered = new BoolField(panel, "", "l_" + data.uniqueIdentifier + "_discovered", false, true, false)
			{
				hidden = true
			};
			discovered.postValueChangeEvent += (PostBoolValueChangeEvent)delegate(bool e)
			{
				levelContainer.field.Discovered = e;
			};
			discovered.TriggerPostValueChangeEvent();
			UpdateData(data);
		}
	}
}