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.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 AngryUiComponents;
using Atlas.Modules.Guns;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Logging;
using FasterPunch;
using HarmonyLib;
using Logic;
using LucasMeshCombine;
using Microsoft.CodeAnalysis;
using MyCoolMod;
using Newtonsoft.Json;
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 UltraFunGuns;
using UltraTweaker;
using UltraTweaker.Tweaks;
using UltraTweaker.Tweaks.Impl;
using Ultrapain;
using UnityEngine;
using UnityEngine.AddressableAssets;
using UnityEngine.AddressableAssets.ResourceLocators;
using UnityEngine.Audio;
using UnityEngine.EventSystems;
using UnityEngine.Events;
using UnityEngine.Networking;
using UnityEngine.ResourceManagement.AsyncOperations;
using UnityEngine.ResourceManagement.ResourceProviders;
using UnityEngine.SceneManagement;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.0", FrameworkDisplayName = ".NET Standard 2.0")]
[assembly: AssemblyCompany("AngryLevelLoader")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyDescription("Loads level made with Rude level editor")]
[assembly: AssemblyFileVersion("2.9.0.0")]
[assembly: AssemblyInformationalVersion("2.9.0+ecded3ec13adc4ec975193a808e6f47e2c134066")]
[assembly: AssemblyProduct("AngryLevelLoader")]
[assembly: AssemblyTitle("AngryLevelLoader")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("2.9.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
public 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 GameObject backgroundUpdater;

	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()
	{
		//IL_001c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0026: Expected O, but got Unknown
		if (instance == null)
		{
			mainThread = Thread.CurrentThread;
			instance = new CrossThreadInvoker();
			backgroundUpdater = new GameObject();
			Object.DontDestroyOnLoad((Object)(object)backgroundUpdater);
			backgroundUpdater.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
	{
		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 (!Plugin.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, "LevelCatalog.json");

		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");

		public static void TryCreateAllPaths()
		{
			IOUtils.TryCreateDirectory(ConfigFolderPath);
			IOUtils.TryCreateDirectory(OnlineCacheFolderPath);
			IOUtils.TryCreateDirectory(ThumbnailCacheFolderPath);
		}
	}
	public class ManifestReader
	{
		public static byte[] GetBytes(string resourceName)
		{
			using Stream stream = Assembly.GetExecutingAssembly().GetManifestResourceStream("AngryLevelLoader.Resources." + resourceName);
			byte[] array = new byte[stream.Length];
			stream.Read(array, 0, array.Length);
			return array;
		}
	}
	public class SpaceField : CustomConfigField
	{
		public SpaceField(ConfigPanel parentPanel, float space)
			: base(parentPanel, 60f, space)
		{
		}
	}
	[BepInPlugin("com.eternalUnion.angryLevelLoader", "AngryLevelLoader", "2.9.0")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[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
	{
		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
		}

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

		[CompilerGenerated]
		private static class <>O
		{
			public static UnityAction<Scene, LoadSceneMode> <0>__RefreshCatalogOnMainMenu;

			public static OnClick <1>__ProcessPendingRecords;
		}

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

			public static Func<AngryBundleContainer, string> <>9__37_0;

			public static Func<AngryBundleContainer, string> <>9__37_1;

			public static Func<AngryBundleContainer, long> <>9__37_2;

			public static Func<AngryBundleContainer, long> <>9__37_3;

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

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

			public static FileSystemEventHandler <>9__101_0;

			public static RenamedEventHandler <>9__101_1;

			public static FileSystemEventHandler <>9__101_2;

			public static FileSystemEventHandler <>9__101_3;

			public static PostPresetChangeEvent <>9__102_0;

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

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

			public static OpenPanelEventDelegate <>9__102_1;

			public static OpenPanelEventDelegate <>9__102_2;

			public static EnumValueChangeEventDelegate<BundleSorting> <>9__102_3;

			public static PostStringListValueChangeEvent <>9__102_22;

			public static OpenPanelEventDelegate <>9__102_4;

			public static OnClick <>9__102_5;

			public static OnClick <>9__102_6;

			public static KeyCodeValueChangeEventDelegate <>9__102_7;

			public static PostEnumValueChangeEvent<CustomLevelButtonPosition> <>9__102_8;

			public static PostColorValueChangeEvent <>9__102_9;

			public static PostColorValueChangeEvent <>9__102_10;

			public static PostColorValueChangeEvent <>9__102_11;

			public static BoolValueChangeEventDelegate <>9__102_12;

			public static BoolValueChangeEventDelegate <>9__102_13;

			public static BoolValueChangeEventDelegate <>9__102_14;

			public static OnClick <>9__102_17;

			public static Func<RudeLevelData, string> <>9__102_24;

			public static Func<Task, bool> <>9__109_0;

			public static BoolValueChangeEventDelegate <>9__112_0;

			public static PostBoolValueChangeEvent <>9__112_1;

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

			public static OpenPanelEventDelegate <>9__112_4;

			internal string <SortBundles>b__37_0(AngryBundleContainer b)
			{
				return b.bundleData.bundleName;
			}

			internal string <SortBundles>b__37_1(AngryBundleContainer b)
			{
				return b.bundleData.bundleAuthor;
			}

			internal long <SortBundles>b__37_2(AngryBundleContainer b)
			{
				if (lastPlayed.TryGetValue(b.bundleData.bundleGuid, out var value))
				{
					return value;
				}
				return 0L;
			}

			internal long <SortBundles>b__37_3(AngryBundleContainer b)
			{
				if (lastUpdate.TryGetValue(b.bundleData.bundleGuid, out var value))
				{
					return value;
				}
				return 0L;
			}

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

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

			internal void <InitializeFileWatcher>b__101_0(object sender, FileSystemEventArgs e)
			{
				string fullPath = e.FullPath;
				foreach (AngryBundleContainer value in angryBundles.Values)
				{
					if (IOUtils.PathEquals(fullPath, value.pathToAngryBundle))
					{
						logger.LogWarning((object)("Bundle " + fullPath + " was updated, container notified"));
						value.FileChanged();
						break;
					}
				}
			}

			internal void <InitializeFileWatcher>b__101_1(object sender, RenamedEventArgs e)
			{
				string fullPath = e.FullPath;
				foreach (AngryBundleContainer value in angryBundles.Values)
				{
					if (IOUtils.PathEquals(fullPath, value.pathToAngryBundle))
					{
						logger.LogWarning((object)("Bundle " + fullPath + " was renamed, path updated"));
						value.pathToAngryBundle = fullPath;
						break;
					}
				}
			}

			internal void <InitializeFileWatcher>b__101_2(object sender, FileSystemEventArgs e)
			{
				string fullPath = e.FullPath;
				foreach (AngryBundleContainer value in angryBundles.Values)
				{
					if (IOUtils.PathEquals(fullPath, value.pathToAngryBundle))
					{
						logger.LogWarning((object)("Bundle " + fullPath + " was deleted, unlinked"));
						value.pathToAngryBundle = "";
						break;
					}
				}
			}

			internal void <InitializeFileWatcher>b__101_3(object sender, FileSystemEventArgs e)
			{
				string fullPath = e.FullPath;
				if (AngryFileUtils.TryGetAngryBundleData(fullPath, out var data, out var _) && angryBundles.TryGetValue(data.bundleGuid, out var value) && value.bundleData.bundleGuid == data.bundleGuid && !File.Exists(value.pathToAngryBundle))
				{
					logger.LogWarning((object)("Bundle " + fullPath + " was just added, and a container with the same guid had no file linked. Linked, container notified"));
					value.pathToAngryBundle = fullPath;
					value.FileChanged();
				}
			}

			internal void <InitializeConfig>b__102_0(string b, string a)
			{
				UpdateAllUI();
			}

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

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

			internal string <InitializeConfig>b__102_20(string name)
			{
				return "<color=lime>New level: " + name + "</color>";
			}

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

			internal void <InitializeConfig>b__102_3(EnumValueChangeEvent<BundleSorting> e)
			{
				bundleSortingMode.value = e.value;
				SortBundles();
			}

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

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

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

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

			internal void <InitializeConfig>b__102_7(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__102_8(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 CustomLevelButtonPosition.Disabled:
					((Component)currentCustomLevelButton).gameObject.SetActive(false);
					break;
				case CustomLevelButtonPosition.Bottom:
					((Component)currentCustomLevelButton).transform.localPosition = new Vector3(((Component)currentCustomLevelButton).transform.localPosition.x, -303f, ((Component)currentCustomLevelButton).transform.localPosition.z);
					break;
				case 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 == 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 <InitializeConfig>b__102_9(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 <InitializeConfig>b__102_10(Color clr)
			{
				//IL_0018: Unknown result type (might be due to invalid IL or missing references)
				if (!((Object)(object)currentCustomLevelButton == (Object)null))
				{
					((Graphic)currentCustomLevelButton.background).color = clr;
				}
			}

			internal void <InitializeConfig>b__102_11(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;
				}
			}

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

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

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

			internal void <InitializeConfig>b__102_17()
			{
				ScanForLevels();
			}

			internal string <InitializeConfig>b__102_24(RudeLevelData data)
			{
				return data.uniqueIdentifier;
			}

			internal bool <ProcessPendingRecords>b__109_0(Task task)
			{
				return ((ConfigField)sendPendingRecords).interactable = true;
			}

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

			internal void <PostAwake>b__112_1(bool newVal)
			{
				((ConfigField)leaderboardsDivision).hidden = newVal;
			}

			internal void <PostAwake>b__112_2(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)
				{
					return;
				}
				if (AngrySceneManager.isInCustomLevel)
				{
					switch (AngrySceneManager.currentBundleContainer.bundleData.bundleVersion)
					{
					case 2:
						LegacyPatchManager.SetLegacyPatchState(LegacyPatchState.Ver2);
						break;
					case 3:
						LegacyPatchManager.SetLegacyPatchState(LegacyPatchState.Ver3);
						break;
					default:
						LegacyPatchManager.SetLegacyPatchState(LegacyPatchState.None);
						break;
					}
				}
				else
				{
					LegacyPatchManager.SetLegacyPatchState(LegacyPatchState.None);
				}
			}

			internal void <PostAwake>b__112_4(bool externally)
			{
				if (AngryLeaderboards.bannedModsListLoaded)
				{
					CheckForBannedMods();
				}
				else
				{
					AngryLeaderboards.LoadBannedModsList();
				}
			}
		}

		public const string PLUGIN_NAME = "AngryLevelLoader";

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

		public const string PLUGIN_VERSION = "2.9.0";

		public const string PLUGIN_CONFIG_MIN_VERSION = "1.8.0";

		public static readonly Vector3 defaultGravity = new Vector3(0f, -40f, 0f);

		public static string workingDir;

		public static string tempFolderPath;

		public static string dataPath;

		public static string levelsPath;

		public static string mapVarsFolderPath;

		public static string angryCatalogPath;

		public static Plugin instance;

		public static ManualLogSource logger;

		public static PluginConfigurator internalConfig;

		public static BoolField devMode;

		public static StringField lastVersion;

		public static StringField updateLastVersion;

		public static BoolField ignoreUpdates;

		public static StringField configDataPath;

		public static BoolField leaderboardToggle;

		public static BoolField askedPermissionForLeaderboards;

		public static BoolField showLeaderboardOnLevelEnd;

		public static BoolField showLeaderboardOnSecretLevelEnd;

		public static StringField pendingRecordsField;

		public static bool ultrapainLoaded = false;

		public static bool heavenOrHellLoaded = false;

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

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

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

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

		public static int selectedDifficulty = 3;

		public static DifficultyField difficultyField;

		internal static List<string> difficultyList = new List<string> { "HARMLESS", "LENIENT", "STANDARD", "VIOLENT", "BRUTAL" };

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

		public static Harmony harmony;

		public static PluginConfigurator config;

		public static ConfigHeader levelUpdateNotifier;

		public static ConfigHeader newLevelNotifier;

		public static StringField newLevelNotifierLevels;

		public static BoolField newLevelToggle;

		public static ConfigHeader errorText;

		public static ConfigDivision bundleDivision;

		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 ButtonArrayField openButtons;

		public static KeyCodeField reloadFileKeybind;

		public static EnumField<CustomLevelButtonPosition> customLevelButtonPosition;

		public static ColorField customLevelButtonFrameColor;

		public static ColorField customLevelButtonBackgroundColor;

		public static ColorField customLevelButtonTextColor;

		public static BoolField refreshCatalogOnBoot;

		public static BoolField checkForUpdates;

		public static BoolField levelUpdateNotifierToggle;

		public static BoolField levelUpdateIgnoreCustomBuilds;

		public static BoolField newLevelNotifierToggle;

		public static BoolField scriptAutoUpdate;

		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 EnumField<BundleSorting> bundleSortingMode;

		public static EnumField<DefaultLeaderboardCategory> defaultLeaderboardCategory;

		public static EnumField<DefaultLeaderboardDifficulty> defaultLeaderboardDifficulty;

		public static EnumField<DefaultLeaderboardFilter> defaultLeaderboardFilter;

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

		private static AngryCustomLevelButtonComponent currentCustomLevelButton;

		private static RectTransform bossRushButton;

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

		public static AngryUIPanelComponent currentPanel;

		internal static FileSystemWatcher watcher;

		private static Task pendingRecordsTask = null;

		private float lastPress;

		public static bool NoMonsters
		{
			get
			{
				if (difficultyField.gamemodeListValueIndex != 1)
				{
					return difficultyField.gamemodeListValueIndex == 2;
				}
				return true;
			}
		}

		public static bool NoWeapons => difficultyField.gamemodeListValueIndex == 2;

		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)
				{
					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
				{
					logger.LogInfo((object)("Invalid last played time '" + text + "'"));
				}
			}
		}

		public static void UpdateLastPlayed(AngryBundleContainer bundle)
		{
			string bundleGuid = bundle.bundleData.bundleGuid;
			if (bundleGuid.Length != 32)
			{
				return;
			}
			if (bundleSortingMode.value == BundleSorting.LastPlayed)
			{
				((ConfigField)bundle.rootPanel).siblingIndex = 0;
			}
			long value = ((DateTimeOffset)DateTime.UtcNow).ToUnixTimeSeconds();
			lastPlayed[bundleGuid] = value;
			string lastPlayedMapPath = AngryPaths.LastPlayedMapPath;
			IOUtils.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());
			}
		}

		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)
				{
					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
				{
					logger.LogInfo((object)("Invalid last played time '" + text + "'"));
				}
			}
		}

		public static void UpdateLastUpdate(AngryBundleContainer bundle)
		{
			string bundleGuid = bundle.bundleData.bundleGuid;
			if (bundleGuid.Length != 32)
			{
				return;
			}
			if (bundleSortingMode.value == BundleSorting.LastUpdate)
			{
				((ConfigField)bundle.rootPanel).siblingIndex = 0;
			}
			long value = ((DateTimeOffset)DateTime.UtcNow).ToUnixTimeSeconds();
			lastUpdate[bundleGuid] = value;
			string lastUpdateMapPath = AngryPaths.LastUpdateMapPath;
			IOUtils.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());
			}
		}

		public static AngryBundleContainer GetAngryBundleByGuid(string guid)
		{
			return angryBundles.Values.Where((AngryBundleContainer bundle) => bundle.bundleData.bundleGuid == guid).FirstOrDefault();
		}

		public static void ProcessPath(string path)
		{
			if (AngryFileUtils.TryGetAngryBundleData(path, out var data, out var error))
			{
				if (!angryBundles.TryGetValue(data.bundleGuid, out var value))
				{
					AngryBundleContainer angryBundleContainer = new AngryBundleContainer(path, data);
					angryBundles[data.bundleGuid] = angryBundleContainer;
					angryBundleContainer.UpdateOrder();
					try
					{
						if (angryBundleContainer.finalRankScore.value < 0)
						{
							logger.LogWarning((object)"Final rank score for the bundle not cached, skipping lazy reload");
							angryBundleContainer.UpdateScenes(forceReload: false, lazyLoad: false);
						}
						else
						{
							angryBundleContainer.UpdateScenes(forceReload: false, lazyLoad: true);
						}
						return;
					}
					catch (Exception arg)
					{
						logger.LogWarning((object)$"Exception thrown while loading level bundle: {arg}");
						if (!string.IsNullOrEmpty(errorText.text))
						{
							ConfigHeader obj = errorText;
							obj.text += "\n";
						}
						ConfigHeader obj2 = errorText;
						obj2.text = obj2.text + "<color=red>Error loading " + Path.GetFileNameWithoutExtension(path) + "</color>. Check the logs for more information";
						return;
					}
				}
				if (File.Exists(value.pathToAngryBundle) && !IOUtils.PathEquals(path, value.pathToAngryBundle))
				{
					logger.LogError((object)("Duplicate angry files. Original: " + Path.GetFileName(value.pathToAngryBundle) + ". Duplicate: " + Path.GetFileName(path)));
					if (!string.IsNullOrEmpty(errorText.text))
					{
						ConfigHeader obj3 = errorText;
						obj3.text += "\n";
					}
					ConfigHeader val = errorText;
					val.text = val.text + "<color=red>Error loading " + Path.GetFileName(path) + "</color> Duplicate file, original is " + Path.GetFileName(value.pathToAngryBundle);
				}
				else
				{
					bool num = !IOUtils.PathEquals(value.pathToAngryBundle, path);
					value.pathToAngryBundle = path;
					((ConfigField)value.rootPanel).interactable = true;
					((ConfigField)value.rootPanel).hidden = false;
					if (num)
					{
						value.UpdateScenes(forceReload: false, lazyLoad: false);
					}
				}
			}
			else if (AngryFileUtils.IsV1LegacyFile(path))
			{
				if (!string.IsNullOrEmpty(errorText.text))
				{
					ConfigHeader obj4 = errorText;
					obj4.text += "\n";
				}
				ConfigHeader obj5 = errorText;
				obj5.text = obj5.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(errorText.text))
				{
					ConfigHeader obj6 = errorText;
					obj6.text += "\n";
				}
				ConfigHeader obj7 = errorText;
				obj7.text = obj7.text + "<color=yellow>Failed to load " + Path.GetFileNameWithoutExtension(path) + "</color>";
			}
		}

		public static void ScanForLevels()
		{
			errorText.text = "";
			if (!Directory.Exists(levelsPath))
			{
				logger.LogWarning((object)("Could not find the Levels folder at " + levelsPath));
				errorText.text = "<color=red>Error: </color>Levels folder not found";
				return;
			}
			string[] files = Directory.GetFiles(levelsPath);
			for (int i = 0; i < files.Length; i++)
			{
				ProcessPath(files[i]);
			}
			OnlineLevelsManager.UpdateUI();
		}

		public static void SortBundles()
		{
			int num = 0;
			if (bundleSortingMode.value == BundleSorting.Alphabetically)
			{
				foreach (AngryBundleContainer item in angryBundles.Values.OrderBy((AngryBundleContainer b) => b.bundleData.bundleName))
				{
					((ConfigField)item.rootPanel).siblingIndex = num++;
				}
				return;
			}
			if (bundleSortingMode.value == BundleSorting.Author)
			{
				foreach (AngryBundleContainer item2 in angryBundles.Values.OrderBy((AngryBundleContainer b) => b.bundleData.bundleAuthor))
				{
					((ConfigField)item2.rootPanel).siblingIndex = num++;
				}
				return;
			}
			if (bundleSortingMode.value == BundleSorting.LastPlayed)
			{
				long value2;
				foreach (AngryBundleContainer item3 in angryBundles.Values.OrderByDescending((AngryBundleContainer b) => lastPlayed.TryGetValue(b.bundleData.bundleGuid, out value2) ? value2 : 0))
				{
					((ConfigField)item3.rootPanel).siblingIndex = num++;
				}
				return;
			}
			if (bundleSortingMode.value != BundleSorting.LastUpdate)
			{
				return;
			}
			long value;
			foreach (AngryBundleContainer item4 in angryBundles.Values.OrderByDescending((AngryBundleContainer b) => lastUpdate.TryGetValue(b.bundleData.bundleGuid, out value) ? value : 0))
			{
				((ConfigField)item4.rootPanel).siblingIndex = num++;
			}
		}

		public static void UpdateAllUI()
		{
			foreach (AngryBundleContainer value in angryBundles.Values)
			{
				if (value.finalRankScore.value < 0)
				{
					value.UpdateScenes(forceReload: false, lazyLoad: false);
				}
				else
				{
					value.UpdateFinalRankUI();
				}
				foreach (LevelContainer value2 in value.levels.Values)
				{
					value2.UpdateUI();
				}
			}
		}

		public static bool LoadEssentialScripts()
		{
			bool result = true;
			if (ScriptManager.AttemptLoadScriptWithCertificate("AngryLoaderAPI.dll") == ScriptManager.LoadScriptResult.NotFound)
			{
				logger.LogError((object)"Required script AngryLoaderAPI.dll not found");
				result = false;
			}
			else
			{
				ScriptManager.ForceLoadScript("AngryLoaderAPI.dll");
			}
			if (ScriptManager.AttemptLoadScriptWithCertificate("RudeLevelScripts.dll") == ScriptManager.LoadScriptResult.NotFound)
			{
				logger.LogError((object)"Required script RudeLevelScripts.dll not found");
				result = false;
			}
			else
			{
				ScriptManager.ForceLoadScript("RudeLevelScripts.dll");
			}
			return result;
		}

		private 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;
			}
		}

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

		private static bool GetUltrapainDifficultySet()
		{
			return Plugin.ultrapainDifficulty;
		}

		private static bool GetHeavenOrHellDifficultySet()
		{
			return Plugin.isHeavenOrHell;
		}

		private static void CreateCustomLevelButtonOnMainMenu()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: 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
			Scene activeScene = SceneManager.GetActiveScene();
			GameObject canvasObj = (from obj in ((Scene)(ref activeScene)).GetRootGameObjects()
				where ((Object)obj).name == "Canvas"
				select obj).FirstOrDefault();
			if ((Object)(object)canvasObj == (Object)null)
			{
				logger.LogWarning((object)"Angry tried to create main menu buttons, but root canvas was not found!");
				return;
			}
			Transform chapterSelect = canvasObj.transform.Find("Chapter Select");
			if ((Object)(object)chapterSelect != (Object)null)
			{
				GameObject obj2 = Addressables.InstantiateAsync((object)"AngryLevelLoader/UI/CustomLevels.prefab", chapterSelect, false, true).WaitForCompletion();
				Transform val = chapterSelect.Find("Boss Rush Button");
				if ((Object)(object)val != (Object)null)
				{
					bossRushButton = ((Component)val).gameObject.GetComponent<RectTransform>();
				}
				currentCustomLevelButton = obj2.GetComponent<AngryCustomLevelButtonComponent>();
				currentCustomLevelButton.button.onClick = new ButtonClickedEvent();
				((UnityEvent)currentCustomLevelButton.button.onClick).AddListener((UnityAction)delegate
				{
					//IL_0147: Unknown result type (might be due to invalid IL or missing references)
					((Component)chapterSelect).gameObject.SetActive(false);
					Transform val2 = canvasObj.transform.Find("OptionsMenu");
					if ((Object)(object)val2 == (Object)null)
					{
						logger.LogError((object)"Angry tried to find the options menu but failed!");
						((Component)chapterSelect).gameObject.SetActive(true);
					}
					else
					{
						((Component)val2).gameObject.SetActive(true);
						Transform val3 = ((Component)val2).transform.Find("Panel/PluginConfiguratorButton(Clone)");
						if ((Object)(object)val3 == (Object)null)
						{
							val3 = ((Component)val2).transform.Find("Panel/PluginConfiguratorButton");
						}
						if ((Object)(object)val3 == (Object)null)
						{
							logger.LogError((object)"Angry tried to find the plugin configurator button but failed!");
						}
						else
						{
							Transform val4 = val2.Find("Panel");
							ButtonHighlightParent val5 = default(ButtonHighlightParent);
							if ((Object)(object)val4 != (Object)null && ((Component)val4).gameObject.TryGetComponent<ButtonHighlightParent>(ref val5) && (val5.buttons == null || val5.buttons.Length == 0))
							{
								val5.Start();
							}
							((UnityEvent)((Component)val3).gameObject.GetComponent<Button>().onClick).Invoke();
							if ((Object)(object)PluginConfiguratorController.activePanel != (Object)null)
							{
								PluginConfiguratorController.activePanel.SetActive(false);
							}
							((Component)PluginConfiguratorController.mainPanel).gameObject.SetActive(false);
							config.rootPanel.OpenPanelInternally(false);
							config.rootPanel.currentPanel.rect.normalizedPosition = new Vector2(0f, 1f);
							int @int = MonoSingleton<PrefsManager>.Instance.GetInt("difficulty", 3);
							switch (@int)
							{
							case 0:
							case 1:
							case 2:
							case 3:
							case 4:
								logger.LogInfo((object)("Angry setting difficulty to " + difficultyList[@int]));
								difficultyField.difficultyListValueIndex = @int;
								break;
							case 5:
								if (ultrapainLoaded)
								{
									if (GetUltrapainDifficultySet())
									{
										difficultyField.difficultyListValueIndex = difficultyList.IndexOf("ULTRAPAIN");
									}
									else
									{
										logger.LogWarning((object)"Difficulty was set to UKMD, but angry does not support it. Setting to violent");
										difficultyField.difficultyListValueIndex = 3;
									}
								}
								break;
							default:
								if (heavenOrHellLoaded)
								{
									if (GetHeavenOrHellDifficultySet())
									{
										difficultyField.difficultyListValueIndex = difficultyList.IndexOf("HEAVEN OR HELL");
									}
									else
									{
										logger.LogWarning((object)"Unknown difficulty, defaulting to violent");
										difficultyField.difficultyListValueIndex = 3;
									}
								}
								break;
							}
							difficultyField.TriggerPostDifficultyChangeEvent();
						}
					}
				});
				customLevelButtonPosition.TriggerPostValueChangeEvent();
				customLevelButtonFrameColor.TriggerPostValueChangeEvent();
				customLevelButtonBackgroundColor.TriggerPostValueChangeEvent();
				customLevelButtonTextColor.TriggerPostValueChangeEvent();
			}
			else
			{
				logger.LogWarning((object)"Angry tried to find chapter select menu, but root canvas was not found!");
			}
		}

		private static void CreateAngryUI()
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			if (!((Object)(object)currentPanel != (Object)null))
			{
				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;
				}
				currentPanel = Addressables.InstantiateAsync((object)"AngryLevelLoader/UI/AngryUIPanel.prefab", val.transform, false, true).WaitForCompletion().GetComponent<AngryUIPanelComponent>();
				currentPanel.reloadBundlePrompt.MakeTransparent(true);
			}
		}

		private static void InitializeFileWatcher()
		{
			if (watcher != null)
			{
				return;
			}
			watcher = new FileSystemWatcher(levelsPath);
			watcher.SynchronizingObject = CrossThreadInvoker.Instance;
			watcher.Changed += delegate(object sender, FileSystemEventArgs e)
			{
				string fullPath4 = e.FullPath;
				foreach (AngryBundleContainer value2 in angryBundles.Values)
				{
					if (IOUtils.PathEquals(fullPath4, value2.pathToAngryBundle))
					{
						logger.LogWarning((object)("Bundle " + fullPath4 + " was updated, container notified"));
						value2.FileChanged();
						break;
					}
				}
			};
			watcher.Renamed += delegate(object sender, RenamedEventArgs e)
			{
				string fullPath3 = e.FullPath;
				foreach (AngryBundleContainer value3 in angryBundles.Values)
				{
					if (IOUtils.PathEquals(fullPath3, value3.pathToAngryBundle))
					{
						logger.LogWarning((object)("Bundle " + fullPath3 + " was renamed, path updated"));
						value3.pathToAngryBundle = fullPath3;
						break;
					}
				}
			};
			watcher.Deleted += delegate(object sender, FileSystemEventArgs e)
			{
				string fullPath2 = e.FullPath;
				foreach (AngryBundleContainer value4 in angryBundles.Values)
				{
					if (IOUtils.PathEquals(fullPath2, value4.pathToAngryBundle))
					{
						logger.LogWarning((object)("Bundle " + fullPath2 + " was deleted, unlinked"));
						value4.pathToAngryBundle = "";
						break;
					}
				}
			};
			watcher.Created += delegate(object sender, FileSystemEventArgs e)
			{
				string fullPath = e.FullPath;
				if (AngryFileUtils.TryGetAngryBundleData(fullPath, out var data, out var _) && angryBundles.TryGetValue(data.bundleGuid, out var value) && value.bundleData.bundleGuid == data.bundleGuid && !File.Exists(value.pathToAngryBundle))
				{
					logger.LogWarning((object)("Bundle " + fullPath + " was just added, and a container with the same guid had no file linked. Linked, container notified"));
					value.pathToAngryBundle = fullPath;
					value.FileChanged();
				}
			};
			watcher.Filter = "*";
			watcher.IncludeSubdirectories = false;
			watcher.EnableRaisingEvents = true;
		}

		private static void InitializeConfig()
		{
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Expected O, but got Unknown
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Expected O, but got Unknown
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Expected O, but got Unknown
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Expected O, but got Unknown
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			//IL_0131: Expected O, but got Unknown
			//IL_0140: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Expected O, but got Unknown
			//IL_01a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b0: Expected O, but got Unknown
			//IL_01d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e1: Expected O, but got Unknown
			//IL_021c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0226: Expected O, but got Unknown
			//IL_0236: Unknown result type (might be due to invalid IL or missing references)
			//IL_0240: Expected O, but got Unknown
			//IL_0272: Unknown result type (might be due to invalid IL or missing references)
			//IL_027c: Expected O, but got Unknown
			//IL_0182: Unknown result type (might be due to invalid IL or missing references)
			//IL_0187: Unknown result type (might be due to invalid IL or missing references)
			//IL_018d: Expected O, but got Unknown
			//IL_02ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b8: Expected O, but got Unknown
			//IL_02c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02df: Expected O, but got Unknown
			//IL_0291: Unknown result type (might be due to invalid IL or missing references)
			//IL_0296: Unknown result type (might be due to invalid IL or missing references)
			//IL_029c: Expected O, but got Unknown
			//IL_036f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0387: Unknown result type (might be due to invalid IL or missing references)
			//IL_0391: Expected O, but got Unknown
			//IL_0397: Unknown result type (might be due to invalid IL or missing references)
			//IL_03bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c9: Expected O, but got Unknown
			//IL_03c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d3: Expected O, but got Unknown
			//IL_0402: Unknown result type (might be due to invalid IL or missing references)
			//IL_040c: Expected O, but got Unknown
			//IL_03f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_03fd: Expected O, but got Unknown
			//IL_045a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0464: Expected O, but got Unknown
			//IL_0474: Unknown result type (might be due to invalid IL or missing references)
			//IL_04c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_04cd: Expected O, but got Unknown
			//IL_042a: Unknown result type (might be due to invalid IL or missing references)
			//IL_042f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0435: Expected O, but got Unknown
			//IL_04ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_04f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_04f7: Expected O, but got Unknown
			//IL_053c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0546: Expected O, but got Unknown
			//IL_051b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0520: Unknown result type (might be due to invalid IL or missing references)
			//IL_0526: Expected O, but got Unknown
			//IL_057c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0590: Unknown result type (might be due to invalid IL or missing references)
			//IL_055f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0564: Unknown result type (might be due to invalid IL or missing references)
			//IL_056a: Expected O, but got Unknown
			//IL_05ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_05f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_05fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0608: Expected O, but got Unknown
			//IL_0603: Unknown result type (might be due to invalid IL or missing references)
			//IL_060d: Expected O, but got Unknown
			//IL_0636: Unknown result type (might be due to invalid IL or missing references)
			//IL_0641: Unknown result type (might be due to invalid IL or missing references)
			//IL_064b: Expected O, but got Unknown
			//IL_0646: Unknown result type (might be due to invalid IL or missing references)
			//IL_0650: Expected O, but got Unknown
			//IL_0626: Unknown result type (might be due to invalid IL or missing references)
			//IL_062b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0631: Expected O, but got Unknown
			//IL_0683: Unknown result type (might be due to invalid IL or missing references)
			//IL_068d: Expected O, but got Unknown
			//IL_0688: Unknown result type (might be due to invalid IL or missing references)
			//IL_0692: Expected O, but got Unknown
			//IL_0669: Unknown result type (might be due to invalid IL or missing references)
			//IL_066e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0674: Expected O, but got Unknown
			//IL_06c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_06dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_06f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0708: Unknown result type (might be due to invalid IL or missing references)
			//IL_0712: Expected O, but got Unknown
			//IL_0723: Unknown result type (might be due to invalid IL or missing references)
			//IL_072d: Expected O, but got Unknown
			//IL_07cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_07e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_07fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0805: Expected O, but got Unknown
			//IL_0816: Unknown result type (might be due to invalid IL or missing references)
			//IL_0820: Expected O, but got Unknown
			//IL_0831: Unknown result type (might be due to invalid IL or missing references)
			//IL_083b: Expected O, but got Unknown
			//IL_084c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0856: Expected O, but got Unknown
			//IL_06ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_06b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_06b6: Expected O, but got Unknown
			//IL_089f: Unknown result type (might be due to invalid IL or missing references)
			//IL_08a9: Expected O, but got Unknown
			//IL_08e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_08ed: Expected O, but got Unknown
			//IL_08c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_08c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_08cd: Expected O, but got Unknown
			//IL_092c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0936: Expected O, but got Unknown
			//IL_0952: Unknown result type (might be due to invalid IL or missing references)
			//IL_095c: Expected O, but got Unknown
			//IL_0906: Unknown result type (might be due to invalid IL or missing references)
			//IL_090b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0911: Expected O, but got Unknown
			//IL_0992: Unknown result type (might be due to invalid IL or missing references)
			//IL_09a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_09c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_09cb: Expected O, but got Unknown
			//IL_09dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_09e6: Expected O, but got Unknown
			//IL_09fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a06: Expected O, but got Unknown
			//IL_0a48: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a4d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a6f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a79: Expected O, but got Unknown
			//IL_0a89: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a9c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0aa6: Expected O, but got Unknown
			//IL_0ab9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ac3: Expected O, but got Unknown
			//IL_0b04: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b09: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b17: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b21: Expected O, but got Unknown
			//IL_0975: Unknown result type (might be due to invalid IL or missing references)
			//IL_097a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0980: Expected O, but got Unknown
			//IL_0b60: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b66: Expected O, but got Unknown
			//IL_0b3b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b40: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b46: Expected O, but got Unknown
			//IL_0b81: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b8e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b98: Expected O, but got Unknown
			//IL_0ba8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0bb6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0bc6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0bd0: Expected O, but got Unknown
			//IL_0bda: Unknown result type (might be due to invalid IL or missing references)
			//IL_0be4: Expected O, but got Unknown
			//IL_0beb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0bf5: Expected O, but got Unknown
			//IL_0c07: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c11: Expected O, but got Unknown
			//IL_0c22: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c37: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c41: Expected O, but got Unknown
			if (config != null)
			{
				return;
			}
			config = PluginConfigurator.Create("Angry Level Loader", "com.eternalUnion.angryLevelLoader");
			PluginConfigurator obj = config;
			object obj2 = <>c.<>9__102_0;
			if (obj2 == null)
			{
				PostPresetChangeEvent val = delegate
				{
					UpdateAllUI();
				};
				<>c.<>9__102_0 = val;
				obj2 = (object)val;
			}
			obj.postPresetChangeEvent += (PostPresetChangeEvent)obj2;
			config.SetIconWithURL("file://" + Path.Combine(workingDir, "plugin-icon.png"));
			newLevelToggle = new BoolField(config.rootPanel, "", "v_newLevelToggle", false);
			((ConfigField)newLevelToggle).hidden = true;
			ConfigPanel rootPanel = config.rootPanel;
			object obj3 = <>c.<>9__102_1;
			if (obj3 == null)
			{
				OpenPanelEventDelegate val2 = delegate
				{
					if (newLevelToggle.value)
					{
						newLevelNotifier.text = string.Join("\n", from level in newLevelNotifierLevels.value.Split(new char[1] { '`' })
							where !string.IsNullOrEmpty(level)
							select level into name
							select "<color=lime>New level: " + name + "</color>");
						((ConfigField)newLevelNotifier).hidden = false;
						newLevelNotifierLevels.value = "";
					}
					newLevelToggle.value = false;
				};
				<>c.<>9__102_1 = val2;
				obj3 = (object)val2;
			}
			rootPanel.onPannelOpenEvent += (OpenPanelEventDelegate)obj3;
			newLevelNotifier = new ConfigHeader(config.rootPanel, "<color=lime>New levels are available!</color>", 16);
			((ConfigField)newLevelNotifier).hidden = true;
			levelUpdateNotifier = new ConfigHeader(config.rootPanel, "<color=lime>Level updates available!</color>", 16);
			((ConfigField)levelUpdateNotifier).hidden = true;
			OnlineLevelsManager.onlineLevelsPanel = new ConfigPanel(internalConfig.rootPanel, "Online Levels", "b_onlineLevels", (PanelFieldType)1);
			new ConfigBridge((ConfigField)(object)OnlineLevelsManager.onlineLevelsPanel, config.rootPanel);
			OnlineLevelsManager.onlineLevelsPanel.SetIconWithURL("file://" + Path.Combine(workingDir, "online-icon.png"));
			ConfigPanel onlineLevelsPanel = OnlineLevelsManager.onlineLevelsPanel;
			object obj4 = <>c.<>9__102_2;
			if (obj4 == null)
			{
				OpenPanelEventDelegate val3 = delegate
				{
					((ConfigField)newLevelNotifier).hidden = true;
				};
				<>c.<>9__102_2 = val3;
				obj4 = (object)val3;
			}
			onlineLevelsPanel.onPannelOpenEvent += (OpenPanelEventDelegate)obj4;
			OnlineLevelsManager.Init();
			leaderboardsDivision = new ConfigDivision(config.rootPanel, "leaderboardsDivision");
			((ConfigField)leaderboardsDivision).hidden = !leaderboardToggle.value;
			bannedModsPanel = new ConfigPanel((ConfigPanel)(object)leaderboardsDivision, "Leaderboard banned mods", "bannedModsPanel", (PanelFieldType)1);
			bannedModsPanel.SetIconWithURL("file://" + Path.Combine(workingDir, "banned-mods-icon.png"));
			((ConfigField)bannedModsPanel).hidden = true;
			bannedModsText = new ConfigHeader(bannedModsPanel, "", 24, (TextAnchor)3);
			pendingRecords = new ConfigPanel((ConfigPanel)(object)leaderboardsDivision, "Pending records", "pendingRecords", (PanelFieldType)1);
			pendingRecords.SetIconWithURL("file://" + Path.Combine(workingDir, "pending.png"));
			sendPendingRecords = new ButtonField(pendingRecords, "Send Pending Records", "sendPendingRecordsButton");
			ButtonField obj5 = sendPendingRecords;
			object obj6 = <>O.<1>__ProcessPendingRecords;
			if (obj6 == null)
			{
				OnClick val4 = ProcessPendingRecords;
				<>O.<1>__ProcessPendingRecords = val4;
				obj6 = (object)val4;
			}
			obj5.onClick += (OnClick)obj6;
			pendingRecordsStatus = new ConfigHeader(pendingRecords, "", 20, (TextAnchor)3);
			new ConfigSpace(pendingRecords, 5f);
			pendingRecordsInfo = new ConfigHeader(pendingRecords, "", 18, (TextAnchor)3);
			UpdatePendingRecordsUI();
			difficultyField = new DifficultyField(config.rootPanel);
			bundleSortingMode = new EnumField<BundleSorting>(internalConfig.rootPanel, "Bundle sorting", "s_bundleSortingMode", BundleSorting.LastPlayed);
			bundleSortingMode.onValueChange += delegate(EnumValueChangeEvent<BundleSorting> e)
			{
				bundleSortingMode.value = e.value;
				SortBundles();
			};
			bundleSortingMode.SetEnumDisplayName(BundleSorting.LastPlayed, "Last Played");
			bundleSortingMode.SetEnumDisplayName(BundleSorting.LastUpdate, "Last Update");
			new ConfigBridge((ConfigField)(object)bundleSortingMode, config.rootPanel);
			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)
			{
				selectedDifficulty = Array.IndexOf(difficultyList.ToArray(), difficultyName);
				if (selectedDifficulty == -1)
				{
					logger.LogWarning((object)"Invalid difficulty, setting to violent");
					selectedDifficulty = 3;
					difficultyField.difficultyListValue = "VIOLENT";
				}
				else if (difficultyName == "ULTRAPAIN")
				{
					selectedDifficulty = 100;
				}
				else if (difficultyName == "HEAVEN OR HELL")
				{
					selectedDifficulty = 101;
				}
				if (difficultyField.gamemodeListValueIndex == 1 || difficultyField.gamemodeListValueIndex == 2)
				{
					((ConfigField)difficultyOverrideWarning).hidden = false;
					difficultyField.difficultyInteractable = false;
					difficultyField.ForceSetDifficultyUI(0);
					selectedDifficulty = 0;
				}
				else
				{
					((ConfigField)difficultyOverrideWarning).hidden = true;
					difficultyField.difficultyInteractable = true;
					difficultyField.ForceSetDifficultyUI(selectedDifficulty);
				}
			});
			DifficultyField obj8 = difficultyField;
			PostStringListValueChangeEvent postGamemodeChange = obj8.postGamemodeChange;
			object obj9 = <>c.<>9__102_22;
			if (obj9 == null)
			{
				PostStringListValueChangeEvent val5 = delegate
				{
					difficultyField.TriggerPostDifficultyChangeEvent();
				};
				<>c.<>9__102_22 = val5;
				obj9 = (object)val5;
			}
			obj8.postGamemodeChange = (PostStringListValueChangeEvent)Delegate.Combine((Delegate?)(object)postGamemodeChange, (Delegate?)obj9);
			ConfigPanel rootPanel2 = config.rootPanel;
			object obj10 = <>c.<>9__102_4;
			if (obj10 == null)
			{
				OpenPanelEventDelegate val6 = delegate
				{
					difficultyField.TriggerPostDifficultyChangeEvent();
				};
				<>c.<>9__102_4 = val6;
				obj10 = (object)val6;
			}
			rootPanel2.onPannelOpenEvent += (OpenPanelEventDelegate)obj10;
			difficultyField.TriggerPostDifficultyChangeEvent();
			ConfigPanel settingsPanel = new ConfigPanel(internalConfig.rootPanel, "Settings", "p_settings", (PanelFieldType)0);
			new ConfigBridge((ConfigField)(object)settingsPanel, config.rootPanel);
			((ConfigField)settingsPanel).hidden = true;
			openButtons = new ButtonArrayField(settingsPanel, "settingButtons", 2, new float[2] { 0.5f, 0.5f }, new string[2] { "Open Levels Folder", "Changelog" }, 5f);
			ButtonClickEvent obj11 = openButtons.OnClickEventHandler(0);
			object obj12 = <>c.<>9__102_5;
			if (obj12 == null)
			{
				OnClick val7 = delegate
				{
					Application.OpenURL(levelsPath);
				};
				<>c.<>9__102_5 = val7;
				obj12 = (object)val7;
			}
			obj11.onClick += (OnClick)obj12;
			ButtonClickEvent obj13 = openButtons.OnClickEventHandler(1);
			object obj14 = <>c.<>9__102_6;
			if (obj14 == null)
			{
				OnClick val8 = delegate
				{
					openButtons.SetButtonInteractable(1, false);
					PluginUpdateHandler.CheckPluginUpdate();
				};
				<>c.<>9__102_6 = val8;
				obj14 = (object)val8;
			}
			obj13.onClick += (OnClick)obj14;
			reloadFileKeybind = new KeyCodeField(settingsPanel, "Reload File", "f_reloadFile", (KeyCode)0);
			KeyCodeField obj15 = reloadFileKeybind;
			object obj16 = <>c.<>9__102_7;
			if (obj16 == null)
			{
				KeyCodeValueChangeEventDelegate val9 = 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__102_7 = val9;
				obj16 = (object)val9;
			}
			obj15.onValueChange += (KeyCodeValueChangeEventDelegate)obj16;
			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);
			customLevelButtonPosition.postValueChangeEvent += delegate(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 CustomLevelButtonPosition.Disabled:
						((Component)currentCustomLevelButton).gameObject.SetActive(false);
						break;
					case CustomLevelButtonPosition.Bottom:
						((Component)currentCustomLevelButton).transform.localPosition = new Vector3(((Component)currentCustomLevelButton).transform.localPosition.x, -303f, ((Component)currentCustomLevelButton).transform.localPosition.z);
						break;
					case 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 == 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);
						}
					}
				}
			};
			ConfigPanel val10 = new ConfigPanel(settingsPanel, "Custom level button colors", "customLevelButtonPanel");
			customLevelButtonFrameColor = new ColorField(val10, "Custom level button frame color", "s_customLevelButtonFrameColor", Color.white);
			ColorField obj17 = customLevelButtonFrameColor;
			object obj18 = <>c.<>9__102_9;
			if (obj18 == null)
			{
				PostColorValueChangeEvent val11 = 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__102_9 = val11;
				obj18 = (object)val11;
			}
			obj17.postValueChangeEvent += (PostColorValueChangeEvent)obj18;
			customLevelButtonBackgroundColor = new ColorField(val10, "Custom level button background color", "s_customLevelButtonBgColor", Color.black);
			ColorField obj19 = customLevelButtonBackgroundColor;
			object obj20 = <>c.<>9__102_10;
			if (obj20 == null)
			{
				PostColorValueChangeEvent val12 = 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.background).color = clr;
					}
				};
				<>c.<>9__102_10 = val12;
				obj20 = (object)val12;
			}
			obj19.postValueChangeEvent += (PostColorValueChangeEvent)obj20;
			customLevelButtonTextColor = new ColorField(val10, "Custom level button text color", "s_customLevelButtonTextColor", Color.white);
			ColorField obj21 = customLevelButtonTextColor;
			object obj22 = <>c.<>9__102_11;
			if (obj22 == null)
			{
				PostColorValueChangeEvent val13 = 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__102_11 = val13;
				obj22 = (object)val13;
			}
			obj21.postValueChangeEvent += (PostColorValueChangeEvent)obj22;
			new ConfigHeader(settingsPanel, "Leaderboards", 24).textColor = new Color(1f, 0.692924f, 0.291f);
			new ConfigBridge((ConfigField)(object)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);
			checkForUpdates = new BoolField(settingsPanel, "Check for updates on boot", "s_checkForUpdates", true);
			useDevelopmentBranch = new BoolField(settingsPanel, "Use development chanel", "s_useDevChannel", false);
			useLocalServer = new BoolField(settingsPanel, "Use local server", "s_useLocalServer", false);
			if (!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 obj23 = levelUpdateNotifierToggle;
			object obj24 = <>c.<>9__102_12;
			if (obj24 == null)
			{
				BoolValueChangeEventDelegate val14 = delegate(BoolValueChangeEvent e)
				{
					levelUpdateNotifierToggle.value = e.value;
					OnlineLevelsManager.CheckLevelUpdateText();
				};
				<>c.<>9__102_12 = val14;
				obj24 = (object)val14;
			}
			obj23.onValueChange += (BoolValueChangeEventDelegate)obj24;
			levelUpdateIgnoreCustomBuilds = new BoolField(settingsPanel, "Ignore updates for custom build", "s_levelUpdateIgnoreCustomBuilds", false);
			BoolField obj25 = levelUpdateIgnoreCustomBuilds;
			object obj26 = <>c.<>9__102_13;
			if (obj26 == null)
			{
				BoolValueChangeEventDelegate val15 = delegate(BoolValueChangeEvent e)
				{
					levelUpdateIgnoreCustomBuilds.value = e.value;
					OnlineLevelsManager.CheckLevelUpdateText();
				};
				<>c.<>9__102_13 = val15;
				obj26 = (object)val15;
			}
			obj25.onValueChange += (BoolValueChangeEventDelegate)obj26;
			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 obj27 = newLevelNotifierToggle;
			object obj28 = <>c.<>9__102_14;
			if (obj28 == null)
			{
				BoolValueChangeEventDelegate val16 = delegate(BoolValueChangeEvent e)
				{
					newLevelNotifierToggle.value = e.value;
					if (!e.value)
					{
						((ConfigField)newLevelNotifier).hidden = true;
					}
				};
				<>c.<>9__102_14 = val16;
				obj28 = (object)val16;
			}
			obj27.onValueChange += (BoolValueChangeEventDelegate)obj28;
			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);
			scriptAutoUpdate = new BoolField(settingsPanel, "Auto update scripts", "s_scriptAutoUpdate", true);
			scriptCertificateIgnoreField = new StringMultilineField(settingsPanel, "Certificate ignore", "s_scriptCertificateIgnore", "", true);
			scriptCertificateIgnore = scriptCertificateIgnoreField.value.Split(new char[1] { '\n' }).ToList();
			new SpaceField(settingsPanel, 5f);
			new ConfigHeader(settingsPanel, "Danger Zone", 24).textColor = Color.red;
			StringField dataPathInput = new StringField(settingsPanel, "Data Path", "s_dataPathInput", dataPath, false, false);
			ButtonField val17 = new ButtonField(settingsPanel, "Move Data", "s_changeDataPath");
			ConfigHeader dataInfo = new ConfigHeader(settingsPanel, "<color=red>RESTART REQUIRED</color>", 18);
			((ConfigField)dataInfo).hidden = true;
			val17.onClick += (OnClick)delegate
			{
				string value = dataPathInput.value;
				if (!(value == configDataPath.value))
				{
					if (!Directory.Exists(value))
					{
						dataInfo.text = "<color=red>Could not find the directory</color>";
						((ConfigField)dataInfo).hidden = false;
					}
					else
					{
						string text3 = Path.Combine(value, "Levels");
						IOUtils.TryCreateDirectory(text3);
						string[] files = Directory.GetFiles(levelsPath);
						foreach (string text4 in files)
						{
							string text5 = Path.Combine(text3, Path.GetFileName(text4));
							if (File.Exists(text5))
							{
								File.Copy(text4, text5, overwrite: true);
								File.Delete(text4);
							}
							else
							{
								File.Move(text4, text5);
							}
						}
						Directory.Delete(levelsPath, recursive: true);
						levelsPath = text3;
						string text6 = Path.Combine(value, "LevelsUnpacked");
						IOUtils.TryCreateDirectory(text6);
						files = Directory.GetDirectories(tempFolderPath);
						foreach (string text7 in files)
						{
							string text8 = Path.Combine(text6, Path.GetFileName(text7));
							if (Directory.Exists(text8))
							{
								Directory.Delete(text8, recursive: true);
							}
							IOUtils.DirectoryCopy(text7, text8, copySubDirs: true, deleteSource: true);
						}
						Directory.Delete(tempFolderPath, recursive: true);
						tempFolderPath = text6;
						string text9 = Path.Combine(value, "MapVars");
						IOUtils.TryCreateDirectory(text9);
						files = Directory.GetDirectories(Path.Combine(dataPath, "MapVars"));
						foreach (string text10 in files)
						{
							string text11 = Path.Combine(text9, Path.GetFileName(text10));
							if (Directory.Exists(text11))
							{
								Directory.Delete(text11, recursive: true);
							}
							IOUtils.DirectoryCopy(text10, text11, copySubDirs: true, deleteSource: true);
						}
						if (Directory.Exists(Path.Combine(dataPath, "MapVars")))
						{
							Directory.Delete(Path.Combine(dataPath, "MapVars"), recursive: true);
						}
						dataInfo.text = "<color=red>RESTART REQUIRED</color>";
						((ConfigField)dataInfo).hidden = false;
						configDataPath.value = value;
						DisableAllConfig();
					}
				}
			};
			ButtonArrayField val18 = new ButtonArrayField(config.rootPanel, "settingsAndReload", 2, new float[2] { 0.5f, 0.5f }, new string[2] { "Settings", "Scan For Levels" }, 5f);
			val18.OnClickEventHandler(0).onClick += (OnClick)delegate
			{
				settingsPanel.OpenPanel();
			};
			ButtonClickEvent obj29 = val18.OnClickEventHandler(1);
			object obj30 = <>c.<>9__102_17;
			if (obj30 == null)
			{
				OnClick val19 = delegate
				{
					ScanForLevels();
				};
				<>c.<>9__102_17 = val19;
				obj30 = (object)val19;
			}
			obj29.onClick += (OnClick)obj30;
			ConfigPanel val20 = new ConfigPanel(config.rootPanel, "Developer Panel", "devPanel", (PanelFieldType)3);
			if (!devMode.value)
			{
				((ConfigField)val20).hidden = true;
			}
			new ConfigHeader(val20, "Angry Server Interface", 24);
			ConfigDivision devDiv = new ConfigDivision(val20, "devDiv");
			ButtonField val21 = new ButtonField((ConfigPanel)(object)devDiv, "Update All Bundles", "updateAllBundles");
			new ConfigHeader(val20, "Output", 18, (TextAnchor)3);
			ConfigHeader processInfo = new ConfigHeader(val20, "", 18, (TextAnchor)3);
			ConfigHeader debugInfo = new ConfigHeader(val20, "", 18, (TextAnchor)3);
			val21.onClick += (OnClick)async delegate
			{
				((ConfigField)devDiv).interactable = false;
				processInfo.text = "";
				debugInfo.text = "";
				try
				{
					if (OnlineLevelsManager.catalog == null)
					{
						processInfo.text = "<color=red>Catalog is not loaded</color>";
					}
					else
					{
						debugInfo.text = "<color=grey>Fetching existing bundles...</color>";
						AngryAdmin.GetAllLevelInfoResult existingBundles = await AngryAdmin.GetAllLevelInfoTask();
						if (existingBundles.networkError)
						{
							processInfo.text = "Network error, check connection";
						}
						else if (existingBundles.httpError)
						{
							processInfo.text = "Http error, check server";
						}
						else if (existingBundles.status != 0)
						{
							processInfo.text = $"Status error: {existingBundles.message}:{existingBundles.status}";
						}
						else
						{
							foreach (LevelInfo bundle in OnlineLevelsManager.catalog.Levels)
							{
								processInfo.text = "\nChecking " + bundle.Name + "...";
								AngryAdmin.BundleLevelInfo existingBundle = existingBundles.response.result.Where((AngryAdmin.BundleLevelInfo b) => b.bundleGuid == bundle.Guid).FirstOrDefault();
								if (existingBundle == null)
								{
									ConfigHeader obj31 = debugInfo;
									obj31.text += "\nMissing, adding to the server";
									ConfigHeader obj32 = debugInfo;
									obj32.text = obj32.text + "\n<color=grey>command: add_bundle " + bundle.Guid + "</color>";
									AngryAdmin.CommandResult commandResult = await AngryAdmin.SendCommand("add_bundle " + bundle.Guid);
									if (commandResult.completedSuccessfully && commandResult.status == AngryAdmin.CommandStatus.OK)
									{
										ConfigHeader obj33 = debugInfo;
										obj33.text = obj33.text + "\n" + commandResult.response.result;
									}
									else if (commandResult.networkError)
									{
										ConfigHeader obj34 = debugInfo;
										obj34.text += "\n<color=red>NETWORK ERROR</color> Check conntection";
									}
									else if (commandResult.httpError)
									{
										ConfigHeader obj35 = debugInfo;
										obj35.text += "\n<color=red>HTTP ERROR</color> Check server";
									}
									else if (commandResult.response != null)
									{
										ConfigHeader obj36 = debugInfo;
										obj36.text += $"\n<color=red>ERROR: </color>{commandResult.message}:{commandResult.status}";
									}
									else
									{
										ConfigHeader obj37 = debugInfo;
										obj37.text = obj37.text + "\n<color=red>ERROR: </color>Encountered unknown error. Status: " + commandResult.status;
									}
								}
								if (existingBundle == null || existingBundle.hash != bundle.Hash)
								{
									ConfigHeader obj38 = debugInfo;
									obj38.text += "\nOut of date hash, updating";
									ConfigHeader val22 = debugInfo;
									val22.text = val22.text + "\n<color=grey>command: update_leaderboard_hash " + bundle.Guid + " " + bundle.Hash + "</color>";
									AngryAdmin.CommandResult commandResult2 = await AngryAdmin.SendCommand("update_leaderboard_hash " + bundle.Guid + " " + bundle.Hash);
									if (commandResult2.completedSuccessfully && commandResult2.status == AngryAdmin.CommandStatus.OK)
									{
										ConfigHeader obj39 = debugInfo;
										obj39.text = obj39.text + "\n" + commandResult2.response.result;
									}
									else if (commandResult2.networkError)
									{
										ConfigHeader obj40 = debugInfo;
										obj40.text += "\n<color=red>NETWORK ERROR</color> Check conntection";
									}
									else if (commandResult2.httpError)
									{
										ConfigHeader obj41 = debugInfo;
										obj41.text += "\n<color=red>HTTP ERROR</color> Check server";
									}
									else if (commandResult2.response != null)
									{
										ConfigHeader obj42 = debugInfo;
										obj42.text += $"\n<color=red>ERROR: </color>{commandResult2.message}:{commandResult2.status}";
									}
									else
									{
										ConfigHeader obj43 = debugInfo;
										obj43.text = obj43.text + "\n<color=red>ERROR: </color>Encountered unknown error. Status: " + commandResult2.status;
									}
								}
								AngryBundleContainer container = GetAngryBundleByGuid(bundle.Guid);
								if (container == null)
								{
									ConfigHeader obj44 = debugInfo;
									obj44.text += "\n<color=red>Bundle not installed locally to check levels</color>";
								}
								else if (container.bundleData.buildHash != bundle.Hash)
								{
									ConfigHeader obj45 = debugInfo;
									obj45.text += "\n<color=red>Local level out of date</color>";
								}
								else
								{
									if (container.locator == null)
									{
										if (container.updating)
										{
											await container.UpdateScenes(forceReload: false, lazyLoad: false);
										}
										await container.UpdateScenes(forceReload: false, lazyLoad: false);
									}
									string[] array = (from data in container.GetAllLevelData()
										select data.uniqueIdentifier).ToArray();
									string[] existingLevels = ((existingBundle == null) ? new string[0] : existingBundle.levels);
									string[] array2 = array;
									foreach (string text in array2)
									{
										if (!existingLevels.Contains(text))
										{
											if (Enumerable.Contains(text, '~'))
											{
												ConfigHeader obj46 = debugInfo;
												obj46.text = obj46.text + "\n<color=red>Level ID '" + text + "' contains ~. Cannot process</color>";
											}
											else
											{
												string text2 = text.Replace(' ', '~');
												ConfigHeader val22 = debugInfo;
												val22.text = val22.text + "\n<color=grey>command: add_leaderboard " + bundle.Guid + " " + bundle.Hash + " " + text2 + "</color>";
												AngryAdmin.CommandResult commandResult3 = await AngryAdmin.SendCommand("add_leaderboard " + bundle.Guid + " " + bundle.Hash + " " + text2);
												if (commandResult3.completedSuccessfully && commandResult3.status == AngryAdmin.CommandStatus.OK)
												{
													ConfigHeader obj47 = debugInfo;
													obj47.text = obj47.text + "\n" + commandResult3.response.result;
												}
												else if (commandResult3.networkError)
												{
													ConfigHeader obj48 = debugInfo;
													obj48.text += "\n<color=red>NETWORK ERROR</color> Check conntection";
												}
												else if (commandResult3.httpError)
												{
													ConfigHeader obj49 = debugInfo;
													obj49.text += "\n<color=red>HTTP ERROR</color> Check server";
												}
												else if (commandResult3.response != null)
												{
													ConfigHeader obj50 = debugInfo;
													obj50.text += $"\n<color=red>ERROR: </color>{commandResult3.message}:{commandResult3.status}";
												}
												else
												{
													ConfigHeader obj51 = debugInfo;
													obj51.text = obj51.text + "\n<color=red>ERROR: </color>Encountered unknown error. Status: " + commandResult3.status;
												}
											}
										}
									}
								}
							}
							processInfo.text = "<color=lime>Done!</color>";
						}
					}
				}
				finally
				{
					((ConfigField)devDiv).interactable = true;
				}
			};
			errorText = new ConfigHeader(config.rootPanel, "", 16, (TextAnchor)0);
			new ConfigHeader(config.rootPanel, "Level Bundles", 24);
			bundleDivision = new ConfigDivision(config.rootPanel, "div_bundles");
		}

		public static void CheckForBannedMods()
		{
			if (!AngryLeaderboards.bannedModsListLoaded)
			{
				return;
			}
			bool flag = false;
			bannedModsText.text = "";
			string[] array = AngryLeaderboards.bannedMods;
			if (array == null)
			{
				logger.LogWarning((object)"Banned mods list cannot be fetched from angry servers, using the local list");
				array = BannedModsManager.LOCAL_BANNED_MODS_LIST;
			}
			foreach (string key in Chainloader.PluginInfos.Keys)
			{
				if (Array.IndexOf(array, key) == -1)
				{
					continue;
				}
				if (!BannedModsManager.guidToName.TryGetValue(key, out var value))
				{
					value = key;
				}
				if (BannedModsManager.checkers.TryGetValue(key, out var value2))
				{
					try
					{
						SoftBanCheckResult softBanCheckResult = value2();
						if (softBanCheckResult.banned)
						{
							if (!string.IsNullOrEmpty(bannedModsText.text))
							{
								ConfigHeader obj = bannedModsText;
								obj.text += "\n";
							}
							ConfigHeader val = bannedModsText;
							val.text = val.text + "<color=red>" + value + "</color>\n<size=18>" + softBanCheckResult.message + "</size>\n\n";
							flag = true;
						}
					}
					catch (Exception arg)
					{
						logger.LogError((object)$"Exception thrown while checking for soft ban for {value}\n{arg}");
						if (!string.IsNullOrEmpty(bannedModsText.text))
						{
							ConfigHeader obj2 = bannedModsText;
							obj2.text += "\n";
						}
						ConfigHeader obj3 = bannedModsText;
						obj3.text = obj3.text + "<color=red>" + value + "</color>\n<size=18>- Encountered an error while checking for the soft ban status, check console</size>\n\n";
						flag = true;
					}
				}
				else
				{
					if (!string.IsNullOrEmpty(bannedModsText.text))
					{
						ConfigHeader obj4 = bannedModsText;
						obj4.text += "\n";
					}
					ConfigHeader obj5 = bannedModsText;
					obj5.text = obj5.text + "<color=red>" + value + "</color>\n<size=18>- Could not find a soft ban check for this mod. Is angry up to date?</size>\n\n";
					flag = true;
				}
			}
			((ConfigField)bannedModsPanel).hidden = !flag;
		}

		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>>(pendingRecordsField.value);
				if (list == null)
				{
					list = new List<RecordInfoJsonWrapper>();
				}
			}
			catch (Exception arg)
			{
				logger.LogError((object)$"Caught exception while trying to deserialize pending records\n{arg}");
				pendingRecordsField.value = "[]";
				list = new List<RecordInfoJsonWrapper>();
			}
			list.Add(new RecordInfoJsonWrapper(record));
			pendingRecordsField.value = JsonConvert.SerializeObject((object)list);
			UpdatePendingRecordsUI();
		}

		internal static void UpdatePendingRecordsUI()
		{
			try
			{
				List<RecordInfoJsonWrapper> list = JsonConvert.DeserializeObject<List<RecordInfoJsonWrapper>>(pendingRecordsField.value);
				if (list == null)
				{
					list = new List<RecordInfoJsonWrapper>();
				}
				((ConfigField)pendingRecords).hidden = list.Count == 0;
				pendingRecordsInfo.text = "";
				foreach (RecordInfoJsonWrapper item in list)
				{
					string text = item.bundleGuid;
					string text2 = item.levelId;
					AngryBundleContainer angryBundleByGuid = GetAngryBundleByGuid(text);
					if (angryBundleByGuid != null)
					{
						text = angryBundleByGuid.bundleData.bundleName;
					}
					if (AngrySceneManager.TryFindLevel(text2, out var level))
					{
						text2 = level.data.levelName;
					}
					ConfigHeader obj = pendingRecordsInfo;
					obj.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)
			{
				logger.LogError((object)$"Caught exception while trying to deserialize pending records\n{arg}");
				pendingRecordsField.value = "[]";
				((ConfigField)pendingRecords).hidden = true;
			}
		}

		private static async Task ProcessPendingRecordsTask()
		{
			pendingRecordsStatus.text = "";
			List<RecordInfoJsonWrapper> list;
			try
			{
				list = JsonConvert.DeserializeObject<List<RecordInfoJsonWrapper>>(pendingRecordsField.value);
				if (list == null)
				{
					list = new List<RecordInfoJsonWrapper>();
				}
			}
			catch (Exception arg)
			{
				pendingRecordsStatus.text = $"<color=red>Exception thrown while deserializing pending records, discarding\n\n{arg}</color>";
				pendingRecordsField.value = "[]";
				UpdatePendingRecordsUI();
				return;
			}
			List<RecordInfoJsonWrapper> failedToSend = new List<RecordInfoJsonWrapper>();
			foreach (RecordInfoJsonWrapper record in list)
			{
				string text = record.bundleGuid;
				string text2 = record.levelId;
				AngryBundleContainer angryBundleByGuid = GetAngryBundleByGuid(text);
				if (angryBundleByGuid != null)
				{
					text = angryBundleByGuid.bundleData.bundleName;
				}
				if (AngrySceneManager.TryFindLevel(text2, out var level))
				{
					text2 = level.data.levelName;
				}
				ConfigHeader val;
				if (!record.TryParseRecordInfo(out var record2))
				{
					val = pendingRecordsStatus;
					val.text = val.text + "<color=red>Failed to parse record info for level " + text2 + " in bundle " + text + ". Discarded.</color>\n\n";
					continue;
				}
				val = pendingRecordsStatus;
				val.text = val.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 obj = pendingRecordsStatus;
						obj.text += $"<color=lime>Record posted successfully!</color> Ranking: #{postRecordResult.response.ranking}, New Best: {postRecordResult.response.newBest}\n\n";
						continue;
					}
					switch (postRecordResult.status)
					{
					case AngryLeaderboards.PostRecordStatus.BANNED:
					{
						ConfigHeader obj7 = pendingRecordsStatus;
						obj7.text += "<color=red>User banned from the leaderboards. Discarded.</color>\n\n";
						break;
					}
					case AngryLeaderboards.PostRecordStatus.INVALID_BUNDLE:
					case AngryLeaderboards.PostRecordStatus.INVALID_ID:
					{
						ConfigHeader obj6 = pendingRecordsStatus;
						obj6.text += "<color=red>Level's leaderboards are not enabled. Discarded.</color>\n\n";
						break;
					}
					case AngryLeaderboards.PostRecordStatus.RATE_LIMITED:
					{
						ConfigHeader obj5 = pendingRecordsStatus;
						obj5.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 obj4 = pendingRecordsStatus;
						obj4.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 obj3 = pendingRecordsStatus;
						obj3.text += $"<color=red>Angry server rejected the sent time {record.time}. Discarded.</color>\n\n";
						break;
					}
					default:
					{
						ConfigHeader obj2 = pendingRecordsStatus;
						obj2.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 obj8 = pendingRecordsStatus;
					obj8.text += "<color=red>Encountered a network error while posting record. Returning record to the pending list</color>\n\n";
					failedToSend.Add(record);
				}
			}
			ConfigHeader obj9 = pendingRecordsStatus;
			obj9.text += "<color=lime>Done!</color>";
			pendingRecordsField.value = JsonConvert.SerializeObject((object)failedToSend);
			UpdatePendingRecordsUI();
		}

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

		private void DisplayPluginConfigVersionError()
		{
			//IL_003a: Unknown result type