using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Net.Sockets;
using System.Net.WebSockets;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using ALTTLArchipelago.Core;
using ALTTLModKit;
using Archipelago.MultiClient.Net;
using Archipelago.MultiClient.Net.Enums;
using Archipelago.MultiClient.Net.Exceptions;
using Archipelago.MultiClient.Net.Helpers;
using Archipelago.MultiClient.Net.MessageLog.Messages;
using Archipelago.MultiClient.Net.MessageLog.Parts;
using Archipelago.MultiClient.Net.Models;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Core.Logging.Interpolation;
using BepInEx.Logging;
using BepInEx.Unity.IL2CPP;
using HarmonyLib;
using Il2CppInterop.Runtime;
using Il2CppInterop.Runtime.Injection;
using Il2CppInterop.Runtime.InteropTypes;
using Il2CppInterop.Runtime.InteropTypes.Arrays;
using Il2CppSystem;
using Il2CppSystem.Collections.Generic;
using Il2CppSystem.Reflection;
using Microsoft.CodeAnalysis;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using Steamworks;
using TMPro;
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.Events;
using UnityEngine.Localization.Components;
using UnityEngine.SceneManagement;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: AssemblyCompany("ALTTLArchipelago")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+9071b21c6adcb522865716b090945e6ed707583f")]
[assembly: AssemblyProduct("ALTTLArchipelago")]
[assembly: AssemblyTitle("ALTTLArchipelago")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

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

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace ALTTLArchipelago
{
	[HarmonyPatch]
	internal static class AbilityLocks
	{
		private static readonly Color Locked = new Color(0.55f, 0.55f, 0.55f, 0.6f);

		private static readonly Dictionary<int, Color> _original = new Dictionary<int, Color>();

		private static readonly HashSet<int> _tinted = new HashSet<int>();

		private static string _lastSummary = "";

		private static readonly AbilityState Released = new AbilityState(new SlotData
		{
			AbilityLocks = false
		});

		private static bool _releasing;

		private static bool _eventsAttached;

		private static readonly List<Action<GameEventData>> KeepAlive = new List<Action<GameEventData>>();

		private static readonly SortedDictionary<string, int> _eventCounts = new SortedDictionary<string, int>(StringComparer.Ordinal);

		private static float _holdUntil;

		private static bool _applying;

		private static bool _again;

		private static int _reentered;

		private static readonly Dictionary<int, Collider2D> _heldButtons = new Dictionary<int, Collider2D>();

		internal static readonly HashSet<int> HeldIndexes = new HashSet<int>();

		private static readonly HashSet<int> _heldArt = new HashSet<int>();

		private static int _indexLevelCopy;

		private const string HandleVote = "Handle";

		private static List<ClearingObject>? _clearers;

		private static int _clearersFor;

		private static List<Match>? _matches;

		private static int _matchesFor;

		private static string _handlesSaid = "";

		private static readonly Dictionary<string, (Type?, PropertyInfo[])> _extraLists = new Dictionary<string, (Type, PropertyInfo[])>();

		private static readonly Dictionary<int, bool> _colliders = new Dictionary<int, bool>();

		private static readonly Dictionary<int, bool> _bodies = new Dictionary<int, bool>();

		private static readonly HashSet<int> _flagged = new HashSet<int>();

		private static readonly Dictionary<int, bool> _gameInteractable = new Dictionary<int, bool>();

		private static readonly HashSet<int> _scrubRefusalSaid = new HashSet<int>();

		private static readonly Dictionary<int, (bool Open, Action? Callback)> _drawerMoveRefused = new Dictionary<int, (bool, Action)>();

		private static readonly HashSet<int> _drawerRefusalSaid = new HashSet<int>();

		private static readonly Dictionary<int, Drawer> _savedWhileLocked = new Dictionary<int, Drawer>();

		private static readonly (string Name, bool WhenLocked)[] Gates = new(string, bool)[3]
		{
			("PreventSelection", true),
			("Interactable", false),
			("Selectable", false)
		};

		private static readonly List<(MemberInfo, bool)> NoGates = new List<(MemberInfo, bool)>();

		private static readonly PropertyInfo[] NoNested = new PropertyInfo[0];

		private static readonly Dictionary<string, (Type?, List<(MemberInfo, bool)>, PropertyInfo[])> _shadowed = new Dictionary<string, (Type, List<(MemberInfo, bool)>, PropertyInfo[])>();

		private static readonly HashSet<string> _drawersSaid = new HashSet<string>(StringComparer.Ordinal);

		private static readonly Dictionary<int, string> _classes = new Dictionary<int, string>();

		private static readonly HashSet<int> _fadingIn = new HashSet<int>();

		internal static void Reset()
		{
			if (_flagged.Count > 0 || _colliders.Count > 0 || _bodies.Count > 0 || _tinted.Count > 0)
			{
				_releasing = true;
				try
				{
					Apply(Released);
				}
				finally
				{
					_releasing = false;
				}
			}
			_lastSummary = "";
			_original.Clear();
			_tinted.Clear();
			_fadingIn.Clear();
			_classes.Clear();
			_colliders.Clear();
			_bodies.Clear();
			_flagged.Clear();
			_savedWhileLocked.Clear();
			_gameInteractable.Clear();
			HeldIndexes.Clear();
			_heldArt.Clear();
			_heldButtons.Clear();
			_clearers = null;
			_matches = null;
			_handlesSaid = "";
			ApplyNow();
		}

		[HarmonyPatch(typeof(ObjectController), "RegisterObjectController")]
		[HarmonyPostfix]
		private static void AfterRegister()
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Expected O, but got Unknown
			try
			{
				AbilityState abilities = Inventory.Abilities;
				if (abilities != null && abilities.LocksEnabled)
				{
					HoldDim();
				}
			}
			catch (Exception ex)
			{
				ManualLogSource logger = Plugin.Logger;
				bool flag = default(bool);
				BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(33, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("abilities: register hook failed: ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(ex.Message);
				}
				logger.LogWarning(val);
			}
		}

		internal static void Tick(float dt)
		{
			if (!(Time.unscaledTime >= _holdUntil))
			{
				AbilityState abilities = Inventory.Abilities;
				if (abilities != null && abilities.LocksEnabled)
				{
					Apply(abilities);
				}
			}
		}

		internal static void AttachGameEvents()
		{
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Expected O, but got Unknown
			if (_eventsAttached)
			{
				return;
			}
			try
			{
				Redim<GameEvent_ObjectDrawerChanged>("DrawerChanged", (Func<bool>?)null);
				Redim<GameEvent_ObjectControllerEnteredPhase>("EnteredPhase", (Func<bool>?)null);
				Redim<GameEvent_LevelReset>("LevelReset", (Func<bool>?)null);
				Redim<GameEvent_LevelRandomized>("LevelRandomized", (Func<bool>?)null);
				Redim<GameEvent_LevelTransitionInComplete>("TransitionInComplete", (Func<bool>?)null);
				Redim<GameEvent_InterludeEnd>("InterludeEnd", (Func<bool>?)LevelHasRag);
				OnLevelEnd<GameEvent_LevelComplete>();
				OnLevelEnd<GameEvent_LevelExited>();
				_eventsAttached = true;
				Plugin.Logger.LogInfo((object)"abilities: listening for rebuilds");
			}
			catch (Exception ex)
			{
				ManualLogSource logger = Plugin.Logger;
				bool flag = default(bool);
				BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(39, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("abilities: could not attach listeners: ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(ex.Message);
				}
				logger.LogWarning(val);
			}
		}

		private static void Redim<T>(string label, Func<bool>? only = null) where T : GameEvent
		{
			Action<GameEventData> val = Action<GameEventData>.op_Implicit((Action<GameEventData>)delegate
			{
				//IL_006b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0071: Expected O, but got Unknown
				try
				{
					_eventCounts[label] = ((!_eventCounts.TryGetValue(label, out var value)) ? 1 : (value + 1));
					AbilityState abilities = Inventory.Abilities;
					if (abilities != null && abilities.LocksEnabled && (only == null || only()))
					{
						HoldDim();
					}
				}
				catch (Exception ex)
				{
					ManualLogSource logger = Plugin.Logger;
					bool flag = default(bool);
					BepInExWarningLogInterpolatedStringHandler val2 = new BepInExWarningLogInterpolatedStringHandler(28, 2, ref flag);
					if (flag)
					{
						((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("abilities: ");
						((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>(label);
						((BepInExLogInterpolatedStringHandler)val2).AppendLiteral(" handler failed: ");
						((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>(ex.Message);
					}
					logger.LogWarning(val2);
				}
			});
			KeepAlive.Add(val);
			GameEventManager.AddEventListener<T>(val);
		}

		private static void OnLevelEnd<T>() where T : GameEvent
		{
			Action<GameEventData> val = Action<GameEventData>.op_Implicit((Action<GameEventData>)delegate
			{
				try
				{
					GameManager instance = GameManager.Instance;
					object obj;
					if (instance == null)
					{
						obj = null;
					}
					else
					{
						LevelManager levelManager = instance.levelManager;
						if (levelManager == null)
						{
							obj = null;
						}
						else
						{
							LevelInterface activeLevelInterface = levelManager.ActiveLevelInterface;
							obj = ((activeLevelInterface != null) ? activeLevelInterface.LevelId : null);
						}
					}
					if (obj == null)
					{
						obj = "?";
					}
					ReportEvents((string)obj);
				}
				catch
				{
				}
			});
			KeepAlive.Add(val);
			GameEventManager.AddEventListener<T>(val);
		}

		private static void ReportEvents(string levelId)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Expected O, but got Unknown
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Expected O, but got Unknown
			bool flag = default(bool);
			if (_reentered > 0)
			{
				ManualLogSource logger = Plugin.Logger;
				BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(53, 2, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("abilities: a lock pass re-entered itself ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<int>(_reentered);
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" time(s) on ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(levelId);
				}
				logger.LogWarning(val);
				_reentered = 0;
			}
			if (_eventCounts.Count == 0)
			{
				return;
			}
			List<string> list = new List<string>();
			foreach (KeyValuePair<string, int> eventCount in _eventCounts)
			{
				list.Add($"{eventCount.Key}={eventCount.Value}");
			}
			ManualLogSource logger2 = Plugin.Logger;
			BepInExInfoLogInterpolatedStringHandler val2 = new BepInExInfoLogInterpolatedStringHandler(30, 2, ref flag);
			if (flag)
			{
				((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("abilities: re-dim events on ");
				((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>(levelId);
				((BepInExLogInterpolatedStringHandler)val2).AppendLiteral(": ");
				((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>(string.Join(", ", list));
			}
			logger2.LogInfo(val2);
			_eventCounts.Clear();
		}

		internal static void ApplyNow()
		{
			AbilityState abilities = Inventory.Abilities;
			if (abilities != null && abilities.LocksEnabled)
			{
				Apply(abilities);
			}
		}

		internal static void AbilitiesChanged()
		{
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Expected O, but got Unknown
			int count = _flagged.Count;
			ApplyNow();
			try
			{
				GameManager instance = GameManager.Instance;
				object obj;
				if (instance == null)
				{
					obj = null;
				}
				else
				{
					LevelManager levelManager = instance.levelManager;
					if (levelManager == null)
					{
						obj = null;
					}
					else
					{
						LevelInterface activeLevelInterface = levelManager.ActiveLevelInterface;
						obj = ((activeLevelInterface != null) ? activeLevelInterface.LevelId : null);
					}
				}
				if (obj == null)
				{
					obj = "";
				}
				string text = (string)obj;
				if (ObjectLock.ResetOnUnlock(text, count, _flagged.Count))
				{
					Traps.ResetQuietly($"{text}: {count - _flagged.Count} piece(s) unlocked mid-level, " + "reloaded so the game sets its pieces up again");
				}
			}
			catch (Exception ex)
			{
				ManualLogSource logger = Plugin.Logger;
				bool flag = default(bool);
				BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(35, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("abilities: reset on unlock failed: ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(ex.Message);
				}
				logger.LogWarning(val);
			}
		}

		internal static void HoldDim(float seconds = 0.5f)
		{
			_holdUntil = Time.unscaledTime + seconds;
			ApplyNow();
		}

		private static void Apply(AbilityState state)
		{
			if (_applying)
			{
				_again = true;
				_reentered++;
				return;
			}
			_applying = true;
			try
			{
				int num = 0;
				do
				{
					_again = false;
					ApplyOnce(state);
				}
				while (_again && ++num < 2);
			}
			finally
			{
				_applying = false;
			}
		}

		private static void ApplyOnce(AbilityState state)
		{
			//IL_021e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0225: Expected O, but got Unknown
			//IL_01e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f0: Expected O, but got Unknown
			bool flag2 = default(bool);
			try
			{
				GameManager instance = GameManager.Instance;
				object obj;
				if (instance == null)
				{
					obj = null;
				}
				else
				{
					LevelManager levelManager = instance.levelManager;
					obj = ((levelManager != null) ? levelManager.ActiveLevelInterface : null);
				}
				LevelInterface val = (LevelInterface)obj;
				Level val2 = ((val != null) ? val.Level : null);
				List<ObjectController> val3 = ((val2 != null) ? val2.objectControllers : null);
				string text = ((val != null) ? val.LevelId : null) ?? "";
				if (val3 == null || val3.Count == 0)
				{
					_lastSummary = "";
					return;
				}
				int num = 0;
				int num2 = 0;
				SortedSet<string> sortedSet = new SortedSet<string>(StringComparer.Ordinal);
				Dictionary<int, ObjectLock> votes = new Dictionary<int, ObjectLock>();
				Dictionary<int, LevelObject> byId = new Dictionary<int, LevelObject>();
				for (int i = 0; i < val3.Count; i++)
				{
					ObjectController val4 = val3[i];
					if ((Object)(object)val4 == (Object)null)
					{
						continue;
					}
					GameObject gameObject = ((Component)val4).gameObject;
					string text2 = ObjectLock.LockClass(text, ((gameObject != null) ? ((Object)gameObject).name : null) ?? "", ClassOf(val4));
					bool flag = state.IsClassLocked(text2);
					if (flag)
					{
						num++;
						string text3 = state.AbilityFor(text2);
						if (!string.IsNullOrEmpty(text3))
						{
							sortedSet.Add(text3);
						}
					}
					else
					{
						num2++;
					}
					Collect(val4, text2, flag, text, votes, byId);
				}
				NoteHandles(val2, text, votes, byId);
				int value = ApplyWanted(votes, byId);
				HoldIndexes(val, val3, text, state);
				string text4 = $"{num} locked, {num2} open, {value} objects" + ((sortedSet.Count > 0) ? (", waiting on " + string.Join(", ", sortedSet)) : "");
				if (!(text4 == _lastSummary))
				{
					_lastSummary = text4;
					ManualLogSource logger = Plugin.Logger;
					BepInExInfoLogInterpolatedStringHandler val5 = new BepInExInfoLogInterpolatedStringHandler(11, 1, ref flag2);
					if (flag2)
					{
						((BepInExLogInterpolatedStringHandler)val5).AppendLiteral("abilities: ");
						((BepInExLogInterpolatedStringHandler)val5).AppendFormatted<string>(text4);
					}
					logger.LogInfo(val5);
				}
			}
			catch (Exception ex)
			{
				ManualLogSource logger2 = Plugin.Logger;
				BepInExWarningLogInterpolatedStringHandler val6 = new BepInExWarningLogInterpolatedStringHandler(52, 1, ref flag2);
				if (flag2)
				{
					((BepInExLogInterpolatedStringHandler)val6).AppendLiteral("abilities: pass failed, leaving everything movable: ");
					((BepInExLogInterpolatedStringHandler)val6).AppendFormatted<string>(ex.Message);
				}
				logger2.LogWarning(val6);
			}
		}

		private static void HoldIndexes(LevelInterface? active, List<ObjectController> controllers, string levelId, AbilityState state)
		{
			int num = ((!((Object)(object)((active != null) ? active.Level : null) == (Object)null)) ? ((Object)active.Level).GetInstanceID() : 0);
			if (num != _indexLevelCopy)
			{
				_indexLevelCopy = num;
				HeldIndexes.Clear();
				_heldArt.Clear();
				_heldButtons.Clear();
			}
			if (!ObjectLock.IndexHoldLevels.Contains(levelId))
			{
				HeldIndexes.Clear();
				_heldArt.Clear();
				_heldButtons.Clear();
				return;
			}
			bool flag = (Object)(object)active != (Object)null && active.LevelIsLoaded && !active.IsTransitioning;
			ObjectLock.IndexHoldArt.TryGetValue(levelId, out var value);
			int count = HeldIndexes.Count;
			for (int i = 0; i < controllers.Count; i++)
			{
				ObjectController val = controllers[i];
				Indexables obj = (((Object)(object)val == (Object)null) ? null : ((Il2CppObjectBase)val).TryCast<Indexables>());
				List<IndexedAttribute> val2 = ((obj != null) ? obj.AllIndexes : null);
				if (val2 == null)
				{
					continue;
				}
				GameObject gameObject = ((Component)val).gameObject;
				string text = ObjectLock.LockClass(levelId, ((gameObject != null) ? ((Object)gameObject).name : null) ?? "", ClassOf(val));
				bool flag2 = ObjectLock.HoldsIndexes(levelId, state.IsClassLocked(text));
				for (int j = 0; j < val2.Count; j++)
				{
					IndexedAttribute val3 = val2[j];
					if (!((Object)(object)val3 == (Object)null))
					{
						if (flag2 && flag)
						{
							HeldIndexes.Add(((Object)val3).GetInstanceID());
						}
						else if (!flag2)
						{
							HeldIndexes.Remove(((Object)val3).GetInstanceID());
						}
						if (value != null && (flag || !flag2))
						{
							HoldArt(val3, value, flag2);
						}
					}
				}
			}
			HoldButtons(active);
			if (HeldIndexes.Count != count)
			{
				Plugin.Logger.LogInfo((object)((HeldIndexes.Count > 0) ? $"abilities: holding {HeldIndexes.Count} indexed state(s) on {levelId} where they are" : ("abilities: indexed states on " + levelId + " given back")));
			}
		}

		private static void HoldButtons(LevelInterface? active)
		{
			Level val = ((active != null) ? active.Level : null);
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			Il2CppArrayBase<IndexIncrementTrigger> componentsInChildren = ((Component)val).GetComponentsInChildren<IndexIncrementTrigger>(true);
			for (int i = 0; i < componentsInChildren.Length; i++)
			{
				IndexIncrementTrigger val2 = componentsInChildren[i];
				IndexedAttribute val3 = (((Object)(object)val2 == (Object)null) ? null : val2.IndexedAttribute);
				if ((Object)(object)val3 == (Object)null)
				{
					continue;
				}
				bool flag = HeldIndexes.Contains(((Object)val3).GetInstanceID());
				Il2CppArrayBase<Collider2D> components = ((Component)val2).GetComponents<Collider2D>();
				for (int j = 0; j < components.Length; j++)
				{
					Collider2D val4 = components[j];
					if ((Object)(object)val4 == (Object)null)
					{
						continue;
					}
					int instanceID = ((Object)val4).GetInstanceID();
					if (flag)
					{
						if (((Behaviour)val4).enabled)
						{
							((Behaviour)val4).enabled = false;
							_heldButtons[instanceID] = val4;
						}
					}
					else if (_heldButtons.Remove(instanceID))
					{
						((Behaviour)val4).enabled = true;
					}
				}
			}
		}

		private static void HoldArt(IndexedAttribute attr, IReadOnlyList<string> names, bool hold)
		{
			Transform val = (((Object)(object)attr.attachedObject != (Object)null) ? ((Component)attr.attachedObject).transform : ((Component)attr).transform);
			foreach (string name in names)
			{
				Transform val2 = val.Find(name);
				SpriteRenderer val3 = (((Object)(object)val2 == (Object)null) ? null : ((Component)val2).GetComponent<SpriteRenderer>());
				if (!((Object)(object)val3 == (Object)null))
				{
					int instanceID = ((Object)val3).GetInstanceID();
					if (hold)
					{
						_heldArt.Add(instanceID);
					}
					else if (!_heldArt.Remove(instanceID))
					{
						continue;
					}
					Paint(val3, hold);
				}
			}
		}

		private static void Collect(ObjectController controller, string cls, bool isLocked, string levelId, Dictionary<int, ObjectLock> votes, Dictionary<int, LevelObject> byId)
		{
			Note(controller.ManagedObjects, cls, isLocked, levelId, votes, byId);
			var (concrete, array) = ExtraLists(controller);
			if (array.Length == 0)
			{
				return;
			}
			object obj = Recast((Il2CppObjectBase)(object)controller, concrete);
			if (obj == null)
			{
				return;
			}
			PropertyInfo[] array2 = array;
			foreach (PropertyInfo propertyInfo in array2)
			{
				try
				{
					Note(propertyInfo.GetValue(obj), cls, isLocked, levelId, votes, byId);
				}
				catch
				{
				}
			}
		}

		private static void Note(object? list, string cls, bool isLocked, string levelId, Dictionary<int, ObjectLock> votes, Dictionary<int, LevelObject> byId)
		{
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Expected O, but got Unknown
			//IL_004f: Expected O, but got Unknown
			if (list == null)
			{
				return;
			}
			foreach (LevelObject item in Walk(list))
			{
				if ((Object)(object)item == (Object)null)
				{
					continue;
				}
				try
				{
					int instanceID = ((Object)item).GetInstanceID();
					byId[instanceID] = item;
					if (!votes.TryGetValue(instanceID, out ObjectLock value))
					{
						ObjectLock val = new ObjectLock(levelId);
						value = val;
						votes[instanceID] = val;
					}
					value.Add(cls, isLocked);
				}
				catch
				{
				}
			}
		}

		private static void NoteHandles(Level level, string levelId, Dictionary<int, ObjectLock> votes, Dictionary<int, LevelObject> byId)
		{
			//IL_02f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fb: Expected O, but got Unknown
			//IL_01e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ea: Expected O, but got Unknown
			//IL_01ef: Expected O, but got Unknown
			List<(LevelObject, List<int>)> list = new List<(LevelObject, List<int>)>();
			List<int> list2 = new List<int>();
			List<int> list3 = new List<int>();
			int num = 0;
			int num2 = 0;
			int num3 = 0;
			foreach (KeyValuePair<int, LevelObject> item3 in byId)
			{
				try
				{
					if ((Object)(object)((Il2CppObjectBase)item3.Value).TryCast<ClearableObject>() != (Object)null)
					{
						list2.Add(item3.Key);
						continue;
					}
					if ((Object)(object)((Il2CppObjectBase)item3.Value).TryCast<Candle>() != (Object)null)
					{
						list3.Add(item3.Key);
						continue;
					}
					StickerObject obj = ((Il2CppObjectBase)item3.Value).TryCast<StickerObject>();
					PluckObject val = ((obj != null) ? obj.pluckObj : null);
					if (!((Object)(object)val == (Object)null))
					{
						list.Add(((LevelObject)(object)val, new List<int> { item3.Key }));
						num++;
					}
				}
				catch
				{
				}
			}
			foreach (ClearingObject item4 in Clearers(level))
			{
				list.Add(((LevelObject)(object)item4, list2));
				num2++;
			}
			foreach (Match item5 in Matches(level))
			{
				list.Add(((LevelObject)(object)item5, list3));
				num3++;
			}
			int num4 = ((num2 > 0) ? list2.Count : 0);
			int num5 = ((num3 > 0) ? list3.Count : 0);
			foreach (var item6 in list)
			{
				LevelObject item = item6.Item1;
				List<int> item2 = item6.Item2;
				int instanceID = ((Object)item).GetInstanceID();
				foreach (int item7 in item2)
				{
					if (votes.TryGetValue(item7, out ObjectLock value))
					{
						if (!votes.TryGetValue(instanceID, out ObjectLock value2))
						{
							ObjectLock val2 = new ObjectLock(levelId);
							value2 = val2;
							votes[instanceID] = val2;
						}
						byId[instanceID] = item;
						value2.Add("Handle", !value.Unlocked);
					}
				}
			}
			string text = $"{levelId}|{num}|{num2}|{num4}|{num3}|{num5}";
			if (list.Count > 0 && text != _handlesSaid)
			{
				_handlesSaid = text;
				ManualLogSource logger = Plugin.Logger;
				bool flag = default(bool);
				BepInExInfoLogInterpolatedStringHandler val3 = new BepInExInfoLogInterpolatedStringHandler(114, 5, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val3).AppendLiteral("abilities: handles vote with what they act on: ");
					((BepInExLogInterpolatedStringHandler)val3).AppendFormatted<int>(num);
					((BepInExLogInterpolatedStringHandler)val3).AppendLiteral(" peel ");
					((BepInExLogInterpolatedStringHandler)val3).AppendLiteral("handle(s), ");
					((BepInExLogInterpolatedStringHandler)val3).AppendFormatted<int>(num2);
					((BepInExLogInterpolatedStringHandler)val3).AppendLiteral(" rag(s) over ");
					((BepInExLogInterpolatedStringHandler)val3).AppendFormatted<int>(num4);
					((BepInExLogInterpolatedStringHandler)val3).AppendLiteral(" piece(s), ");
					((BepInExLogInterpolatedStringHandler)val3).AppendFormatted<int>(num3);
					((BepInExLogInterpolatedStringHandler)val3).AppendLiteral(" match(es) over ");
					((BepInExLogInterpolatedStringHandler)val3).AppendFormatted<int>(num5);
					((BepInExLogInterpolatedStringHandler)val3).AppendLiteral(" candle(s)");
				}
				logger.LogInfo(val3);
			}
		}

		private static List<ClearingObject> Clearers(Level level)
		{
			int instanceID = ((Object)level).GetInstanceID();
			if (_clearers != null && _clearersFor == instanceID)
			{
				return _clearers;
			}
			_clearersFor = instanceID;
			_clearers = new List<ClearingObject>();
			try
			{
				foreach (ClearingObject componentsInChild in ((Component)level).GetComponentsInChildren<ClearingObject>(true))
				{
					if ((Object)(object)componentsInChild != (Object)null)
					{
						_clearers.Add(componentsInChild);
					}
				}
			}
			catch
			{
			}
			return _clearers;
		}

		private static List<Match> Matches(Level level)
		{
			int instanceID = ((Object)level).GetInstanceID();
			if (_matches != null && _matchesFor == instanceID)
			{
				return _matches;
			}
			_matchesFor = instanceID;
			_matches = new List<Match>();
			try
			{
				foreach (Match componentsInChild in ((Component)level).GetComponentsInChildren<Match>(true))
				{
					if ((Object)(object)componentsInChild != (Object)null)
					{
						_matches.Add(componentsInChild);
					}
				}
			}
			catch
			{
			}
			return _matches;
		}

		private static bool LevelHasRag()
		{
			try
			{
				GameManager instance = GameManager.Instance;
				object obj;
				if (instance == null)
				{
					obj = null;
				}
				else
				{
					LevelManager levelManager = instance.levelManager;
					if (levelManager == null)
					{
						obj = null;
					}
					else
					{
						LevelInterface activeLevelInterface = levelManager.ActiveLevelInterface;
						obj = ((activeLevelInterface != null) ? activeLevelInterface.Level : null);
					}
				}
				Level val = (Level)obj;
				return (Object)(object)val != (Object)null && _clearers != null && _clearers.Count > 0 && _clearersFor == ((Object)val).GetInstanceID();
			}
			catch
			{
				return false;
			}
		}

		private static IEnumerable<LevelObject> Walk(object list)
		{
			if (list is IEnumerable<LevelObject> enumerable)
			{
				foreach (LevelObject item in enumerable)
				{
					yield return item;
				}
				yield break;
			}
			Type type = list.GetType();
			PropertyInfo property = type.GetProperty("Count");
			PropertyInfo itemProp = type.GetProperty("Item");
			if (property == null || itemProp == null)
			{
				yield break;
			}
			int count;
			try
			{
				count = (int)(property.GetValue(list) ?? ((object)0));
			}
			catch
			{
				yield break;
			}
			for (int i = 0; i < count; i++)
			{
				LevelObject val = null;
				try
				{
					object? value = itemProp.GetValue(list, new object[1] { i });
					val = (LevelObject)((value is LevelObject) ? value : null);
				}
				catch
				{
				}
				if ((Object)(object)val != (Object)null)
				{
					yield return val;
				}
			}
		}

		private static (Type?, PropertyInfo[]) ExtraLists(ObjectController controller)
		{
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Expected O, but got Unknown
			string text = ClassOf(controller);
			if (_extraLists.TryGetValue(text, out (Type, PropertyInfo[]) value))
			{
				return value;
			}
			Type type = WrapperFor(text, typeof(ObjectController));
			List<PropertyInfo> list = new List<PropertyInfo>();
			if (type != null)
			{
				try
				{
					PropertyInfo[] properties = type.GetProperties(BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
					foreach (PropertyInfo propertyInfo in properties)
					{
						if (propertyInfo.GetIndexParameters().Length == 0 && HoldsLevelObjects(propertyInfo.PropertyType))
						{
							list.Add(propertyInfo);
						}
					}
				}
				catch (Exception ex)
				{
					ManualLogSource logger = Plugin.Logger;
					bool flag = default(bool);
					BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(64, 2, ref flag);
					if (flag)
					{
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral("abilities: could not inspect ");
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(text);
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral(", locking only its ");
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral("ManagedObjects: ");
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(ex.Message);
					}
					logger.LogWarning(val);
				}
			}
			if (list.Count > 0)
			{
				Plugin.Logger.LogInfo((object)("abilities: " + text + " keeps objects outside ManagedObjects: " + string.Join(", ", list.ConvertAll((PropertyInfo p) => p.Name))));
			}
			(Type, PropertyInfo[]) tuple = (type, list.ToArray());
			_extraLists[text] = tuple;
			return tuple;
		}

		private static Type? WrapperFor(string cls, Type mustDeriveFrom)
		{
			if (string.IsNullOrEmpty(cls))
			{
				return null;
			}
			Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
			foreach (Assembly assembly in assemblies)
			{
				Type[] types;
				try
				{
					types = assembly.GetTypes();
				}
				catch (ReflectionTypeLoadException ex)
				{
					types = ex.Types;
				}
				catch
				{
					continue;
				}
				Type[] array = types;
				foreach (Type type in array)
				{
					if (type != null && type.Name == cls && mustDeriveFrom.IsAssignableFrom(type))
					{
						return type;
					}
				}
			}
			return null;
		}

		private static object? Recast(Il2CppObjectBase controller, Type? concrete)
		{
			if (concrete == null)
			{
				return null;
			}
			try
			{
				return (typeof(Il2CppObjectBase).GetMethod("TryCast")?.MakeGenericMethod(concrete))?.Invoke(controller, null);
			}
			catch
			{
				return null;
			}
		}

		private static bool HoldsLevelObjects(Type type)
		{
			if (typeof(IEnumerable<LevelObject>).IsAssignableFrom(type))
			{
				return true;
			}
			if (!type.IsGenericType)
			{
				return false;
			}
			Type[] genericArguments = type.GetGenericArguments();
			if (genericArguments.Length == 1)
			{
				return typeof(LevelObject).IsAssignableFrom(genericArguments[0]);
			}
			return false;
		}

		private static void Freeze(LevelObject obj, bool isLocked, bool solid = false, bool inDrawer = false)
		{
			Collider2D collider = obj.collider;
			Rigidbody2D rigidbody = obj.rigidbody;
			if (isLocked && !solid)
			{
				if ((Object)(object)rigidbody != (Object)null)
				{
					int instanceID = ((Object)rigidbody).GetInstanceID();
					if (!_bodies.ContainsKey(instanceID) || rigidbody.simulated)
					{
						_bodies[instanceID] = rigidbody.simulated;
					}
					rigidbody.simulated = false;
				}
				if ((Object)(object)collider != (Object)null)
				{
					int instanceID2 = ((Object)collider).GetInstanceID();
					if (!_colliders.ContainsKey(instanceID2) || ((Behaviour)collider).enabled)
					{
						_colliders[instanceID2] = ((Behaviour)collider).enabled;
					}
					((Behaviour)collider).enabled = false;
				}
				return;
			}
			if ((Object)(object)collider != (Object)null && _colliders.TryGetValue(((Object)collider).GetInstanceID(), out var value))
			{
				if (!((Behaviour)collider).enabled)
				{
					((Behaviour)collider).enabled = value;
				}
				_colliders.Remove(((Object)collider).GetInstanceID());
			}
			if ((Object)(object)rigidbody != (Object)null && _bodies.TryGetValue(((Object)rigidbody).GetInstanceID(), out var value2))
			{
				if (!rigidbody.simulated)
				{
					rigidbody.simulated = inDrawer || value2;
				}
				_bodies.Remove(((Object)rigidbody).GetInstanceID());
			}
		}

		internal static bool IsLocked(LevelObject? obj)
		{
			try
			{
				return (Object)(object)obj != (Object)null && _flagged.Contains(((Object)obj).GetInstanceID());
			}
			catch
			{
				return false;
			}
		}

		[HarmonyPatch(typeof(AnimScrubObject), "ScrubPickedUp")]
		[HarmonyPrefix]
		private static bool BeforeScrubPickedUp(AnimScrubObject __instance)
		{
			return !RefuseScrub(__instance);
		}

		[HarmonyPatch(typeof(AnimScrubObject), "Scrubbing")]
		[HarmonyPrefix]
		private static bool BeforeScrubbing(AnimScrubObject __instance)
		{
			return !RefuseScrub(__instance);
		}

		[HarmonyPatch(typeof(AnimScrubObject), "ScrubReleased")]
		[HarmonyPrefix]
		private static bool BeforeScrubReleased(AnimScrubObject __instance)
		{
			return !RefuseScrub(__instance);
		}

		private static bool RefuseScrub(AnimScrubObject scrub)
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Expected O, but got Unknown
			try
			{
				if (!IsLocked((LevelObject?)(object)scrub))
				{
					return false;
				}
				if (_scrubRefusalSaid.Add(((Object)scrub).GetInstanceID()))
				{
					ManualLogSource logger = Plugin.Logger;
					bool flag = default(bool);
					BepInExInfoLogInterpolatedStringHandler val = new BepInExInfoLogInterpolatedStringHandler(46, 1, ref flag);
					if (flag)
					{
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral("abilities: '");
						GameObject gameObject = ((Component)scrub).gameObject;
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(((gameObject != null) ? ((Object)gameObject).name : null) ?? "?");
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral("' is locked - its scrub is refused");
					}
					logger.LogInfo(val);
				}
				return true;
			}
			catch
			{
				return false;
			}
		}

		[HarmonyPatch(typeof(Drawer), "OpenDrawer")]
		[HarmonyPrefix]
		private static bool BeforeOpenDrawer(Drawer __instance, Action __0)
		{
			return !RefuseDrawerMove(__instance, open: true, __0);
		}

		[HarmonyPatch(typeof(Drawer), "CloseDrawer")]
		[HarmonyPrefix]
		private static bool BeforeCloseDrawer(Drawer __instance, Action __0)
		{
			return !RefuseDrawerMove(__instance, open: false, __0);
		}

		private static bool RefuseDrawerMove(Drawer drawer, bool open, Action? callback)
		{
			try
			{
				if (!IsLocked((LevelObject?)(object)drawer))
				{
					return false;
				}
				int instanceID = ((Object)drawer).GetInstanceID();
				_drawerMoveRefused[instanceID] = (open, callback);
				if (_drawerRefusalSaid.Add(instanceID))
				{
					ManualLogSource logger = Plugin.Logger;
					GameObject gameObject = ((Component)drawer).gameObject;
					logger.LogInfo((object)("abilities: drawer '" + (((gameObject != null) ? ((Object)gameObject).name : null) ?? "?") + "' is locked - the game's own open or close waits for the ability"));
				}
				return true;
			}
			catch
			{
				return false;
			}
		}

		private static void ReplayRefusedDrawer(int id, LevelObject obj)
		{
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Expected O, but got Unknown
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Expected O, but got Unknown
			if (!_drawerMoveRefused.TryGetValue(id, out (bool, Action) value))
			{
				return;
			}
			_drawerMoveRefused.Remove(id);
			bool flag = default(bool);
			try
			{
				Drawer val = ((Il2CppObjectBase)obj).TryCast<Drawer>();
				if (!((Object)(object)val == (Object)null) && val.Open != value.Item1)
				{
					ManualLogSource logger = Plugin.Logger;
					BepInExInfoLogInterpolatedStringHandler val2 = new BepInExInfoLogInterpolatedStringHandler(54, 2, ref flag);
					if (flag)
					{
						((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("abilities: drawer '");
						GameObject gameObject = ((Component)obj).gameObject;
						((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>(((gameObject != null) ? ((Object)gameObject).name : null) ?? "?");
						((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("' unlocked - ");
						((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>(value.Item1 ? "opening" : "closing");
						((BepInExLogInterpolatedStringHandler)val2).AppendLiteral(" it, as the game asked");
					}
					logger.LogInfo(val2);
					if (value.Item1)
					{
						val.OpenDrawer(value.Item2);
					}
					else
					{
						val.CloseDrawer(value.Item2);
					}
				}
			}
			catch (Exception ex)
			{
				ManualLogSource logger2 = Plugin.Logger;
				BepInExWarningLogInterpolatedStringHandler val3 = new BepInExWarningLogInterpolatedStringHandler(45, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val3).AppendLiteral("abilities: moving a drawer on unlock failed: ");
					((BepInExLogInterpolatedStringHandler)val3).AppendFormatted<string>(ex.Message);
				}
				logger2.LogWarning(val3);
			}
		}

		[HarmonyPatch(typeof(Drawer), "SetContainedObjectsInteractable")]
		[HarmonyPostfix]
		private static void AfterDrawerSetsContents(Drawer __instance)
		{
			try
			{
				if (_flagged.Count == 0)
				{
					return;
				}
				Dictionary<LevelObject, bool> contentsInitialInteractableStates = __instance.m_contentsInitialInteractableStates;
				if (contentsInitialInteractableStates == null || contentsInitialInteractableStates.Count == 0)
				{
					return;
				}
				Enumerator<LevelObject, bool> enumerator = contentsInitialInteractableStates.GetEnumerator();
				while (enumerator.MoveNext())
				{
					KeyValuePair<LevelObject, bool> current = enumerator.Current;
					LevelObject key = current.Key;
					if (!((Object)(object)key == (Object)null) && !current.Value)
					{
						int instanceID = ((Object)key).GetInstanceID();
						if (_flagged.Contains(instanceID))
						{
							_savedWhileLocked[instanceID] = __instance;
						}
					}
				}
			}
			catch
			{
			}
		}

		private static void FreeSavedState(int id, LevelObject obj)
		{
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Expected O, but got Unknown
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Expected O, but got Unknown
			if (!_savedWhileLocked.TryGetValue(id, out Drawer value))
			{
				return;
			}
			_savedWhileLocked.Remove(id);
			bool flag = default(bool);
			try
			{
				if ((Object)(object)value == (Object)null)
				{
					return;
				}
				Dictionary<LevelObject, bool> contentsInitialInteractableStates = value.m_contentsInitialInteractableStates;
				if (contentsInitialInteractableStates != null && contentsInitialInteractableStates.ContainsKey(obj))
				{
					contentsInitialInteractableStates[obj] = true;
					ManualLogSource logger = Plugin.Logger;
					BepInExInfoLogInterpolatedStringHandler val = new BepInExInfoLogInterpolatedStringHandler(90, 2, ref flag);
					if (flag)
					{
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral("abilities: '");
						GameObject gameObject = ((Component)obj).gameObject;
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(((gameObject != null) ? ((Object)gameObject).name : null) ?? "?");
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral("' was shut in drawer ");
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral("'");
						GameObject gameObject2 = ((Component)value).gameObject;
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(((gameObject2 != null) ? ((Object)gameObject2).name : null) ?? "?");
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral("' while locked - it comes out free when the drawer opens");
					}
					logger.LogInfo(val);
				}
			}
			catch (Exception ex)
			{
				ManualLogSource logger2 = Plugin.Logger;
				BepInExWarningLogInterpolatedStringHandler val2 = new BepInExWarningLogInterpolatedStringHandler(50, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("abilities: freeing a drawer's saved state failed: ");
					((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>(ex.Message);
				}
				logger2.LogWarning(val2);
			}
		}

		private static void SetFlagsOnOwnClass(LevelObject obj, bool isLocked, int depth = 0)
		{
			var (concrete, list, array) = Shadowed(obj);
			if (list.Count == 0 && array.Length == 0)
			{
				return;
			}
			object obj2 = Recast((Il2CppObjectBase)(object)obj, concrete);
			if (obj2 == null)
			{
				return;
			}
			foreach (var item3 in list)
			{
				MemberInfo item = item3.Item1;
				bool item2 = item3.Item2;
				bool flag = (isLocked ? item2 : (!item2));
				try
				{
					if (item is PropertyInfo propertyInfo)
					{
						propertyInfo.SetValue(obj2, flag);
					}
					else if (item is MethodInfo methodInfo)
					{
						methodInfo.Invoke(obj2, new object[1] { flag });
					}
				}
				catch
				{
				}
			}
		}

		private static (Type?, List<(MemberInfo, bool)>, PropertyInfo[]) Shadowed(LevelObject obj)
		{
			//IL_01b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bd: Expected O, but got Unknown
			//IL_0338: Unknown result type (might be due to invalid IL or missing references)
			//IL_033f: Expected O, but got Unknown
			string text;
			try
			{
				Type il2CppType = ((Object)obj).GetIl2CppType();
				text = ((il2CppType != null) ? ((MemberInfo)il2CppType).Name : null) ?? "";
			}
			catch
			{
				return (null, NoGates, NoNested);
			}
			if (_shadowed.TryGetValue(text, out (Type, List<(MemberInfo, bool)>, PropertyInfo[]) value))
			{
				return value;
			}
			Type type = null;
			List<(MemberInfo, bool)> list = new List<(MemberInfo, bool)>();
			List<PropertyInfo> list2 = new List<PropertyInfo>();
			bool flag = default(bool);
			try
			{
				type = WrapperFor(text, typeof(LevelObject));
				if (type != null && type != typeof(LevelObject))
				{
					Type[] types = new Type[1] { typeof(bool) };
					(string, bool)[] gates = Gates;
					for (int i = 0; i < gates.Length; i++)
					{
						(string, bool) tuple = gates[i];
						string item = tuple.Item1;
						bool item2 = tuple.Item2;
						PropertyInfo property = type.GetProperty(item, BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
						if (property != null && property.PropertyType == typeof(bool) && property.CanWrite)
						{
							list.Add((property, item2));
							continue;
						}
						MethodInfo method = type.GetMethod("Set" + item, BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, types, null);
						if (method != null)
						{
							list.Add((method, item2));
						}
					}
					PropertyInfo[] properties = type.GetProperties(BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
					foreach (PropertyInfo propertyInfo in properties)
					{
						if (propertyInfo.GetIndexParameters().Length == 0 && propertyInfo.CanRead && typeof(LevelObject).IsAssignableFrom(propertyInfo.PropertyType))
						{
							list2.Add(propertyInfo);
						}
					}
				}
			}
			catch (Exception ex)
			{
				ManualLogSource logger = Plugin.Logger;
				BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(58, 2, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("abilities: could not inspect ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(text);
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(", using the base flags only: ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(ex.Message);
				}
				logger.LogWarning(val);
			}
			if (list.Count > 0)
			{
				List<string> list3 = new List<string>();
				foreach (var item4 in list)
				{
					MemberInfo item3 = item4.Item1;
					list3.Add(item3.Name);
				}
				Plugin.Logger.LogInfo((object)($"abilities: {text} redeclares {string.Join(", ", list3)}; " + "setting them on the object's own class"));
			}
			else
			{
				Plugin.Logger.LogInfo((object)("abilities: " + text + " -> base flags only" + ((type == null) ? " (no wrapper type found)" : "")));
			}
			if (list2.Count > 0)
			{
				List<string> list4 = new List<string>();
				foreach (PropertyInfo item5 in list2)
				{
					list4.Add(item5.Name);
				}
				ManualLogSource logger2 = Plugin.Logger;
				BepInExInfoLogInterpolatedStringHandler val2 = new BepInExInfoLogInterpolatedStringHandler(42, 2, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("abilities: ");
					((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>(text);
					((BepInExLogInterpolatedStringHandler)val2).AppendLiteral(" holds its own LevelObject(s): ");
					((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>(string.Join(", ", list4));
				}
				logger2.LogInfo(val2);
			}
			(Type, List<(MemberInfo, bool)>, PropertyInfo[]) tuple2 = (type, list, list2.ToArray());
			_shadowed[text] = tuple2;
			return tuple2;
		}

		private static int ApplyWanted(Dictionary<int, ObjectLock> votes, Dictionary<int, LevelObject> byId)
		{
			int num = 0;
			bool value2 = default(bool);
			foreach (KeyValuePair<int, ObjectLock> vote in votes)
			{
				if (!byId.TryGetValue(vote.Key, out LevelObject value) || (Object)(object)value == (Object)null)
				{
					continue;
				}
				bool flag = !vote.Value.Unlocked;
				bool flag2 = !flag && vote.Value.DrawerSetLocked && Slides(value);
				if (flag2)
				{
					flag = true;
				}
				if (flag && vote.Value.IsDrawerSetPart && !_flagged.Contains(vote.Key) && GameHoldsStill(value))
				{
					continue;
				}
				try
				{
					if (flag)
					{
						if (_flagged.Add(vote.Key))
						{
							_gameInteractable[vote.Key] = value.m_interactable;
						}
						else if (value.m_interactable)
						{
							_gameInteractable[vote.Key] = true;
						}
						value.SetInteractable(false);
						value.SetPreventSelection(true);
						SetFlagsOnOwnClass(value, isLocked: true);
					}
					else if (_flagged.Remove(vote.Key))
					{
						bool interactable = value.m_interactable || !_gameInteractable.TryGetValue(vote.Key, out value2) || value2;
						_gameInteractable.Remove(vote.Key);
						value.SetInteractable(interactable);
						value.SetPreventSelection(false);
						SetFlagsOnOwnClass(value, isLocked: false);
						FreeSavedState(vote.Key, value);
					}
					Freeze(value, flag, vote.Value.IsCover || flag2, vote.Value.HeldByDrawerSet);
					Tint(value, flag);
					if (!flag && !_releasing)
					{
						ReplayRefusedDrawer(vote.Key, value);
					}
					num++;
				}
				catch
				{
				}
			}
			return num;
		}

		private static bool GameHoldsStill(LevelObject obj)
		{
			try
			{
				Drawer val = ((Il2CppObjectBase)obj).TryCast<Drawer>();
				if ((Object)(object)val == (Object)null)
				{
					return false;
				}
				float num = Travel(val);
				bool flag = !(num > 0.05f) && (!val.IsTray || obj.PreventSelection || !obj.Interactable);
				GameObject gameObject = ((Component)obj).gameObject;
				string value = ((gameObject != null) ? ((Object)gameObject).name : null) ?? "?";
				if (_drawersSaid.Add($"{value}|{flag}"))
				{
					Plugin.Logger.LogInfo((object)($"abilities: drawer '{value}' travel {num:0.00} (sliding={val.IsSlidingDrawer} tray={val.IsTray} fixedBox={val.IsFixedBox})" + (flag ? " - cannot be moved at all; left alone and not greyed" : " - locked")));
				}
				return flag;
			}
			catch
			{
				return false;
			}
		}

		private static float Travel(Drawer drawer)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			Transform fullyOpenPosition = drawer.FullyOpenPosition;
			Transform fullyClosedPosition = drawer.FullyClosedPosition;
			if (!((Object)(object)fullyOpenPosition == (Object)null) && !((Object)(object)fullyClosedPosition == (Object)null))
			{
				return Vector3.Distance(fullyOpenPosition.position, fullyClosedPosition.position);
			}
			return 0f;
		}

		private static bool Slides(LevelObject obj)
		{
			try
			{
				Drawer val = ((Il2CppObjectBase)obj).TryCast<Drawer>();
				if ((Object)(object)val == (Object)null || Travel(val) <= 0.05f)
				{
					return false;
				}
				GameObject gameObject = ((Component)obj).gameObject;
				string text = ((gameObject != null) ? ((Object)gameObject).name : null) ?? "?";
				if (_drawersSaid.Add(text + "|follows"))
				{
					Plugin.Logger.LogInfo((object)("abilities: drawer '" + text + "' slides - it follows its drawer lock although another group holds it"));
				}
				return true;
			}
			catch
			{
				return false;
			}
		}

		private static string ClassOf(ObjectController controller)
		{
			int instanceID = ((Object)controller).GetInstanceID();
			if (_classes.TryGetValue(instanceID, out string value))
			{
				return value;
			}
			Type il2CppType = ((Object)controller).GetIl2CppType();
			string text = ((il2CppType != null) ? ((MemberInfo)il2CppType).Name : null) ?? "";
			if (_classes.Count > 512)
			{
				_classes.Clear();
			}
			_classes[instanceID] = text;
			return text;
		}

		private static void Tint(LevelObject obj, bool isLocked)
		{
			Paint(obj.renderer, isLocked);
			List<SpriteRenderer> subrenderers = obj.subrenderers;
			int num = subrenderers?.Count ?? 0;
			for (int i = 0; i < num; i++)
			{
				Paint(subrenderers[i], isLocked);
			}
			if ((Object)(object)obj.renderer == (Object)null && num == 0)
			{
				PaintScrubPicture(obj, isLocked);
			}
			Paint(((Component)obj).GetComponent<SpriteRenderer>(), isLocked);
			PaintArtUnder(((Component)obj).transform, isLocked);
		}

		private static void PaintArtUnder(Transform t, bool isLocked)
		{
			for (int i = 0; i < t.childCount; i++)
			{
				Transform child = t.GetChild(i);
				if (!((Object)(object)child == (Object)null) && !((Object)(object)((Component)child).GetComponent<LevelObject>() != (Object)null) && !((Object)((Component)child).gameObject).name.Contains("Shadow"))
				{
					SpriteRenderer component = ((Component)child).GetComponent<SpriteRenderer>();
					if ((Object)(object)component != (Object)null && (!isLocked || ((Renderer)component).enabled) && (isLocked || !_heldArt.Contains(((Object)component).GetInstanceID())))
					{
						Paint(component, isLocked);
					}
					PaintArtUnder(child, isLocked);
				}
			}
		}

		private static void PaintScrubPicture(LevelObject obj, bool isLocked)
		{
			AnimScrubObject val = ((Il2CppObjectBase)obj).TryCast<AnimScrubObject>();
			Animator val2 = (((Object)(object)val == (Object)null) ? null : val.animationToScrub);
			if (!((Object)(object)val2 == (Object)null))
			{
				Paint(((Component)val2).GetComponent<SpriteRenderer>(), isLocked);
			}
		}

		private static void Paint(SpriteRenderer? renderer, bool isLocked)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)renderer == (Object)null)
			{
				return;
			}
			int instanceID = ((Object)renderer).GetInstanceID();
			Color color = renderer.color;
			if (!isLocked)
			{
				if (_tinted.Remove(instanceID) && _original.TryGetValue(instanceID, out var value) && OurGrey(color))
				{
					renderer.color = value;
				}
				_original.Remove(instanceID);
				_fadingIn.Remove(instanceID);
				return;
			}
			if (!_tinted.Contains(instanceID) || !OurGrey(color))
			{
				if (color.a < 0.05f)
				{
					_tinted.Remove(instanceID);
					_original.Remove(instanceID);
					_fadingIn.Add(instanceID);
					return;
				}
				if (!_original.ContainsKey(instanceID))
				{
					_original[instanceID] = (Color)(_fadingIn.Remove(instanceID) ? new Color(color.r, color.g, color.b, 1f) : color);
				}
			}
			_tinted.Add(instanceID);
			if (!(renderer.color == Locked))
			{
				renderer.color = Locked;
			}
		}

		private static bool OurGrey(Color c)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			if (Math.Abs(c.r - Locked.r) < 0.01f && Math.Abs(c.g - Locked.g) < 0.01f)
			{
				return Math.Abs(c.b - Locked.b) < 0.01f;
			}
			return false;
		}
	}
	internal static class Backgrounds
	{
		private sealed class LevelColours
		{
			internal LevelInterface Face;

			internal Color Own;

			internal Color LevelOwn;

			internal Color Written;
		}

		private static Color[]? _palette;

		private static string? _chosenFor;

		private static int _chosenCount = -1;

		private static Color? _chosen;

		private const float MinContrast = 0.34f;

		private static readonly Dictionary<IntPtr, LevelColours> _levelOwn = new Dictionary<IntPtr, LevelColours>();

		private static readonly Dictionary<IntPtr, (Image Image, Color Own)> _menuOwn = new Dictionary<IntPtr, (Image, Color)>();

		private static int _writes;

		private static float _writesReportedAt;

		internal static int EffectiveTraps => BackgroundResets.EffectiveTraps(Inventory.BackgroundTraps, RunState.BackgroundResetAt);

		internal static int ResetsAvailable => BackgroundResets.Available(Inventory.BackgroundResetsHeld, RunState.BackgroundResetsUsed);

		private static Color[] Palette()
		{
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Expected O, but got Unknown
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Expected O, but got Unknown
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			if (_palette != null)
			{
				return _palette;
			}
			bool flag = default(bool);
			try
			{
				foreach (Object item in (Il2CppArrayBase<Object>)(object)Object.FindObjectsOfTypeAll(Il2CppType.Of<ColorSchemesData>()))
				{
					ColorSchemesData val = ((item == (Object)null) ? null : ((Il2CppObjectBase)item).TryCast<ColorSchemesData>());
					if ((Object)(object)val == (Object)null)
					{
						continue;
					}
					Il2CppReferenceArray<LevelColorScheme> levelColorSchemes = val.levelColorSchemes;
					if (levelColorSchemes == null || ((Il2CppArrayBase<LevelColorScheme>)(object)levelColorSchemes).Length == 0)
					{
						continue;
					}
					Color[] array = (Color[])(object)new Color[((Il2CppArrayBase<LevelColorScheme>)(object)levelColorSchemes).Length];
					for (int i = 0; i < ((Il2CppArrayBase<LevelColorScheme>)(object)levelColorSchemes).Length; i++)
					{
						LevelColorScheme val2 = ((Il2CppArrayBase<LevelColorScheme>)(object)levelColorSchemes)[i];
						if (val2 != null)
						{
							array[i] = val2.backgroundColor;
						}
					}
					_palette = array;
					ManualLogSource logger = Plugin.Logger;
					BepInExInfoLogInterpolatedStringHandler val3 = new BepInExInfoLogInterpolatedStringHandler(32, 1, ref flag);
					if (flag)
					{
						((BepInExLogInterpolatedStringHandler)val3).AppendLiteral("backgrounds: palette of ");
						((BepInExLogInterpolatedStringHandler)val3).AppendFormatted<int>(array.Length);
						((BepInExLogInterpolatedStringHandler)val3).AppendLiteral(" colours");
					}
					logger.LogInfo(val3);
					return _palette;
				}
			}
			catch (Exception ex)
			{
				ManualLogSource logger2 = Plugin.Logger;
				BepInExWarningLogInterpolatedStringHandler val4 = new BepInExWarningLogInterpolatedStringHandler(41, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val4).AppendLiteral("backgrounds: could not read the palette: ");
					((BepInExLogInterpolatedStringHandler)val4).AppendFormatted<string>(ex.Message);
				}
				logger2.LogWarning(val4);
			}
			_palette = Array.Empty<Color>();
			return _palette;
		}

		private static Color? ColourFor(int count)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			if (count <= 0)
			{
				return null;
			}
			Color[] array = Palette();
			if (array.Length == 0)
			{
				return null;
			}
			return array[(count - 1) % array.Length];
		}

		private static float Distance(Color a, Color b)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			float num = a.r - b.r;
			float num2 = a.g - b.g;
			float num3 = a.b - b.b;
			return Mathf.Sqrt(2f * num * num + 4f * num2 * num2 + 3f * num3 * num3);
		}

		private static List<Color> PieceColours(LevelInterface li)
		{
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			List<Color> list = new List<Color>();
			try
			{
				Level level = li.Level;
				List<ObjectController> val = ((level != null) ? level.objectControllers : null);
				if (val == null)
				{
					return list;
				}
				for (int i = 0; i < val.Count; i++)
				{
					if (list.Count >= 200)
					{
						break;
					}
					ObjectController val2 = val[i];
					GameObject val3 = (((Object)(object)val2 == (Object)null) ? null : ((Component)val2).gameObject);
					if ((Object)(object)val3 == (Object)null)
					{
						continue;
					}
					foreach (SpriteRenderer componentsInChild in val3.GetComponentsInChildren<SpriteRenderer>(false))
					{
						if (!((Object)(object)componentsInChild == (Object)null))
						{
							list.Add(componentsInChild.color);
							if (list.Count >= 200)
							{
								break;
							}
						}
					}
				}
			}
			catch
			{
			}
			return list;
		}

		private static Color Legible(Color wanted, LevelInterface li, int count)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			Color[] array = Palette();
			if (array.Length == 0)
			{
				return wanted;
			}
			List<Color> list = PieceColours(li);
			if (list.Count == 0)
			{
				return wanted;
			}
			for (int i = 0; i < array.Length; i++)
			{
				Color val = array[(count - 1 + i) % array.Length];
				float num = float.MaxValue;
				foreach (Color item in list)
				{
					if (!(item.a < 0.2f))
					{
						float num2 = Distance(val, item);
						if (num2 < num)
						{
							num = num2;
						}
					}
				}
				if (num >= 0.34f)
				{
					if (i > 0)
					{
						Plugin.Logger.LogInfo((object)($"backgrounds: skipped {i} palette colour(s) the pieces " + "would have vanished into"));
					}
					return val;
				}
			}
			Plugin.Logger.LogWarning((object)"backgrounds: no palette colour clears this level's pieces, keeping the first");
			return wanted;
		}

		internal static Color? ForLevel()
		{
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			int effectiveTraps = EffectiveTraps;
			Color? result = ColourFor(effectiveTraps);
			if (!result.HasValue)
			{
				return null;
			}
			GameManager instance = GameManager.Instance;
			object obj;
			if (instance == null)
			{
				obj = null;
			}
			else
			{
				LevelManager levelManager = instance.levelManager;
				obj = ((levelManager != null) ? levelManager.ActiveLevelInterface : null);
			}
			LevelInterface val = (LevelInterface)obj;
			if ((Object)(object)val == (Object)null)
			{
				return result;
			}
			string levelId = val.LevelId;
			if (_chosen.HasValue && _chosenCount == effectiveTraps && _chosenFor == levelId)
			{
				return _chosen;
			}
			_chosenFor = levelId;
			_chosenCount = effectiveTraps;
			_chosen = Legible(result.Value, val, effectiveTraps);
			return _chosen;
		}

		internal static Color? ForMenu()
		{
			return ColourFor(EffectiveTraps);
		}

		internal static void RememberMenuImage(Image image)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)image == (Object)null) && !_menuOwn.ContainsKey(((Il2CppObjectBase)image).Pointer))
			{
				_menuOwn[((Il2CppObjectBase)image).Pointer] = (image, ((Graphic)image).color);
			}
		}

		internal static void RestoreOwnColours()
		{
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0144: Unknown result type (might be due to invalid IL or missing references)
			foreach (LevelColours value in _levelOwn.Values)
			{
				try
				{
					LevelInterface face = value.Face;
					if (!((Object)(object)face == (Object)null))
					{
						if (face.BackgroundColor == value.Written)
						{
							face.BackgroundColor = value.Own;
						}
						Level level = face.Level;
						if ((Object)(object)level != (Object)null && level.backgroundColor == value.Written)
						{
							level.backgroundColor = value.LevelOwn;
						}
					}
				}
				catch
				{
				}
			}
			_levelOwn.Clear();
			foreach (var (val, color) in _menuOwn.Values)
			{
				try
				{
					if ((Object)(object)val != (Object)null)
					{
						((Graphic)val).color = color;
					}
				}
				catch
				{
				}
			}
			_menuOwn.Clear();
			try
			{
				GameManager instance = GameManager.Instance;
				object obj3;
				if (instance == null)
				{
					obj3 = null;
				}
				else
				{
					LevelManager levelManager = instance.levelManager;
					obj3 = ((levelManager != null) ? levelManager.ActiveLevelInterface : null);
				}
				LevelInterface val2 = (LevelInterface)obj3;
				Camera main = Camera.main;
				if ((Object)(object)val2 != (Object)null && (Object)(object)main != (Object)null)
				{
					main.backgroundColor = val2.ActiveBackgroundColor;
				}
			}
			catch
			{
			}
			_chosen = null;
			_chosenFor = null;
			_chosenCount = -1;
			Track.RepaintSections();
		}

		internal static void ApplyToLevel()
		{
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0146: Expected O, but got Unknown
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if (!Track.Active)
				{
					return;
				}
				Color? val = ForLevel();
				if (!val.HasValue)
				{
					return;
				}
				GameManager instance = GameManager.Instance;
				object obj;
				if (instance == null)
				{
					obj = null;
				}
				else
				{
					LevelManager levelManager = instance.levelManager;
					obj = ((levelManager != null) ? levelManager.ActiveLevelInterface : null);
				}
				LevelInterface val2 = (LevelInterface)obj;
				if ((Object)(object)val2 == (Object)null)
				{
					return;
				}
				Level level = val2.Level;
				if (!_levelOwn.TryGetValue(((Il2CppObjectBase)val2).Pointer, out LevelColours value))
				{
					value = new LevelColours
					{
						Face = val2,
						Own = val2.BackgroundColor,
						LevelOwn = (((Object)(object)level != (Object)null) ? level.backgroundColor : val2.BackgroundColor)
					};
					_levelOwn[((Il2CppObjectBase)val2).Pointer] = value;
				}
				else
				{
					if (val2.BackgroundColor != value.Written)
					{
						value.Own = val2.BackgroundColor;
					}
					if ((Object)(object)level != (Object)null && level.backgroundColor != value.Written)
					{
						value.LevelOwn = level.backgroundColor;
					}
				}
				value.Written = val.Value;
				val2.BackgroundColor = val.Value;
				Level level2 = val2.Level;
				if ((Object)(object)level2 != (Object)null)
				{
					level2.backgroundColor = val.Value;
				}
			}
			catch (Exception ex)
			{
				ManualLogSource logger = Plugin.Logger;
				bool flag = default(bool);
				BepInExWarningLogInterpolatedStringHandler val3 = new BepInExWarningLogInterpolatedStringHandler(36, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val3).AppendLiteral("backgrounds: level recolour failed: ");
					((BepInExLogInterpolatedStringHandler)val3).AppendFormatted<string>(ex.Message);
				}
				logger.LogWarning(val3);
			}
		}

		internal static void Tick()
		{
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if (!Track.Active)
				{
					return;
				}
				GameManager instance = GameManager.Instance;
				object obj;
				if (instance == null)
				{
					obj = null;
				}
				else
				{
					LevelManager levelManager = instance.levelManager;
					obj = ((levelManager != null) ? levelManager.ActiveLevelInterface : null);
				}
				LevelInterface val = (LevelInterface)obj;
				if (((Object)(object)val != (Object)null && (val.IsTransitioning || !val.LevelIsLoaded)) || ((Object)(object)val != (Object)null && val.IsCredits))
				{
					return;
				}
				Color? val2 = ForLevel();
				if (val2.HasValue)
				{
					Camera main = Camera.main;
					if (!((Object)(object)main == (Object)null) && !(main.backgroundColor == val2.Value))
					{
						main.backgroundColor = val2.Value;
						CountWrite();
					}
				}
			}
			catch
			{
			}
		}

		private static void CountWrite()
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Expected O, but got Unknown
			_writes++;
			float unscaledTime = Time.unscaledTime;
			if (!(unscaledTime - _writesReportedAt < 1f))
			{
				_writesReportedAt = unscaledTime;
				ManualLogSource logger = Plugin.Logger;
				bool flag = default(bool);
				BepInExInfoLogInterpolatedStringHandler val = new BepInExInfoLogInterpolatedStringHandler(42, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("backgrounds: repainted the camera ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<int>(_writes);
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" time(s)");
				}
				logger.LogInfo(val);
				_writes = 0;
			}
		}
	}
	internal static class Badges
	{
		private static float _sincePills;

		private static RectTransform? _pills;

		private static readonly List<string> _pillOrder = new List<string>();

		private static readonly List<RectTransform> _pillTiles = new List<RectTransform>();

		private static readonly Color PillHeld = new Color(0.25f, 0.7f, 0.3f, 0.85f);

		private static readonly Color PillLocked = new Color(0.16f, 0.16f, 0.19f, 0.75f);

		private static readonly Color IconLocked = new Color(0.42f, 0.42f, 0.46f, 0.55f);

		private static readonly Dictionary<string, string> PillText = new Dictionary<string, string>(StringComparer.Ordinal)
		{
			["Swapping"] = "SWP",
			["Stacking"] = "STK",
			["Ordering"] = "ORD",
			["Gadgets"] = "GAD",
			["Rotating"] = "ROT",
			["Grids"] = "GRD",
			["Tidying"] = "TDY",
			["Containers"] = "CON",
			["Drawer"] = "DRW",
			["Sticking"] = "STI",
			["Symmetry"] = "SYM",
			["Jigsaw"] = "JIG",
			["Distributing"] = "DST"
		};

		private static readonly Dictionary<string, string> PillSprite = new Dictionary<string, string>(StringComparer.Ordinal)
		{
			["Swapping"] = "Books",
			["Stacking"] = "Cartridges",
			["Ordering"] = "Pencils",
			["Gadgets"] = "Lightbulb",
			["Rotating"] = "Record",
			["Grids"] = "GridTile",
			["Tidying"] = "Breadtag",
			["Containers"] = "EggCarton",
			["Drawer"] = "Drawer",
			["Sticking"] = "Stickers",
			["Symmetry"] = "Wreath",
			["Jigsaw"] = "Gingerbread",
			["Distributing"] = "Pizza"
		};

		private static readonly Dictionary<string, Sprite> _pillArt = new Dictionary<string, Sprite>(StringComparer.Ordinal);

		private static bool _pillArtLoaded;

		private const float PillWidth = 58f;

		private const float PillHeight = 72f;

		private const float PillIcon = 54f;

		private const float PillGap = 4f;

		private const float PillRowGap = 10f;

		private const int PillsPerRow = 6;

		private const float LabelHeight = 15f;

		private const string BadgeName = "ApTrackerBadge";

		private const string NameLabel = "ApCardName";

		private const float BadgeSize = 30f;

		private static float _sinceRefresh;

		private static readonly Dictionary<int, SlotStatus> _shown = new Dictionary<int, SlotStatus>();

		private static readonly HashSet<string> _repeated = new HashSet<string>(StringComparer.Ordinal);

		private static bool _repeatedBuilt;

		private static Sprite? _diagonal;

		private static Texture2D? _diagonalTexture;

		private static float _sinceSubtitle;

		private static TextMeshProUGUI? _subtitle;

		private static float _sinceTag;

		private static TextMeshProUGUI? _tag;

		private static readonly Color Green = new Color(0.25f, 0.7f, 0.3f);

		private static readonly Color Red = new Color(0.85f, 0.2f, 0.2f);

		private static readonly Color FallbackStar = new Color(0.98f, 0.8f, 0.25f);

		private static float _sinceCounter;

		private static TextMeshProUGUI? _counter;

		private static Image? _counterStar;

		private static float _sinceDots;

		private static bool _dotsReported;

		private const string DotName = "ApDotState";

		private static Transform? _fittedStrip;

		private static Vector3 _fittedBase = Vector3.one;

		private static Vector2 _fittedPosition;

		private static float _fittedBarWidth;

		private static float _appliedBarWidth = -1f;

		private const float DotAllowance = 64f;

		private const float MinStripScale = 0.55f;

		private static string? _fitReported;

		private static float _sinceWhy;

		private static void LoadPillArt()
		{
			//IL_0199: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a0: Expected O, but got Unknown
			//IL_0150: Unknown result type (might be due to invalid IL or missing references)
			//IL_0157: Expected O, but got Unknown
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Expected O, but got Unknown
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			if (_pillArtLoaded)
			{
				return;
			}
			_pillArtLoaded = true;
			bool flag = default(bool);
			try
			{
				Assembly executingAssembly = Assembly.GetExecutingAssembly();
				string[] manifestResourceNames = executingAssembly.GetManifestResourceNames();
				foreach (string text in manifestResourceNames)
				{
					if (!text.EndsWith(".png", StringComparison.OrdinalIgnoreCase))
					{
						continue;
					}
					using Stream stream = executingAssembly.GetManifestResourceStream(text);
					if (stream == null)
					{
						continue;
					}
					using MemoryStream memoryStream = new MemoryStream();
					stream.CopyTo(memoryStream);
					byte[] array = memoryStream.ToArray();
					if (array.Length == 0)
					{
						continue;
					}
					Texture2D val = new Texture2D(2, 2, (TextureFormat)4, false);
					if (ImageConversion.LoadImage(val, Il2CppStructArray<byte>.op_Implicit(array)))
					{
						((Texture)val).wrapMode = (TextureWrapMode)1;
						((Texture)val).filterMode = (FilterMode)1;
						Sprite value = Sprite.Create(val, new Rect(0f, 0f, (float)((Texture)val).width, (float)((Texture)val).height), new Vector2(0.5f, 0.5f));
						string text2 = text;
						int num = text2.LastIndexOf('.', text2.Length - 5);
						if (num >= 0)
						{
							text2 = text2.Substring(num + 1);
						}
						text2 = text2.Substring(0, text2.Length - 4);
						_pillArt[text2] = value;
					}
				}
				ManualLogSource logger = Plugin.Logger;
				BepInExInfoLogInterpolatedStringHandler val2 = new BepInExInfoLogInterpolatedStringHandler(31, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("badges: loaded ");
					((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<int>(_pillArt.Count);
					((BepInExLogInterpolatedStringHandler)val2).AppendLiteral(" ability icon(s)");
				}
				logger.LogInfo(val2);
			}
			catch (Exception ex)
			{
				ManualLogSource logger2 = Plugin.Logger;
				BepInExWarningLogInterpolatedStringHandler val3 = new BepInExWarningLogInterpolatedStringHandler(34, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val3).AppendLiteral("badges: could not load the icons: ");
					((BepInExLogInterpolatedStringHandler)val3).AppendFormatted<string>(ex.Message);
				}
				logger2.LogWarning(val3);
			}
		}

		private static Vector2 FitIcon(string ability)
		{
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			if (PillSprite.TryGetValue(ability, out string value) && _pillArt.TryGetValue(value, out Sprite value2) && (Object)(object)value2 != (Object)null)
			{
				Rect rect = value2.rect;
				float width = ((Rect)(ref rect)).width;
				rect = value2.rect;
				float height = ((Rect)(ref rect)).height;
				if (width > 0f && height > 0f)
				{
					if (!(width >= height))
					{
						return new Vector2(54f * width / height, 54f);
					}
					return new Vector2(54f, 54f * height / width);
				}
			}
			return new Vector2(54f, 54f);
		}

		internal static void TickAbilityPills()
		{
			//IL_0154: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0209: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a0: Unknown result type (might be due to invalid IL or missing references)
			_sincePills += Time.unscaledDeltaTime;
			if (_sincePills < 0.5f)
			{
				return;
			}
			_sincePills = 0f;
			LevelsTrack val = (Track.Active ? Track.CampaignTrack() : null);
			bool num = (Object)(object)val != (Object)null && ((Component)val).gameObject.activeInHierarchy;
			AbilityState abilities = Inventory.Abilities;
			if (!num || abilities == null || !abilities.LocksEnabled)
			{
				if ((Object)(object)_pills != (Object)null)
				{
					((Component)_pills).gameObject.SetActive(false);
				}
				return;
			}
			LoadPillArt();
			if ((Object)(object)_pills == (Object)null && !BuildPills())
			{
				return;
			}
			((Component)_pills).gameObject.SetActive(true);
			for (int i = 0; i < _pillOrder.Count && i < _pillTiles.Count; i++)
			{
				RectTransform val2 = _pillTiles[i];
				if ((Object)(object)val2 == (Object)null)
				{
					continue;
				}
				bool flag = abilities.Has(_pillOrder[i]);
				Transform obj = ((Transform)val2).Find("Icon");
				Image val3 = ((obj != null) ? ((Component)obj).GetComponent<Image>() : null);
				if ((Object)(object)val3 != (Object)null)
				{
					if ((Object)(object)val3.sprite == (Object)null && PillSprite.TryGetValue(_pillOrder[i], out string value) && _pillArt.TryGetValue(value, out Sprite value2))
					{
						val3.sprite = value2;
						((Behaviour)val3).enabled = true;
					}
					((Graphic)val3).color = (flag ? Color.white : IconLocked);
				}
				Image component = ((Component)val2).GetComponent<Image>();
				if ((Object)(object)component != (Object)null)
				{
					((Behaviour)component).enabled = (Object)(object)val3 == (Object)null || (Object)(object)val3.sprite == (Object)null;
					if (((Behaviour)component).enabled)
					{
						((Graphic)component).color = (flag ? PillHeld : PillLocked);
					}
				}
				Transform obj2 = ((Transform)val2).Find("Text");
				TextMeshProUGUI val4 = ((obj2 != null) ? ((Component)obj2).GetComponent<TextMeshProUGUI>() : null);
				if ((Object)(object)val4 != (Object)null)
				{
					((Graphic)val4).color = (flag ? new Color(1f, 1f, 1f, 0.95f) : new Color(1f, 1f, 1f, 0.3f));
				}
			}
		}

		private static bool BuildPills()
		{
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0165: Unknown result type (might be due to invalid IL or missing references)
			//IL_018d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0192: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0206: Unknown result type (might be due to invalid IL or missing references)
			//IL_021c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0232: Unknown result type (might be due to invalid IL or missing references)
			//IL_0241: Unknown result type (might be due to invalid IL or missing references)
			//IL_0246: Unknown result type (might be due to invalid IL or missing references)
			//IL_0254: Unknown result type (might be due to invalid IL or missing references)
			//IL_0265: Unknown result type (might be due to invalid IL or missing references)
			//IL_027a: Unknown result type (might be due to invalid IL or missing references)
			//IL_028f: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_030a: Unknown result type (might be due to invalid IL or missing references)
			//IL_031f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0334: Unknown result type (might be due to invalid IL or missing references)
			//IL_033f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0353: Unknown result type (might be due to invalid IL or missing references)
			//IL_03fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0404: Expected O, but got Unknown
			Transform overlayRoot = Toasts.OverlayRoot;
			SlotData seed = Plugin.Seed;
			if ((Object)(object)overlayRoot == (Object)null || seed == null)
			{
				return false;
			}
			_pillOrder.Clear();
			_pillTiles.Clear();
			foreach (string item in Abilities.StripOrder)
			{
				if (seed.Abilities.Count <= 0 || seed.Abilities.ContainsKey(item))
				{
					_pillOrder.Add(item);
				}
			}
			if (_pillOrder.Count == 0)
			{
				return false;
			}
			GameObject val = new GameObject("ApAbilityStrip");
			val.transform.SetParent(overlayRoot, false);
			_pills = val.AddComponent<RectTransform>();
			_pills.anchorMin = new Vector2(0f, 1f);
			_pills.anchorMax = new Vector2(0f, 1f);
			_pills.pivot = new Vector2(0f, 1f);
			int num = (_pillOrder.Count + 6 - 1) / 6;
			float num2 = (float)Math.Min(_pillOrder.Count, 6) * 62f;
			float num3 = 438.5f - num2 * 0.5f;
			_pills.anchoredPosition = new Vector2(Mathf.Max(187f, num3), -18f);
			_pills.sizeDelta = new Vector2(num2, (float)num * 82f);
			for (int i = 0; i < _pillOrder.Count; i++)
			{
				GameObject val2 = new GameObject("ApPill_" + _pillOrder[i]);
				val2.transform.SetParent((Transform)(object)_pills, false);
				RectTransform val3 = val2.AddComponent<RectTransform>();
				val3.anchorMin = new Vector2(0f, 1f);
				val3.anchorMax = new Vector2(0f, 1f);
				val3.pivot = new Vector2(0f, 1f);
				val3.anchoredPosition = new Vector2((float)(i % 6) * 62f, (float)(-(i / 6)) * 82f);
				val3.sizeDelta = new Vector2(58f, 72f);
				Image obj = val2.AddComponent<Image>();
				((Graphic)obj).raycastTarget = false;
				((Graphic)obj).color = PillLocked;
				GameObject val4 = new GameObject("Icon");
				val4.transform.SetParent((Transform)(object)val3, false);
				RectTransform obj2 = val4.AddComponent<RectTransform>();
				obj2.anchorMin = new Vector2(0.5f, 0f);
				obj2.anchorMax = new Vector2(0.5f, 0f);
				obj2.pivot = new Vector2(0.5f, 0f);
				obj2.anchoredPosition = new Vector2(0f, 17f);
				obj2.sizeDelta = FitIcon(_pillOrder[i]);
				Image obj3 = val4.AddComponent<Image>();
				((Graphic)obj3).raycastTarget = false;
				((Graphic)obj3).color = IconLocked;
				((Behaviour)obj3).enabled = false;
				GameObject val5 = new GameObject("Text");
				val5.transform.SetParent((Transform)(object)val3, false);
				RectTransform obj4 = val5.AddComponent<RectTransform>();
				obj4.anchorMin = new Vector2(0f, 0f);
				obj4.anchorMax = new Vector2(1f, 0f);
				obj4.pivot = new Vector2(0.5f, 0f);
				obj4.anchoredPosition = Vector2.zero;
				obj4.sizeDelta = new Vector2(0f, 15f);
				_pillTiles.Add(val3);
				TextMeshProUGUI obj5 = val5.AddComponent<TextMeshProUGUI>();
				((TMP_Text)obj5).text = (PillText.TryGetValue(_pillOrder[i], out string value) ? value : _pillOrder[i].Substring(0, Math.Min(3, _pillOrder[i].Length)).ToUpperInvariant());
				((TMP_Text)obj5).alignment = (TextAlignmentOptions)514;
				((TMP_Text)obj5).fontSize = 12f;
				((Graphic)obj5).raycastTarget = false;
			}
			ManualLogSource logger = Plugin.Logger;
			bool flag = default(bool);
			BepInExInfoLogInterpolatedStringHandler val6 = new BepInExInfoLogInterpolatedStringHandler(41, 1, ref flag);
			if (flag)
			{
				((BepInExLogInterpolatedStringHandler)val6).AppendLiteral("badges: ability strip built with ");
				((BepInExLogInterpolatedStringHandler)val6).AppendFormatted<int>(_pillOrder.Count);
				((BepInExLogInterpolatedStringHandler)val6).AppendLiteral(" pill(s)");
			}
			logger.LogInfo(val6);
			return true;
		}

		internal static void Tick(float dt)
		{
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Expected O, but got Unknown
			if (!Track.Active)
			{
				return;
			}
			_sinceRefresh += dt;
			if (_sinceRefresh < 1f)
			{
				return;
			}
			_sinceRefresh = 0f;
			try
			{
				Refresh();
			}
			catch (Exception ex)
			{
				ManualLogSource logger = Plugin.Logger;
				bool flag = default(bool);
				BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(24, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("badges: refresh failed: ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(ex.Message);
				}
				logger.LogWarning(val);
			}
		}

		private static void Refresh()
		{
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			SlotProgress progress = Checks.Progress;
			AbilityState abilities = Inventory.Abilities;
			TrackState state = Track.State;
			if (progress == null || abilities == null || state == null)
			{
				return;
			}
			LevelsTrack val = Track.CampaignTrack();
			List<LevelIcon> val2 = (((Object)(object)val == (Object)null) ? null : val.trackItems);
			if (val2 == null || !((Component)val).gameObject.activeInHierarchy)
			{
				return;
			}
			for (int i = 0; i < val2.Count; i++)
			{
				LevelIcon val3 = val2[i];
				if ((Object)(object)val3 == (Object)null)
				{
					continue;
				}
				int num = Track.SlotAt(i);
				if (num < 0)
				{
					Remove(val3, "ApTrackerBadge");
					Remove(val3, "ApCardName");
					RenumberDivider(val3, Track.PackNumberAt(i));
					continue;
				}
				SlotStatus val4 = progress.StatusOf(num, (Func<string, bool>)Checks.Ledger.IsCollected, state.PacksHeld, abilities);
				CardStars.Apply(val3, i);
				if (!_shown.TryGetValue(num, out var value) || value != val4 || !((Object)(object)((Component)val3).transform.Find("ApTrackerBadge") != (Object)null))
				{
					SetBadge(val3, val4);
					SetName(val3, num);
					_shown[num] = val4;
				}
			}
			SectionStars.Apply(Track.CampaignSelect());
		}

		private static void RenumberDivider(LevelIcon icon, int pack)
		{
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Expected O, but got Unknown
			if (pack <= 0)
			{
				return;
			}
			try
			{
				string text = pack.ToString(CultureInfo.InvariantCulture);
				foreach (TextMeshProUGUI componentsInChild in ((Component)icon).GetComponentsInChildren<TextMeshProUGUI>(true))
				{
					if ((Object)(object)componentsInChild == (Object)null)
					{
						continue;
					}
					string text2 = ((TMP_Text)componentsInChild).text;
					if (!string.IsNullOrWhiteSpace(text2) && !(text2 == text))
					{
						string text3 = text2.Trim();
						if (text3.Length <= 2 && int.TryParse(text3, NumberStyles.Integer, CultureInfo.InvariantCulture, out var _))
						{
							((TMP_Text)componentsInChild).text = text;
						}
					}
				}
			}
			catch (Exception ex)
			{
				ManualLogSource logger = Plugin.Logger;
				bool flag = default(bool);
				BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(38, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("badges: could not renumber a divider: ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(ex.Message);
				}
				logger.LogWarning(val);
			}
		}

		private static void SetBadge(LevelIcon icon, SlotStatus state)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Expected O, but got Unknown
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Expected I4, but got Unknown
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			Remove(icon, "ApTrackerBadge");
			GameObject val = new GameObject("ApTrackerBadge");
			val.transform.SetParent(((Component)icon).transform, false);
			RectTransform obj = val.AddComponent<RectTransform>();
			obj.anchorMin = new Vector2(1f, 1f);
			obj.anchorMax = new Vector2(1f, 1f);
			obj.pivot = new Vector2(1f, 1f);
			obj.anchoredPosition = new Vector2(-6f, -6f);
			obj.sizeDelta = new Vector2(30f, 30f);
			switch ((int)state)
			{
			case 0:
				AddFill(val, Green, 0f, 1f);
				break;
			case 2:
				AddFill(val, Red, 0f, 1f);
				break;
			case 1:
				AddDiagonal(val);
				break;
			case 3:
				AddFill(val, Red, 0f, 1f);
				break;
			case 4:
				AddStar(val, icon);
				break;
			}
			val.transform.SetAsLastSibling();
		}

		private static void AddDiagonal(GameObject parent)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: 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)
			GameObject val = new GameObject("Diagonal");
			val.transform.SetParent(parent.transform, false);
			RectTransform obj = val.AddComponent<RectTransform>();
			obj.anchorMin = Vector2.zero;
			obj.anchorMax = Vector2.one;
			obj.offsetMin = Vector2.zero;
			obj.offsetMax = Vector2.zero;
			Image obj2 = val.AddComponent<Image>();
			obj2.sprite = DiagonalSprite();
			((Graphic)obj2).color = Color.white;
			((Graphic)obj2).raycastTarget = false;
		}

		private static Sprite DiagonalSprite()
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Expected O, but got Unknown
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_diagonal != (Object)null)
			{
				return _diagonal;
			}
			Texture2D val = new Texture2D(64, 64, (TextureFormat)4, false)
			{
				filterMode = (FilterMode)1,
				wrapMode = (TextureWrapMode)1
			};
			for (int i = 0; i < 64; i++)
			{
				for (int j = 0; j < 64; j++)
				{
					float num = Mathf.Clamp01((float)(i - j) / 1.5f + 0.5f);
					val.SetPixel(j, i, Color.Lerp(Red, Green, num));
				}
			}
			val.Apply();
			_diagonalTexture = val;
			_diagonal = Sprite.Create(val, new Rect(0f, 0f, 64f, 64f), new Vector2(0.5f, 0.5f));
			return _diagonal;
		}

		private static void AddFill(GameObject parent, Color colour, float from, float to)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("Fill");
			val.transform.SetParent(parent.transform, false);
			RectTransform obj = val.AddComponent<RectTransform>();
			obj.anchorMin = new Vector2(from, 0f);
			obj.anchorMax = new Vector2(to, 1f);
			obj.offsetMin = Vector2.zero;
			obj.offsetMax = Vector2.zero;
			Image obj2 = val.AddComponent<Image>();
			((Graphic)obj2).color = colour;
			((Graphic)obj2).raycastTarget = false;
		}

		private static void AddStar(GameObject parent, LevelIcon icon)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("Star");
			val.transform.SetParent(parent.transform, false);
			RectTransform obj = val.AddComponent<RectTransform>();
			obj.anchorMin = Vector2.zero;
			obj.anchorMax = Vector2.one;
			obj.offsetMin = Vector2.zero;
			obj.offsetMax = Vector2.zero;
			Image val2 = val.AddComponent<Image>();
			((Graphic)val2).raycastTarget = false;
			var (val3, color) = FindStar(icon);
			if ((Object)(object)val3 != (Object)null)
			{
				val2.sprite = val3;
				val2.preserveAspect = true;
				((Graphic)val2).color = color;
			}
			else
			{
				((Graphic)val2).color = color;
			}
		}

		private static (Sprite?, Color) FindStar(LevelIcon icon)
		{
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			Sprite val = null;
			foreach (Image componentsInChild in ((Component)icon).GetComponentsInChildren<Image>(true))
			{
				Sprite sprite = (((Object)(object)componentsInChild == (Object)null) ? null : componentsInChild.sprite);
				if ((Object)(object)sprite == (Object)null)
				{
					continue;
				}
				string te