using System;
using System.Buffers.Binary;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Diagnostics.Tracing;
using System.Globalization;
using System.IO;
using System.IO.Compression;
using System.Linq;
using System.Numerics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security.Cryptography;
using System.Text;
using System.Text.Json;
using System.Text.Json.Nodes;
using System.Text.Json.Serialization;
using System.Text.RegularExpressions;
using System.Threading;
using System.Threading.Tasks;
using Actors.Enemies;
using Assets.Scripts.Actors;
using Assets.Scripts.Actors.Enemies;
using Assets.Scripts.Actors.Player;
using Assets.Scripts.Audio.Music;
using Assets.Scripts.Game.Combat;
using Assets.Scripts.Game.MapGeneration;
using Assets.Scripts.Game.Other;
using Assets.Scripts.Inventory__Items__Pickups;
using Assets.Scripts.Inventory__Items__Pickups.Chests;
using Assets.Scripts.Inventory__Items__Pickups.Items;
using Assets.Scripts.Inventory__Items__Pickups.Items.ItemImplementations;
using Assets.Scripts.Inventory__Items__Pickups.Stats;
using Assets.Scripts.Inventory__Items__Pickups.Weapons;
using Assets.Scripts.Managers;
using Assets.Scripts.MapGeneration.ProceduralTiles;
using Assets.Scripts.Menu.Shop;
using Assets.Scripts.Saves___Serialization.Progression.Achievements;
using Assets.Scripts.Saves___Serialization.SaveFiles.Configs;
using Assets.Scripts.Settings___Saves.SaveFiles;
using Assets.Scripts.Settings___Saves.SaveFiles.ConfigSaves;
using Assets.Scripts.Steam;
using Assets.Scripts.UI.Debug;
using Assets.Scripts.UI.InGame.Levelup;
using Assets.Scripts.UI.InGame.Rewards;
using Assets.Scripts.Utility;
using Assets.Scripts._Data.MapsAndStages;
using BepInEx;
using BepInEx.Logging;
using BepInEx.Unity.IL2CPP;
using BepInEx.Unity.IL2CPP.Utils.Collections;
using HarmonyLib;
using Il2CppInterop.Runtime;
using Il2CppInterop.Runtime.Attributes;
using Il2CppInterop.Runtime.Injection;
using Il2CppInterop.Runtime.InteropTypes;
using Il2CppInterop.Runtime.InteropTypes.Arrays;
using Il2CppSystem;
using Il2CppSystem.Collections.Generic;
using Il2CppSystem.Reflection;
using NLayer;
using Rewired;
using Steamworks;
using TMPro;
using Unity.AI.Navigation;
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.Events;
using UnityEngine.Rendering;
using UnityEngine.SceneManagement;
using UnityEngine.UI;
using Utility;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: AssemblyCompany("MegabonkLevels.Mod")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("0.1.0.0")]
[assembly: AssemblyInformationalVersion("0.1.0+0ebefc8288bdf46075af01840000a6780e450789")]
[assembly: AssemblyProduct("MegabonkLevels.Mod")]
[assembly: AssemblyTitle("MegabonkLevels.Mod")]
[assembly: AssemblyVersion("0.1.0.0")]
namespace MegabonkLevels;

public enum ActorKind
{
	Enemy,
	Elite,
	Miniboss,
	StageBoss,
	FinalBoss
}
public static class ActorKinds
{
	private const int Elite = 1;

	private const int Boss = 2;

	private const int StageBoss = 4;

	private const int SummonerMiniboss = 16;

	private const int FinalBoss = 32;

	public static ActorKind Of(int enemyFlags)
	{
		if ((enemyFlags & 0x20) != 0)
		{
			return ActorKind.FinalBoss;
		}
		if ((enemyFlags & 4) != 0)
		{
			return ActorKind.StageBoss;
		}
		if ((enemyFlags & 0x12) != 0)
		{
			return ActorKind.Miniboss;
		}
		if ((enemyFlags & 1) != 0)
		{
			return ActorKind.Elite;
		}
		return ActorKind.Enemy;
	}

	public static string Label(ActorKind kind)
	{
		return kind switch
		{
			ActorKind.FinalBoss => "final boss:", 
			ActorKind.StageBoss => "boss:", 
			ActorKind.Miniboss => "miniboss:", 
			ActorKind.Elite => "elite:", 
			_ => "enemy:", 
		};
	}

	public static bool IsBossTier(ActorKind kind)
	{
		if ((uint)(kind - 2) <= 2u)
		{
			return true;
		}
		return false;
	}
}
public static class AssetDump
{
	private sealed class Walk
	{
		public HashSet<object> Path { get; } = new HashSet<object>();

		public int MaxItems { get; }

		public int MaxNodes { get; }

		public int Nodes { get; set; }

		public int Level { get; set; }

		public Walk(int maxItems, int maxNodes)
		{
			MaxItems = maxItems;
			MaxNodes = maxNodes;
		}
	}

	public const int MaxDepth = 6;

	public const int DefaultMaxItems = 64;

	public const int DefaultMaxNodes = 20000;

	private const int MaxLevel = 24;

	private const BindingFlags Members = BindingFlags.Instance | BindingFlags.Public;

	public static JsonNode Describe(object value, int depth, int maxItems = 64, int maxNodes = 20000)
	{
		return Describe(value, Math.Min(depth, 6), new Walk(Math.Max(1, maxItems), Math.Max(1, maxNodes)));
	}

	private static JsonNode Describe(object value, int depth, Walk walk)
	{
		if (value == null)
		{
			return null;
		}
		if (IsPrimitive(value, out var primitive))
		{
			return primitive;
		}
		if (walk.Nodes >= walk.MaxNodes || walk.Level >= 24)
		{
			return new JsonObject { ["$truncated"] = true };
		}
		walk.Nodes++;
		if (walk.Path.Contains(value))
		{
			return new JsonObject
			{
				["$type"] = value.GetType().Name,
				["name"] = ReadName(value),
				["$cycle"] = true
			};
		}
		if (value is IEnumerable sequence)
		{
			return DescribeSequence(sequence, depth, walk);
		}
		if (depth <= 0)
		{
			return JsonValue.Create(SafeText(value));
		}
		Type type = value.GetType();
		bool flag = Inherits(type, "UnityEngine.Object") && !Inherits(type, "UnityEngine.ScriptableObject");
		walk.Path.Add(value);
		walk.Level++;
		JsonObject jsonObject = new JsonObject { ["$type"] = type.Name };
		if (flag)
		{
			jsonObject["name"] = JsonValue.Create(ReadName(value));
		}
		foreach (KeyValuePair<string, Func<object, object>> item in MembersOf(type, flag))
		{
			jsonObject[item.Key] = DescribeMember(item, value, depth - 1, walk);
		}
		walk.Level--;
		walk.Path.Remove(value);
		if (flag)
		{
			jsonObject["$fieldsOnly"] = true;
		}
		return jsonObject;
	}

	private static bool Inherits(Type type, string fullName)
	{
		Type baseType = type.BaseType;
		while (baseType != null)
		{
			if (baseType.FullName == fullName)
			{
				return true;
			}
			baseType = baseType.BaseType;
		}
		return false;
	}

	private static JsonNode DescribeSequence(IEnumerable sequence, int depth, Walk walk)
	{
		walk.Path.Add(sequence);
		walk.Level++;
		JsonArray jsonArray = new JsonArray();
		int num = 0;
		foreach (object item in sequence)
		{
			num++;
			if (jsonArray.Count < walk.MaxItems)
			{
				jsonArray.Add(Describe(item, depth, walk));
			}
		}
		walk.Level--;
		walk.Path.Remove(sequence);
		if (num <= walk.MaxItems)
		{
			return jsonArray;
		}
		return new JsonObject
		{
			["count"] = JsonValue.Create((long)num, (JsonNodeOptions?)null),
			["truncated"] = true,
			["items"] = jsonArray
		};
	}

	private static JsonNode DescribeMember(KeyValuePair<string, Func<object, object>> member, object owner, int depth, Walk walk)
	{
		object value;
		try
		{
			value = member.Value(owner);
		}
		catch (Exception ex)
		{
			Exception ex2 = ((ex is TargetInvocationException { InnerException: not null } ex3) ? ex3.InnerException : ex);
			return JsonValue.Create("$error: " + ex2.GetType().Name + ": " + ex2.Message);
		}
		return Describe(value, depth, walk);
	}

	private static IEnumerable<KeyValuePair<string, Func<object, object>>> MembersOf(Type type, bool fieldsOnly)
	{
		FieldInfo[] fields = type.GetFields(BindingFlags.Instance | BindingFlags.Public);
		foreach (FieldInfo field in fields)
		{
			yield return new KeyValuePair<string, Func<object, object>>(field.Name, (object instance) => field.GetValue(instance));
		}
		if (fieldsOnly)
		{
			yield break;
		}
		PropertyInfo[] properties = type.GetProperties(BindingFlags.Instance | BindingFlags.Public);
		foreach (PropertyInfo property in properties)
		{
			if (property.GetIndexParameters().Length == 0 && !(property.GetMethod == null))
			{
				yield return new KeyValuePair<string, Func<object, object>>(property.Name, (object instance) => property.GetValue(instance));
			}
		}
	}

	private static bool IsPrimitive(object value, out JsonNode primitive)
	{
		JsonValue jsonValue = ((value is string value2) ? JsonValue.Create(value2) : ((value is bool value3) ? JsonValue.Create(value3) : ((value is Enum value4) ? JsonValue.Create(Convert.ToInt64(value4)) : ((!(value is sbyte) && !(value is byte) && !(value is short) && !(value is ushort) && !(value is int) && !(value is uint) && !(value is long)) ? ((value is ulong value5) ? JsonValue.Create(value5) : ((value is float value6) ? JsonValue.Create(value6) : ((!(value is double) && !(value is decimal)) ? ((!(value is char c)) ? null : JsonValue.Create(c.ToString())) : JsonValue.Create(Convert.ToDouble(value))))) : JsonValue.Create(Convert.ToInt64(value))))));
		primitive = jsonValue;
		bool flag = primitive != null;
		if (!flag)
		{
			bool flag2 = ((value is string || value is bool) ? true : false);
			flag = flag2;
		}
		return flag;
	}

	private static string ReadName(object value)
	{
		try
		{
			return (value.GetType().GetProperty("name", BindingFlags.Instance | BindingFlags.Public)?.GetValue(value) as string) ?? (value.GetType().GetField("name", BindingFlags.Instance | BindingFlags.Public)?.GetValue(value) as string);
		}
		catch (Exception ex)
		{
			return "$error: " + ex.GetType().Name + ": " + ex.Message;
		}
	}

	private static string SafeText(object value)
	{
		try
		{
			return value.ToString() ?? value.GetType().Name;
		}
		catch (Exception ex)
		{
			return "$error: " + ex.GetType().Name + ": " + ex.Message;
		}
	}
}
public static class BlankLevel
{
	public const int DefaultSize = 7;

	public const int MinimumSize = 3;

	private const float SpawnBodyY = 2f;

	private const float BossSpawnerRotationY = 270f;

	public static LevelFile Create(EMap map, int stageIndex, int tier, int size, float spacing, string gameBuildId)
	{
		if (size < 3)
		{
			throw new ArgumentException($"A from-scratch grid must be at least {3} by {3}, got {size}.", "size");
		}
		List<AuthoredCell> list = new List<AuthoredCell>(size * size);
		for (int i = 0; i < size; i++)
		{
			for (int j = 0; j < size; j++)
			{
				list.Add(new AuthoredCell(i, j, 0));
			}
		}
		int num = size / 2;
		int cellX = Math.Min(num + 2, size - 1);
		(float X, float Z) tuple = PositionReadout.CellCentre(num, num, size, size, spacing);
		float item = tuple.X;
		float item2 = tuple.Z;
		(float X, float Z) tuple2 = PositionReadout.CellCentre(cellX, num, size, size, spacing);
		float item3 = tuple2.X;
		float item4 = tuple2.Z;
		Dictionary<string, string> packs = new Dictionary<string, string>();
		EditOp[] edits = Array.Empty<EditOp>();
		LevelGrid? grid = new LevelGrid(size, size, list);
		SpawnPoint? spawn = new SpawnPoint(new float[3] { item, 2f, item2 }, new float[3]);
		SpawnPoint? bossSpawner = new SpawnPoint(new float[3] { item3, 0f, item4 }, new float[3] { 0f, 270f, 0f });
		return new LevelFile(4, gameBuildId, map, stageIndex, tier, 0, packs, edits, NoGrass: false, null, null, null, null, null, null, null, null, null, GrindRequiresSlide: false, null, null, RandomizeShadyGuy: false, RandomizeChests: false, RandomizeMoai: false, 0, null, null, null, null, null, null, null, null, null, null, null, null, "none", grid, spawn, bossSpawner);
	}
}
public static class BossEventLog
{
	public static string Format(string eventName)
	{
		return "BossEvents: " + eventName;
	}

	public static string Format<T>(string eventName, T value)
	{
		return $"BossEvents: {eventName} {value}";
	}
}
public static class BossEventPatch
{
	public static void Install(ModLogger logger)
	{
		InteractableBossSpawner.A_BossSpawned += Action.op_Implicit((Action)delegate
		{
			logger.Msg(BossEventLog.Format("A_BossSpawned"));
		});
		InteractableBossSpawner.A_BossDefeated += Action<bool>.op_Implicit((Action<bool>)delegate(bool flag)
		{
			logger.Msg(BossEventLog.Format("A_BossDefeated", flag));
		});
		InteractableBossSpawner.A_NumBossesDefeated += Action<int>.op_Implicit((Action<int>)delegate(int count)
		{
			logger.Msg(BossEventLog.Format("A_NumBossesDefeated", count));
		});
		GraveyardBossRoom.A_BossDied += Action.op_Implicit((Action)delegate
		{
			logger.Msg(BossEventLog.Format("A_BossDied"));
		});
		EnemyManager.A_StageBossDied += Action.op_Implicit((Action)delegate
		{
			logger.Msg(BossEventLog.Format("A_StageBossDied"));
		});
	}
}
public enum BossPoolKind
{
	None,
	Boss,
	Miniboss
}
public static class BossPools
{
	private const int BossBit = 2;

	private const int StageBossBit = 4;

	private const int SummonerMinibossBit = 16;

	private const int FinalBossBit = 32;

	public const int MaxEntries = 64;

	public static BossPoolKind Classify(int flags)
	{
		if ((flags & 0x24) == 0)
		{
			if ((flags & 0x12) == 0)
			{
				return BossPoolKind.None;
			}
			return BossPoolKind.Miniboss;
		}
		return BossPoolKind.Boss;
	}

	public static string Pick(IReadOnlyList<string> pool, Random random, ISet<string> used = null)
	{
		List<string> list = pool?.Where((string name) => used == null || !used.Contains(name)).ToList();
		if (list == null || list.Count <= 0)
		{
			return null;
		}
		string text = list[random.Next(list.Count)];
		used?.Add(text);
		return text;
	}

	public static void Validate(IReadOnlyList<string> pool, string field)
	{
		if (pool == null || (pool.Count <= 64 && !pool.Any(string.IsNullOrWhiteSpace)))
		{
			return;
		}
		throw new ArgumentException($"{field} lists up to {64} enemy names, none blank.");
	}
}
public static class BossPoolPatch
{
	[HarmonyPatch(typeof(EnemyManager), "SpawnBoss")]
	private static class SpawnBossDrawsFromThePool
	{
		private static void Prefix(ref EEnemy eEnemy, EEnemyFlag enemyFlag)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Expected I4, but got Unknown
			//IL_0144: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: Unknown result type (might be due to invalid IL or missing references)
			//IL_016c: Unknown result type (might be due to invalid IL or missing references)
			//IL_016f: Expected I4, but got Unknown
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			if (!CustomLevelState.IsActive)
			{
				return;
			}
			LevelFile currentSettings = LiveEditPatch.CurrentSettings;
			BossPoolKind bossPoolKind = BossPools.Classify((int)enemyFlag);
			IReadOnlyList<string> readOnlyList = bossPoolKind switch
			{
				BossPoolKind.Boss => currentSettings.BossPool, 
				BossPoolKind.Miniboss => currentSettings.MinibossPool, 
				_ => null, 
			};
			string text = LiveEditPatch.RunRandom.PickBoss(readOnlyList);
			EEnemy result;
			if (text == null)
			{
				if (readOnlyList != null && readOnlyList.Count > 0)
				{
					_logger?.Msg($"BossPool: {bossPoolKind} pool exhausted; keeping {eEnemy} (flags {enemyFlag})");
				}
			}
			else if (!Enum.TryParse<EEnemy>(text, ignoreCase: true, out result))
			{
				if (s_unknown.Add(text))
				{
					_logger?.Warning("BossPool: unknown enemy '" + text + "' ignored");
				}
			}
			else
			{
				_logger?.Msg($"BossPool: {bossPoolKind} spawn of {eEnemy} (flags {enemyFlag}) replaced by {result}");
				eEnemy = (EEnemy)(int)result;
			}
		}
	}

	private static ModLogger _logger;

	private static readonly HashSet<string> s_unknown = new HashSet<string>();

	public static void Install(ModLogger logger)
	{
		_logger = logger;
	}
}
public readonly record struct Vec3(float X, float Y, float Z);
public static class BossSpawnRedirect
{
	public const int ArmWindowFrames = 2;

	public const float MinDistanceFromSpawner = 35f;

	public const float MaxDistanceFromSpawner = 68f;

	public const float MinSpacingBetweenCopies = 20f;

	public const float KillFloorMargin = 5f;

	public const float BoxFloorBelowSpawner = 2f;

	public const float BoxRoofAboveSpawner = 10f;

	public static bool ShouldArm(bool customLevelActive, bool fromScratch, bool redirectRequested)
	{
		if (customLevelActive)
		{
			return !fromScratch || redirectRequested;
		}
		return false;
	}

	public static bool IsInsideBossBox(Vec3 pos, Vec3 spawner)
	{
		if (XzDistance(pos, spawner) < 35f && pos.Y >= spawner.Y - 2f)
		{
			return pos.Y <= spawner.Y + 10f;
		}
		return false;
	}

	public static int ExpectedMoves(int bossCurses)
	{
		return Math.Max(1, 1 + bossCurses);
	}

	public static bool ShouldConsume(int? armedFrame, int frame, int windowFrames = 2)
	{
		if (armedFrame.HasValue && frame >= armedFrame.Value)
		{
			return frame <= armedFrame.Value + windowFrames;
		}
		return false;
	}

	public static bool ShouldExpire(int? armedFrame, int expectedMoves, int moveCount, int frame, int windowFrames = 2)
	{
		if (armedFrame.HasValue)
		{
			if (moveCount < expectedMoves)
			{
				return frame > armedFrame.Value + windowFrames;
			}
			return true;
		}
		return false;
	}

	public static List<Vec3> CandidateRing(Vec3 spawner, int seed, int count)
	{
		Random random = new Random(seed);
		List<Vec3> list = new List<Vec3>(count);
		for (int i = 0; i < count; i++)
		{
			float x = (float)(random.NextDouble() * 2.0 * Math.PI);
			float num = 35f + (float)(random.NextDouble() * 33.0);
			list.Add(new Vec3(spawner.X + MathF.Cos(x) * num, spawner.Y, spawner.Z + MathF.Sin(x) * num));
		}
		return list;
	}

	public static bool SpotUsable(Vec3 floorPoint, Vec3 spawner, float killFloorY, IReadOnlyList<Vec3> taken)
	{
		if (XzDistance(floorPoint, spawner) < 35f)
		{
			return false;
		}
		if (floorPoint.Y < killFloorY + 5f)
		{
			return false;
		}
		foreach (Vec3 item in taken)
		{
			if (XzDistance(floorPoint, item) < 20f)
			{
				return false;
			}
		}
		return true;
	}

	public static bool PickSpot(IReadOnlyList<Vec3> usable, IReadOnlyList<Vec3> taken, out Vec3 spot)
	{
		return Maximin.Pick(usable, taken, XzDistance, out spot);
	}

	public static Vec3 FloorPlacement(Vec3 floorPoint, Vec3 requestedPosition, Vec3 actualPosition)
	{
		return new Vec3(floorPoint.X, floorPoint.Y + actualPosition.Y - requestedPosition.Y, floorPoint.Z);
	}

	public static float XzDistance(Vec3 a, Vec3 b)
	{
		float num = a.X - b.X;
		float num2 = a.Z - b.Z;
		return MathF.Sqrt(num * num + num2 * num2);
	}
}
public static class BossSpawnRedirectPatch
{
	[HarmonyPatch(typeof(InteractableBossSpawner), "Interact")]
	private static class InteractArmsTheRedirect
	{
		private static void Prefix(InteractableBossSpawner __instance)
		{
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			if (BossSpawnRedirect.ShouldArm(CustomLevelState.IsActive, FromScratchGenerationPatch.ActiveLevel.HasValue, FromScratchGenerationPatch.ActiveLevel?.BossRedirect ?? false) && !((Object)(object)__instance == (Object)null))
			{
				_expectedMoves = BossSpawnRedirect.ExpectedMoves(((Object)(object)GameManager.Instance != (Object)null) ? GameManager.Instance.bossCurses : 0);
				_moveCount = 0;
				_taken.Clear();
				_movedBosses.Clear();
				Vector3 position = ((Component)__instance).transform.position;
				_spawner = new Vec3(position.x, position.y, position.z);
				_seed = Environment.TickCount;
				_armedFrame = Time.frameCount;
				_logger?.Msg($"BossSpawnRedirect: armed at spawner ({position.x:0.###}, {position.y:0.###}, {position.z:0.###}), expecting {_expectedMoves} boss(es) at frame {Time.frameCount}.");
			}
		}
	}

	[HarmonyPatch(typeof(EnemyManager), "SpawnBoss")]
	private static class SpawnBossMovesTheBoss
	{
		private static void Postfix(Enemy __result, Vector3 pos)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			MoveIfArmed(__result, pos, "SpawnBoss");
		}
	}

	[HarmonyPatch(typeof(EnemyManager), "SpawnEnemy", new Type[]
	{
		typeof(EnemyData),
		typeof(Vector3),
		typeof(int),
		typeof(bool),
		typeof(EEnemyFlag),
		typeof(bool),
		typeof(float)
	})]
	private static class SpawnEnemyMovesTheBoss
	{
		private static void Postfix(Enemy __result, Vector3 pos)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			MoveIfArmed(__result, pos, "SpawnEnemy");
		}
	}

	private const int CandidatesPerBoss = 48;

	private const int SeedPerCopy = 7919;

	private static ModLogger _logger;

	private static int? _armedFrame;

	private static int _expectedMoves;

	private static int _moveCount;

	private static Vec3 _spawner;

	private static int _seed;

	private static readonly List<Vec3> _taken = new List<Vec3>();

	private static readonly HashSet<IntPtr> _movedBosses = new HashSet<IntPtr>();

	public static void Install(ModLogger logger)
	{
		_logger = logger;
	}

	public static void Disarm()
	{
		_armedFrame = null;
		_expectedMoves = 0;
		_moveCount = 0;
		_taken.Clear();
		_movedBosses.Clear();
	}

	private static void MoveIfArmed(Enemy boss, Vector3 requested, string via)
	{
		//IL_000d: Unknown result type (might be due to invalid IL or missing references)
		//IL_013e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0143: Unknown result type (might be due to invalid IL or missing references)
		//IL_0145: Unknown result type (might be due to invalid IL or missing references)
		//IL_014b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0151: Unknown result type (might be due to invalid IL or missing references)
		//IL_015c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0162: Unknown result type (might be due to invalid IL or missing references)
		//IL_0168: Unknown result type (might be due to invalid IL or missing references)
		//IL_0194: Unknown result type (might be due to invalid IL or missing references)
		//IL_01b2: Unknown result type (might be due to invalid IL or missing references)
		//IL_022a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0248: Unknown result type (might be due to invalid IL or missing references)
		//IL_0266: Unknown result type (might be due to invalid IL or missing references)
		if (!_armedFrame.HasValue)
		{
			MoveMinibossOutOfTheBox(boss, requested, via);
			return;
		}
		int frameCount = Time.frameCount;
		if (BossSpawnRedirect.ShouldExpire(_armedFrame, _expectedMoves, _moveCount, frameCount))
		{
			if (_moveCount < _expectedMoves)
			{
				_logger?.Msg($"BossSpawnRedirect: window expired at frame {frameCount} after {_moveCount}/{_expectedMoves} moves.");
			}
			_armedFrame = null;
		}
		else
		{
			if (!BossSpawnRedirect.ShouldConsume(_armedFrame, frameCount) || (Object)(object)boss == (Object)null || !boss.IsBoss() || !_movedBosses.Add(((Il2CppObjectBase)boss).Pointer))
			{
				return;
			}
			if (!TryFindSpot(boss, _spawner, _seed + _moveCount * 7919, _taken, out var floorPoint))
			{
				_logger?.Msg("BossSpawnRedirect: no usable interior spot for the boss spawned via " + via + ", left alone.");
				return;
			}
			Vector3 position = ((Component)boss).transform.position;
			Vec3 vec = BossSpawnRedirect.FloorPlacement(floorPoint, new Vec3(requested.x, requested.y, requested.z), new Vec3(position.x, position.y, position.z));
			((Component)boss).transform.position = new Vector3(vec.X, vec.Y, vec.Z);
			if ((Object)(object)boss.rb != (Object)null)
			{
				boss.rb.velocity = Vector3.zero;
			}
			_taken.Add(floorPoint);
			_moveCount++;
			_logger?.Msg($"BossSpawnRedirect: boss {_moveCount}/{_expectedMoves} moved from ({position.x:0.###}, {position.y:0.###}, {position.z:0.###}) to ({vec.X:0.###}, {vec.Y:0.###}, {vec.Z:0.###}) via {via}.");
			if (BossSpawnRedirect.ShouldExpire(_armedFrame, _expectedMoves, _moveCount, frameCount))
			{
				_armedFrame = null;
			}
		}
	}

	private static void MoveMinibossOutOfTheBox(Enemy boss, Vector3 requested, string via)
	{
		//IL_0065: Unknown result type (might be due to invalid IL or missing references)
		//IL_006a: Unknown result type (might be due to invalid IL or missing references)
		//IL_006d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0073: Unknown result type (might be due to invalid IL or missing references)
		//IL_0079: Unknown result type (might be due to invalid IL or missing references)
		//IL_008a: Unknown result type (might be due to invalid IL or missing references)
		//IL_008f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0090: Unknown result type (might be due to invalid IL or missing references)
		//IL_0096: Unknown result type (might be due to invalid IL or missing references)
		//IL_009c: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
		//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
		//IL_0104: Unknown result type (might be due to invalid IL or missing references)
		//IL_010a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0137: Unknown result type (might be due to invalid IL or missing references)
		//IL_0155: Unknown result type (might be due to invalid IL or missing references)
		//IL_0197: Unknown result type (might be due to invalid IL or missing references)
		//IL_01b4: Unknown result type (might be due to invalid IL or missing references)
		//IL_01d2: Unknown result type (might be due to invalid IL or missing references)
		//IL_01f0: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)boss == (Object)null || !boss.IsBoss() || !BossSpawnRedirect.ShouldArm(CustomLevelState.IsActive, FromScratchGenerationPatch.ActiveLevel.HasValue, FromScratchGenerationPatch.ActiveLevel?.BossRedirect ?? false))
		{
			return;
		}
		InteractableBossSpawner val = Object.FindObjectOfType<InteractableBossSpawner>();
		if ((Object)(object)val == (Object)null)
		{
			return;
		}
		Vector3 position = ((Component)val).transform.position;
		Vec3 spawner = new Vec3(position.x, position.y, position.z);
		Vector3 position2 = ((Component)boss).transform.position;
		if (!BossSpawnRedirect.IsInsideBossBox(new Vec3(position2.x, position2.y, position2.z), spawner))
		{
			return;
		}
		if (!TryFindSpot(boss, spawner, Environment.TickCount, Array.Empty<Vec3>(), out var floorPoint))
		{
			_logger?.Msg("BossSpawnRedirect: no usable interior spot for the miniboss spawned via " + via + ", left alone.");
			return;
		}
		Vec3 vec = BossSpawnRedirect.FloorPlacement(floorPoint, new Vec3(requested.x, requested.y, requested.z), new Vec3(position2.x, position2.y, position2.z));
		((Component)boss).transform.position = new Vector3(vec.X, vec.Y, vec.Z);
		if ((Object)(object)boss.rb != (Object)null)
		{
			boss.rb.velocity = Vector3.zero;
		}
		ModLogger logger = _logger;
		if (logger != null)
		{
			DefaultInterpolatedStringHandler defaultInterpolatedStringHandler = new DefaultInterpolatedStringHandler(62, 8);
			defaultInterpolatedStringHandler.AppendLiteral("BossSpawnRedirect: miniboss ");
			EnemyData enemyData = boss.enemyData;
			defaultInterpolatedStringHandler.AppendFormatted((enemyData != null) ? new EEnemy?(enemyData.enemyName) : ((EEnemy?)null));
			defaultInterpolatedStringHandler.AppendLiteral(" moved from (");
			defaultInterpolatedStringHandler.AppendFormatted(position2.x, "0.###");
			defaultInterpolatedStringHandler.AppendLiteral(", ");
			defaultInterpolatedStringHandler.AppendFormatted(position2.y, "0.###");
			defaultInterpolatedStringHandler.AppendLiteral(", ");
			defaultInterpolatedStringHandler.AppendFormatted(position2.z, "0.###");
			defaultInterpolatedStringHandler.AppendLiteral(") to ");
			defaultInterpolatedStringHandler.AppendLiteral("(");
			defaultInterpolatedStringHandler.AppendFormatted(vec.X, "0.###");
			defaultInterpolatedStringHandler.AppendLiteral(", ");
			defaultInterpolatedStringHandler.AppendFormatted(vec.Y, "0.###");
			defaultInterpolatedStringHandler.AppendLiteral(", ");
			defaultInterpolatedStringHandler.AppendFormatted(vec.Z, "0.###");
			defaultInterpolatedStringHandler.AppendLiteral(") via ");
			defaultInterpolatedStringHandler.AppendFormatted(via);
			defaultInterpolatedStringHandler.AppendLiteral(".");
			logger.Msg(defaultInterpolatedStringHandler.ToStringAndClear());
		}
	}

	private static bool TryFindSpot(Enemy boss, Vec3 spawner, int seed, IReadOnlyList<Vec3> taken, out Vec3 floorPoint)
	{
		//IL_0099: Unknown result type (might be due to invalid IL or missing references)
		//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
		floorPoint = default(Vec3);
		float num = LiveEditPatch.KillFloorY ?? float.MinValue;
		float top = spawner.Y + 20f;
		List<Vec3> list = new List<Vec3>();
		foreach (Vec3 item in BossSpawnRedirect.CandidateRing(spawner, seed, 48))
		{
			if (BossSpawnRedirect.SpotUsable(item, spawner, num, taken) && PlacementProbe.HighestFloor(item.X, item.Z, top, (num == float.MinValue) ? (-100f) : (num - 5f), ((Component)boss).transform, out var floor))
			{
				Vec3 vec = new Vec3(item.X, floor.y, item.Z);
				if (BossSpawnRedirect.SpotUsable(vec, spawner, num, taken) && PlacementProbe.ClearPoint(new Vector3(vec.X, vec.Y, vec.Z)))
				{
					list.Add(vec);
				}
			}
		}
		return BossSpawnRedirect.PickSpot(list, taken, out floorPoint);
	}
}
public static class CameraOverride
{
	private static CameraPose? _pose;

	private static bool _hasSaved;

	private static Vector3 _savedLocalPosition;

	private static Quaternion _savedLocalRotation;

	public static void Set(CameraPose pose)
	{
		_pose = pose;
	}

	public static void Clear()
	{
		//IL_003a: Unknown result type (might be due to invalid IL or missing references)
		//IL_004a: Unknown result type (might be due to invalid IL or missing references)
		_pose = null;
		if (_hasSaved)
		{
			_hasSaved = false;
			PlayerCamera instance = PlayerCamera.Instance;
			Camera val = ((instance != null) ? instance.camera : null);
			if ((Object)(object)val != (Object)null)
			{
				((Component)val).transform.localPosition = _savedLocalPosition;
				((Component)val).transform.localRotation = _savedLocalRotation;
			}
		}
	}

	public static void Apply()
	{
		//IL_0076: 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_0045: Unknown result type (might be due to invalid IL or missing references)
		//IL_004a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0050: Unknown result type (might be due to invalid IL or missing references)
		//IL_0055: Unknown result type (might be due to invalid IL or missing references)
		CameraPose? pose = _pose;
		if (!pose.HasValue)
		{
			return;
		}
		CameraPose valueOrDefault = pose.GetValueOrDefault();
		PlayerCamera instance = PlayerCamera.Instance;
		Camera val = ((instance != null) ? instance.camera : null);
		if (!((Object)(object)val == (Object)null))
		{
			Transform transform = ((Component)val).transform;
			if (!_hasSaved)
			{
				_savedLocalPosition = transform.localPosition;
				_savedLocalRotation = transform.localRotation;
				_hasSaved = true;
			}
			transform.position = new Vector3(valueOrDefault.X, valueOrDefault.Y, valueOrDefault.Z);
			transform.rotation = Quaternion.Euler(valueOrDefault.Rx, valueOrDefault.Ry, valueOrDefault.Rz);
		}
	}
}
public enum CatalogNamespace
{
	GameAsset,
	Bundle
}
public readonly record struct CatalogId(CatalogNamespace ns, IReadOnlyList<string> segments)
{
	private static readonly Regex SegmentPattern = new Regex("^[A-Za-z0-9_-]+$", RegexOptions.Compiled);

	private const string BundlePrefix = "bundle:";

	public static CatalogId Parse(string raw)
	{
		if (!TryParse(raw, out var id, out var error))
		{
			throw new ArgumentException(error, "raw");
		}
		return id;
	}

	public static bool TryParse(string raw, out CatalogId id, out string error)
	{
		id = default(CatalogId);
		if (string.IsNullOrWhiteSpace(raw))
		{
			error = "catalogId must not be empty or whitespace.";
			return false;
		}
		CatalogNamespace ns;
		string text;
		if (raw.StartsWith("bundle:", StringComparison.Ordinal))
		{
			ns = CatalogNamespace.Bundle;
			text = raw.Substring("bundle:".Length);
		}
		else
		{
			if (raw.Contains(':'))
			{
				error = "catalogId '" + raw + "' has an unknown namespace prefix; only 'bundle:' is recognized.";
				return false;
			}
			ns = CatalogNamespace.GameAsset;
			text = raw;
		}
		string[] array = text.Split('/');
		string[] array2 = array;
		foreach (string text2 in array2)
		{
			if (text2.Length == 0)
			{
				error = "catalogId '" + raw + "' contains an empty segment (check for leading/trailing or doubled '/').";
				return false;
			}
			if (!SegmentPattern.IsMatch(text2))
			{
				error = $"catalogId '{raw}' has invalid character(s) in segment '{text2}'; only letters, digits, '_', and '-' are allowed.";
				return false;
			}
		}
		if (array.Length < 2)
		{
			error = $"catalogId '{raw}' has too few segments; must have at least 2, got {array.Length}.";
			return false;
		}
		id = new CatalogId(ns, array);
		error = null;
		return true;
	}

	public string Serialize()
	{
		return Namespace switch
		{
			CatalogNamespace.Bundle => "bundle:" + string.Join("/", Segments), 
			CatalogNamespace.GameAsset => string.Join("/", Segments), 
			_ => throw new ArgumentException($"Unknown {"CatalogNamespace"}: {Namespace}"), 
		};
	}

	public bool Equals(CatalogId other)
	{
		if (Namespace == other.Namespace)
		{
			if (Segments != null && other.Segments != null)
			{
				return Segments.SequenceEqual(other.Segments);
			}
			return Segments == other.Segments;
		}
		return false;
	}

	public override int GetHashCode()
	{
		HashCode hashCode = default(HashCode);
		hashCode.Add(Namespace);
		if (Segments != null)
		{
			foreach (string segment in Segments)
			{
				hashCode.Add(segment);
			}
		}
		return hashCode.ToHashCode();
	}
}
public static class CatalogPrefabs
{
	private static MapData _lastMap;

	public static MapData TryFindMap(EMap map)
	{
		//IL_0012: Unknown result type (might be due to invalid IL or missing references)
		//IL_0018: Invalid comparison between Unknown and I4
		//IL_003e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0044: Invalid comparison between Unknown and I4
		if ((Object)(object)_lastMap != (Object)null && (int)_lastMap.eMap == (int)map)
		{
			return _lastMap;
		}
		foreach (MapData item in Resources.FindObjectsOfTypeAll<MapData>())
		{
			if ((Object)(object)item != (Object)null && (int)item.eMap == (int)map)
			{
				_lastMap = item;
				return item;
			}
		}
		return null;
	}

	public static MapData FindMap(EMap map)
	{
		return TryFindMap(map) ?? throw new ArgumentException($"No MapData for map {map}.");
	}

	public static IReadOnlyList<PaletteMapCatalog> DescribeAll(MapData current, SpawnInteractables interactables, RandomObjectPlacer placer)
	{
		List<PaletteMapCatalog> list = new List<PaletteMapCatalog>();
		if ((Object)(object)current != (Object)null)
		{
			list.Add(Describe(current, interactables, placer));
		}
		foreach (MapData item in OtherLoadedMaps(current))
		{
			list.Add(Describe(item, null, null));
		}
		return list;
	}

	public static PaletteMapCatalog Describe(MapData mapData, SpawnInteractables interactables, RandomObjectPlacer placer)
	{
		//IL_0186: Unknown result type (might be due to invalid IL or missing references)
		//IL_02bd: Expected I4, but got Unknown
		PaletteStageCatalog[] array = new PaletteStageCatalog[((Il2CppArrayBase<StageData>)(object)mapData.stages)?.Length ?? 0];
		for (int i = 0; i < array.Length; i++)
		{
			StageData val = ((Il2CppArrayBase<StageData>)(object)mapData.stages)[i];
			Il2CppReferenceArray<RandomMapObject> randomMapObjects = val.randomMapObjects;
			int[] array2 = new int[((Il2CppArrayBase<RandomMapObject>)(object)randomMapObjects)?.Length ?? 0];
			for (int j = 0; j < array2.Length; j++)
			{
				array2[j] = ((Il2CppArrayBase<GameObject>)(object)((Il2CppArrayBase<RandomMapObject>)(object)randomMapObjects)[j].prefabs)?.Length ?? 0;
			}
			int num = i;
			StageTilePrefabs stageTilePrefabs = val.stageTilePrefabs;
			int valueOrDefault = ((stageTilePrefabs != null) ? ((Il2CppArrayBase<GameObject>)(object)stageTilePrefabs.flatTilePrefabs)?.Length : ((int?)null)).GetValueOrDefault();
			StageTilePrefabs stageTilePrefabs2 = val.stageTilePrefabs;
			array[num] = new PaletteStageCatalog(array2, valueOrDefault, ((stageTilePrefabs2 != null) ? ((Il2CppArrayBase<GameObject>)(object)stageTilePrefabs2.mapSpecificTilesPrefabs)?.Length : ((int?)null)).GetValueOrDefault());
		}
		Il2CppReferenceArray<RandomMapObject> randomObjectsOverride = mapData.randomObjectsOverride;
		int[] array3 = new int[((Il2CppArrayBase<RandomMapObject>)(object)randomObjectsOverride)?.Length ?? 0];
		for (int k = 0; k < array3.Length; k++)
		{
			int num2 = k;
			RandomMapObject obj = ((Il2CppArrayBase<RandomMapObject>)(object)randomObjectsOverride)[k];
			array3[num2] = ((obj != null) ? ((Il2CppArrayBase<GameObject>)(object)obj.prefabs)?.Length : ((int?)null)).GetValueOrDefault();
		}
		EMap eMap = mapData.eMap;
		int shrineCount = ((Il2CppArrayBase<GameObject>)(object)mapData.shrines)?.Length ?? 0;
		bool hasChest = (Object)(object)((interactables != null) ? interactables.chest : null) != (Object)null;
		bool hasChestFree = (Object)(object)((interactables != null) ? interactables.chestFree : null) != (Object)null;
		int valueOrDefault2 = ((interactables == null) ? ((int?)null) : ((Il2CppArrayBase<GameObject>)(object)interactables.rails)?.Length).GetValueOrDefault();
		int hasBoombox;
		if ((Object)(object)interactables != (Object)null)
		{
			EffectManager instance = EffectManager.Instance;
			hasBoombox = (((Object)(object)((instance != null) ? instance.boomboxQuest : null) != (Object)null) ? 1 : 0);
		}
		else
		{
			hasBoombox = 0;
		}
		int? obj2;
		if (placer == null)
		{
			obj2 = null;
		}
		else
		{
			RandomMapObject chargeShrineSpawns = placer.chargeShrineSpawns;
			obj2 = ((chargeShrineSpawns == null) ? ((int?)null) : ((Il2CppArrayBase<GameObject>)(object)chargeShrineSpawns.prefabs)?.Length);
		}
		int? num3 = obj2;
		int valueOrDefault3 = num3.GetValueOrDefault();
		int? obj3;
		if (placer == null)
		{
			obj3 = null;
		}
		else
		{
			RandomMapObject greedShrineSpawns = placer.greedShrineSpawns;
			obj3 = ((greedShrineSpawns == null) ? ((int?)null) : ((Il2CppArrayBase<GameObject>)(object)greedShrineSpawns.prefabs)?.Length);
		}
		num3 = obj3;
		return new PaletteMapCatalog((EMap)eMap, array, shrineCount, hasChest, hasChestFree, valueOrDefault2, (byte)hasBoombox != 0, valueOrDefault3, num3.GetValueOrDefault(), array3);
	}

	public static GameObject Resolve(CatalogRoute route, SpawnInteractables interactables, RandomObjectPlacer placer)
	{
		switch (route.Kind)
		{
		case CatalogRouteKind.Chest:
			return interactables.chest;
		case CatalogRouteKind.ChestFree:
			return interactables.chestFree;
		case CatalogRouteKind.Boombox:
			return EffectManager.Instance.boomboxQuest;
		case CatalogRouteKind.Rail:
			return ((Il2CppArrayBase<GameObject>)(object)interactables.rails)[route.Index];
		case CatalogRouteKind.ChargeShrine:
		{
			object obj2;
			if (placer == null)
			{
				obj2 = null;
			}
			else
			{
				RandomMapObject chargeShrineSpawns = placer.chargeShrineSpawns;
				obj2 = ((chargeShrineSpawns != null) ? chargeShrineSpawns.prefabs : null);
			}
			return PrefabAt(Il2CppArrayBase<GameObject>.op_Implicit((Il2CppArrayBase<GameObject>)obj2), route.Index);
		}
		case CatalogRouteKind.GreedShrine:
		{
			object obj3;
			if (placer == null)
			{
				obj3 = null;
			}
			else
			{
				RandomMapObject greedShrineSpawns = placer.greedShrineSpawns;
				obj3 = ((greedShrineSpawns != null) ? greedShrineSpawns.prefabs : null);
			}
			return PrefabAt(Il2CppArrayBase<GameObject>.op_Implicit((Il2CppArrayBase<GameObject>)obj3), route.Index);
		}
		default:
		{
			MapData val = FindMap(route.Map);
			if (route.Kind == CatalogRouteKind.Shrine)
			{
				return ((Il2CppArrayBase<GameObject>)(object)val.shrines)[route.Index];
			}
			if (route.Kind == CatalogRouteKind.RandomObjectOverride)
			{
				Il2CppReferenceArray<RandomMapObject> randomObjectsOverride = val.randomObjectsOverride;
				if (randomObjectsOverride == null || route.Index >= ((Il2CppArrayBase<RandomMapObject>)(object)randomObjectsOverride).Length)
				{
					return null;
				}
				RandomMapObject obj = ((Il2CppArrayBase<RandomMapObject>)(object)randomObjectsOverride)[route.Index];
				return PrefabAt(Il2CppArrayBase<GameObject>.op_Implicit((Il2CppArrayBase<GameObject>)(object)((obj != null) ? obj.prefabs : null)), route.SubIndex);
			}
			StageData val2 = ((Il2CppArrayBase<StageData>)(object)val.stages)[route.Stage];
			return (GameObject)(route.Kind switch
			{
				CatalogRouteKind.RandomMapObject => ((Il2CppArrayBase<GameObject>)(object)((Il2CppArrayBase<RandomMapObject>)(object)val2.randomMapObjects)[route.Index].prefabs)[route.SubIndex], 
				CatalogRouteKind.FlatTilePrefab => ((Il2CppArrayBase<GameObject>)(object)val2.stageTilePrefabs.flatTilePrefabs)[route.Index], 
				CatalogRouteKind.SpecificTilePrefab => ((Il2CppArrayBase<GameObject>)(object)val2.stageTilePrefabs.mapSpecificTilesPrefabs)[route.Index], 
				_ => throw new ArgumentException($"Unhandled catalog route kind {route.Kind}."), 
			});
		}
		}
	}

	private static IEnumerable<MapData> OtherLoadedMaps(MapData current)
	{
		HashSet<int> seen = new HashSet<int>();
		return from mapData in (IEnumerable<MapData>)Resources.FindObjectsOfTypeAll<MapData>()
			where (Object)(object)mapData != (Object)null && mapData != current && seen.Add((int)mapData.eMap)
			orderby (int)mapData.eMap
			select mapData;
	}

	private static GameObject PrefabAt(GameObject[] prefabs, int index)
	{
		if (prefabs == null || index < 0 || index >= prefabs.Length)
		{
			return null;
		}
		return prefabs[index];
	}
}
public enum CatalogRouteKind
{
	RandomMapObject,
	FlatTilePrefab,
	SpecificTilePrefab,
	Shrine,
	RandomObjectOverride,
	Chest,
	ChestFree,
	Boombox,
	Rail,
	ChargeShrine,
	GreedShrine
}
public readonly record struct CatalogRoute(CatalogRouteKind Kind, EMap Map, int Stage, int Index, int SubIndex)
{
	public static CatalogRoute Parse(CatalogId id)
	{
		if (id.Namespace != CatalogNamespace.GameAsset)
		{
			throw new ArgumentException("'" + id.Serialize() + "' is not a game-asset catalogId.", "id");
		}
		IReadOnlyList<string> segments = id.Segments;
		if (segments.Count == 2 && segments[0] == "interactable")
		{
			return segments[1] switch
			{
				"chest" => new CatalogRoute(CatalogRouteKind.Chest, EMap.None, 0, 0, 0), 
				"chestFree" => new CatalogRoute(CatalogRouteKind.ChestFree, EMap.None, 0, 0, 0), 
				"boombox" => new CatalogRoute(CatalogRouteKind.Boombox, EMap.None, 0, 0, 0), 
				_ => throw Unresolvable(id), 
			};
		}
		if (segments.Count == 3 && segments[0] == "interactable" && segments[1] == "rail")
		{
			return new CatalogRoute(CatalogRouteKind.Rail, EMap.None, 0, Number(segments[2], id), 0);
		}
		if (segments.Count == 3 && segments[0] == "interactable" && segments[1] == "chargeShrine")
		{
			return new CatalogRoute(CatalogRouteKind.ChargeShrine, EMap.None, 0, Number(segments[2], id), 0);
		}
		if (segments.Count == 3 && segments[0] == "interactable" && segments[1] == "greedShrine")
		{
			return new CatalogRoute(CatalogRouteKind.GreedShrine, EMap.None, 0, Number(segments[2], id), 0);
		}
		EMap map = ParseMap(segments[0], id);
		if (segments.Count == 3 && segments[1] == "shrines")
		{
			return new CatalogRoute(CatalogRouteKind.Shrine, map, 0, Number(segments[2], id), 0);
		}
		if (segments.Count == 4 && segments[1] == "randomObjectsOverride")
		{
			return new CatalogRoute(CatalogRouteKind.RandomObjectOverride, map, 0, Number(segments[2], id), Number(segments[3], id));
		}
		if (segments.Count >= 4 && segments[1].StartsWith("stage", StringComparison.Ordinal))
		{
			int stage = Number(segments[1].Substring("stage".Length), id);
			if (segments.Count == 5 && segments[2] == "randomMapObjects")
			{
				return new CatalogRoute(CatalogRouteKind.RandomMapObject, map, stage, Number(segments[3], id), Number(segments[4], id));
			}
			if (segments.Count == 5 && segments[2] == "stageTilePrefabs" && segments[3] == "flat")
			{
				return new CatalogRoute(CatalogRouteKind.FlatTilePrefab, map, stage, Number(segments[4], id), 0);
			}
			if (segments.Count == 5 && segments[2] == "stageTilePrefabs" && segments[3] == "specific")
			{
				return new CatalogRoute(CatalogRouteKind.SpecificTilePrefab, map, stage, Number(segments[4], id), 0);
			}
		}
		throw Unresolvable(id);
	}

	private static EMap ParseMap(string segment, CatalogId id)
	{
		if (!Enum.TryParse<EMap>(segment, ignoreCase: true, out var result) || result == EMap.None || !Enum.IsDefined(typeof(EMap), result))
		{
			throw Unresolvable(id);
		}
		return result;
	}

	private static int Number(string segment, CatalogId id)
	{
		if (!int.TryParse(segment, out var result) || result < 0)
		{
			throw Unresolvable(id);
		}
		return result;
	}

	private static ArgumentException Unresolvable(CatalogId id)
	{
		return new ArgumentException("catalogId '" + id.Serialize() + "' does not match a known game-asset catalog shape.", "id");
	}
}
public sealed class CellChangeTracker
{
	public const uint PlayerId = uint.MaxValue;

	private readonly Dictionary<uint, (GridCell Cell, int Level)> _last = new Dictionary<uint, (GridCell, int)>();

	public bool Changed(uint id, GridCell cell, int level)
	{
		if (_last.TryGetValue(id, out (GridCell, int) value) && value.Item1.Equals(cell) && value.Item2 == level)
		{
			return false;
		}
		_last[id] = (cell, level);
		return true;
	}

	public void Reset()
	{
		_last.Clear();
	}
}
public static class CharacterOverride
{
	public const int TonyMcZoomId = 13;

	public const int CalciumId = 1;

	public static string DisplayName(int id)
	{
		return id switch
		{
			1 => "Calcium", 
			13 => "Tony McZoom", 
			_ => $"character {id}", 
		};
	}

	public static bool IsAllowed(int id)
	{
		if (id != 1)
		{
			return id == 13;
		}
		return true;
	}

	public static int? TryParseName(string name)
	{
		switch (name?.Trim().ToLowerInvariant())
		{
		case "calcium":
			return 1;
		case "tony":
		case "tonymczoom":
			return 13;
		default:
			return null;
		}
	}

	public static string TryApply(Action<int> setSelected, int id = 13)
	{
		try
		{
			setSelected(id);
			return null;
		}
		catch (Exception ex)
		{
			return $"LevelLoader: could not select character {id}, run starts with the default character: {ex.Message}";
		}
	}
}
public static class DevCharacter
{
	public static int? Resolve(bool devEnabled, string name)
	{
		if (!devEnabled)
		{
			return null;
		}
		if (string.IsNullOrWhiteSpace(name))
		{
			return 13;
		}
		return CharacterOverride.TryParseName(name) ?? throw new ArgumentException("'" + name + "' is not an allowed character (calcium, tonymczoom)");
	}
}
public static class CharacterGridOrder
{
	public static IReadOnlyList<int> Pin(IReadOnlyList<int> stockIds)
	{
		return new int[2] { 1, 13 }.Where(((IEnumerable<int>)stockIds).Contains<int>).Concat(stockIds.Where((int id) => !CharacterOverride.IsAllowed(id))).ToList();
	}
}
public static class CharacterPolicy
{
	public static IReadOnlyList<int> AllowedIds(IReadOnlyList<string> names)
	{
		List<int> list = (names ?? new List<string>()).Select(CharacterOverride.TryParseName).OfType<int>().Distinct()
			.ToList();
		if (list.Count != 0)
		{
			return list;
		}
		return null;
	}

	public static IReadOnlyList<string> UnknownNames(IReadOnlyList<string> names)
	{
		return (names ?? new List<string>()).Where((string name) => !CharacterOverride.TryParseName(name).HasValue).ToList();
	}

	public static bool Permits(IReadOnlyList<int> allowedIds, int id)
	{
		return allowedIds?.Contains(id) ?? true;
	}

	public static string Refusal(IReadOnlyList<int> allowedIds, string levelTitle)
	{
		string text = string.Join(" or ", allowedIds.Select(CharacterOverride.DisplayName));
		return "Pick " + text + " for " + (levelTitle ?? "this level");
	}
}
public static class CharacterScreenPatch
{
	private readonly record struct ButtonSnapshot(int SiblingIndex, bool CanUse, Color IconColor, bool OverlayActive, string Reason);

	[HarmonyPatch(typeof(CharacterMenu), "OnEnable")]
	private static class OnEnablePostfix
	{
		private static void Postfix(CharacterMenu __instance)
		{
			if (Restricted)
			{
				Apply(__instance);
			}
		}
	}

	[HarmonyPatch(typeof(CharacterMenu), "OnDisable")]
	private static class OnDisablePostfix
	{
		private static void Postfix(CharacterMenu __instance)
		{
			MainMenu mainMenu = __instance.mainMenu;
			GameObject val = ((mainMenu != null) ? mainMenu.tabMaps : null);
			LevelLoaderPatch.OnMenuDisabled((Object)(object)val != (Object)null && val.activeInHierarchy);
		}
	}

	private const int PlaceholderId = -1;

	private static ModLogger _logger;

	private static readonly Dictionary<int, ButtonSnapshot> _stock = new Dictionary<int, ButtonSnapshot>();

	private static readonly int[] DefaultAllowedIds = new int[2] { 1, 13 };

	private static IReadOnlyList<int> _allowedIds = DefaultAllowedIds;

	private static ECharacter? _savedCharacter;

	public static bool Restricted { get; private set; }

	public static void Install(ModLogger logger)
	{
		_logger = logger;
	}

	public static void SetRestricted(bool restricted, IReadOnlyList<int> allowedIds = null)
	{
		//IL_002d: Unknown result type (might be due to invalid IL or missing references)
		_allowedIds = allowedIds ?? DefaultAllowedIds;
		if (restricted && !Restricted)
		{
			Preferences obj = SavedPreferences();
			_savedCharacter = ((obj != null) ? new ECharacter?(obj.selectedCharacter) : ((ECharacter?)null));
		}
		else if (!restricted && Restricted)
		{
			RestoreSavedCharacter();
		}
		Restricted = restricted;
		foreach (CharacterMenu item in Resources.FindObjectsOfTypeAll<CharacterMenu>())
		{
			Apply(item);
		}
	}

	private static bool IsAllowed(int id)
	{
		return CharacterPolicy.Permits(_allowedIds, id);
	}

	private static Preferences SavedPreferences()
	{
		SaveManager instance = SaveManager.Instance;
		if (instance == null)
		{
			return null;
		}
		ConfigSaveFile config = instance.config;
		if (config == null)
		{
			return null;
		}
		return config.preferences;
	}

	private static void RestoreSavedCharacter()
	{
		//IL_0017: Unknown result type (might be due to invalid IL or missing references)
		//IL_001c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0021: Unknown result type (might be due to invalid IL or missing references)
		//IL_0026: Unknown result type (might be due to invalid IL or missing references)
		//IL_002a: Unknown result type (might be due to invalid IL or missing references)
		//IL_005d: Unknown result type (might be due to invalid IL or missing references)
		Preferences val = SavedPreferences();
		ECharacter? savedCharacter = _savedCharacter;
		if (savedCharacter.HasValue)
		{
			ECharacter valueOrDefault = savedCharacter.GetValueOrDefault();
			if (val != null && val.selectedCharacter != valueOrDefault)
			{
				val.selectedCharacter = valueOrDefault;
				SaveManager.Instance.SaveConfig();
				_logger?.Msg($"CharacterScreen: saved character restored to {valueOrDefault}");
			}
		}
		_savedCharacter = null;
	}

	private static void Apply(CharacterMenu menu)
	{
		if ((Object)(object)menu == (Object)null || (Object)(object)menu.characterGridParent == (Object)null)
		{
			return;
		}
		Il2CppArrayBase<MyButtonCharacter> componentsInChildren = ((Component)menu.characterGridParent).GetComponentsInChildren<MyButtonCharacter>(true);
		if (componentsInChildren.Length < 2)
		{
			return;
		}
		foreach (MyButtonCharacter item in componentsInChildren)
		{
			if (!_stock.ContainsKey(((Object)item).GetInstanceID()))
			{
				_stock[((Object)item).GetInstanceID()] = Snapshot(item);
			}
		}
		if (Restricted)
		{
			Restrict(menu, Il2CppArrayBase<MyButtonCharacter>.op_Implicit(componentsInChildren));
		}
		else
		{
			RestoreStock(Il2CppArrayBase<MyButtonCharacter>.op_Implicit(componentsInChildren));
		}
		RebuildNavigation(menu);
		if (Restricted && ((Component)menu).gameObject.activeInHierarchy)
		{
			FocusFirstAllowed(Il2CppArrayBase<MyButtonCharacter>.op_Implicit(componentsInChildren));
		}
	}

	private static void FocusFirstAllowed(MyButtonCharacter[] buttons)
	{
		MyButtonCharacter val = null;
		foreach (MyButtonCharacter val2 in buttons)
		{
			if (IsAllowed(IdOf(val2)) && ((Object)(object)val == (Object)null || ((Component)val2).transform.GetSiblingIndex() < ((Component)val).transform.GetSiblingIndex()))
			{
				val = val2;
			}
		}
		if ((Object)(object)val != (Object)null && (Object)(object)EventSystem.current != (Object)null)
		{
			EventSystem.current.SetSelectedGameObject(((Component)val).gameObject);
		}
	}

	private static void RebuildNavigation(CharacterMenu menu)
	{
		try
		{
			List<MyButtonCharacter> value = Traverse.Create((object)menu).Property("characterButtons", (object[])null).GetValue<List<MyButtonCharacter>>();
			if (value != null)
			{
				List<MyButtonCharacter> list = new List<MyButtonCharacter>();
				Enumerator<MyButtonCharacter> enumerator = value.GetEnumerator();
				while (enumerator.MoveNext())
				{
					MyButtonCharacter current = enumerator.Current;
					list.Add(current);
				}
				list.Sort((MyButtonCharacter a, MyButtonCharacter b) => ((Component)a).transform.GetSiblingIndex().CompareTo(((Component)b).transform.GetSiblingIndex()));
				value.Clear();
				foreach (MyButtonCharacter item in list)
				{
					value.Add(item);
				}
			}
			AccessTools.Method(typeof(CharacterMenu), "SetupButtonNavigation", (Type[])null, (Type[])null).Invoke(menu, null);
		}
		catch (Exception ex)
		{
			_logger?.Warning("CharacterScreen: could not rebuild navigation: " + ex.Message);
		}
	}

	private static ButtonSnapshot Snapshot(MyButtonCharacter button)
	{
		//IL_002c: Unknown result type (might be due to invalid IL or missing references)
		//IL_001f: Unknown result type (might be due to invalid IL or missing references)
		return new ButtonSnapshot(((Component)button).transform.GetSiblingIndex(), button.canUseCharacter, ((Object)(object)button.i_icon != (Object)null) ? ((Graphic)button.i_icon).color : Color.white, (Object)(object)button.unavailableOverlay != (Object)null && button.unavailableOverlay.activeSelf, button.cantUseCharacterReason);
	}

	private static int IdOf(MyButtonCharacter button)
	{
		//IL_0016: Unknown result type (might be due to invalid IL or missing references)
		//IL_001c: Expected I4, but got Unknown
		if (!((Object)(object)button.characterData != (Object)null))
		{
			return -1;
		}
		return (int)button.characterData.eCharacter;
	}

	private static void Restrict(CharacterMenu menu, MyButtonCharacter[] buttons)
	{
		//IL_013d: Unknown result type (might be due to invalid IL or missing references)
		List<MyButtonCharacter> list = new List<MyButtonCharacter>(buttons);
		list.Sort((MyButtonCharacter a, MyButtonCharacter b) => _stock[((Object)a).GetInstanceID()].SiblingIndex.CompareTo(_stock[((Object)b).GetInstanceID()].SiblingIndex));
		List<int> list2 = list.ConvertAll(IdOf);
		Dictionary<int, Queue<MyButtonCharacter>> dictionary = new Dictionary<int, Queue<MyButtonCharacter>>();
		for (int num = 0; num < list.Count; num++)
		{
			if (!dictionary.TryGetValue(list2[num], out var value))
			{
				value = (dictionary[list2[num]] = new Queue<MyButtonCharacter>());
			}
			value.Enqueue(list[num]);
		}
		int num2 = 0;
		foreach (int item in CharacterGridOrder.Pin(list2))
		{
			((Component)dictionary[item].Dequeue()).transform.SetSiblingIndex(num2++);
		}
		foreach (MyButtonCharacter val in buttons)
		{
			if (!((Object)(object)val.characterData == (Object)null) && !IsAllowed(IdOf(val)))
			{
				val.canUseCharacter = false;
				val.cantUseCharacterReason = CharacterPolicy.Refusal(_allowedIds, null);
				if ((Object)(object)val.i_icon != (Object)null)
				{
					((Graphic)val.i_icon).color = Color.black;
				}
				if ((Object)(object)val.unavailableOverlay != (Object)null)
				{
					val.unavailableOverlay.SetActive(true);
				}
			}
		}
		_logger?.Msg($"CharacterScreen: restricted to {string.Join(", ", _allowedIds)}, {buttons.Length} buttons");
	}

	private static void RestoreStock(MyButtonCharacter[] buttons)
	{
		//IL_0060: Unknown result type (might be due to invalid IL or missing references)
		foreach (MyButtonCharacter val in buttons)
		{
			ButtonSnapshot buttonSnapshot = _stock[((Object)val).GetInstanceID()];
			((Component)val).transform.SetSiblingIndex(buttonSnapshot.SiblingIndex);
			val.canUseCharacter = buttonSnapshot.CanUse;
			val.cantUseCharacterReason = buttonSnapshot.Reason;
			if ((Object)(object)val.i_icon != (Object)null)
			{
				((Graphic)val.i_icon).color = buttonSnapshot.IconColor;
			}
			if ((Object)(object)val.unavailableOverlay != (Object)null)
			{
				val.unavailableOverlay.SetActive(buttonSnapshot.OverlayActive);
			}
		}
	}
}
public static class ChestLuck
{
	public static float Roll(IReadOnlyList<float> range, Random random)
	{
		if (range != null)
		{
			return range[0] + (float)random.NextDouble() * (range[1] - range[0]);
		}
		return 0f;
	}

	public static float Apply(float luck, float shift)
	{
		return luck + shift;
	}
}
public static class ChestLuckPatch
{
	[HarmonyPatch(typeof(ItemUtility), "GetRandomChestItem")]
	private static class GetRandomChestItemPrefix
	{
		private static void Prefix(ref float luck)
		{
			if (_shift != 0f && CustomLevelState.IsActive)
			{
				float num = ChestLuck.Apply(luck, _shift);
				_logger?.Msg($"ChestLuck: chest loot rolled with luck {luck:F2} shifted to {num:F2}");
				luck = num;
			}
		}
	}

	private static float _shift;

	private static ModLogger _logger;

	public static void Install(ModLogger logger)
	{
		_logger = logger;
	}

	public static void Roll(IReadOnlyList<float> range, ModLogger logger)
	{
		_shift = ChestLuck.Roll(range, new Random(Guid.NewGuid().GetHashCode()));
		if (range != null)
		{
			logger.Msg($"ChestLuck: this run's chest luck shift is {_shift:F2} (range {range[0]:F2} to {range[1]:F2})");
		}
	}
}
public static class ChildHider
{
	public static void Hide(GameObject go, IReadOnlyList<string> names, ModLogger logger)
	{
		if (names == null || names.Count == 0)
		{
			return;
		}
		foreach (Transform componentsInChild in go.GetComponentsInChildren<Transform>(true))
		{
			if (!names.Contains(((Object)componentsInChild).name))
			{
				continue;
			}
			foreach (Renderer component in ((Component)componentsInChild).GetComponents<Renderer>())
			{
				component.enabled = false;
			}
			foreach (Collider component2 in ((Component)componentsInChild).GetComponents<Collider>())
			{
				component2.enabled = false;
			}
			logger?.Msg($"LiveEdit: hid child '{((Object)componentsInChild).name}' of '{((Object)go).name}'");
		}
	}
}
public static class CollisionRebuild
{
	public static void Replace(ProceduralTileGeneration tileGen, ModLogger logger)
	{
		GameObject collider = tileGen.collider;
		GameObject val = Build(tileGen, logger);
		if ((Object)(object)val == (Object)null)
		{
			logger.Warning("CollisionRebuild: combiner returned nothing; keeping the original collision");
			return;
		}
		tileGen.collider = val;
		if ((Object)(object)collider != (Object)null)
		{
			Object.Destroy((Object)(object)collider);
		}
	}

	private static GameObject Build(ProceduralTileGeneration tileGen, ModLogger logger)
	{
		Dictionary<string, Mesh> dictionary = PrefabColliderMeshes(tileGen);
		List<GameObject> val = new List<GameObject>();
		List<MeshCollider> list = new List<MeshCollider>();
		List<GameObject>[] array = new List<GameObject>[3] { tileGen.tiles, tileGen.flatTiles, tileGen.fillTiles };
		foreach (List<GameObject> val2 in array)
		{
			for (int j = 0; j < val2.Count; j++)
			{
				GameObject val3 = val2[j];
				if (!((Object)(object)val3 == (Object)null) && val3.activeInHierarchy && dictionary.TryGetValue(StripClone(((Object)val3).name), out var value))
				{
					MeshCollider component = val3.GetComponent<MeshCollider>();
					if ((Object)(object)component == (Object)null)
					{
						component = val3.AddComponent<MeshCollider>();
						component.sharedMesh = value;
						list.Add(component);
					}
					val.Add(val3);
				}
			}
		}
		GameObject result = MeshColliderCombiner.CombineMeshes(val);
		foreach (MeshCollider item in list)
		{
			Object.Destroy((Object)(object)item);
		}
		logger.Msg($"CollisionRebuild: combined {val.Count} pieces ({list.Count} temporary colliders)");
		return result;
	}

	private static Dictionary<string, Mesh> PrefabColliderMeshes(ProceduralTileGeneration tileGen)
	{
		Dictionary<string, Mesh> dictionary = new Dictionary<string, Mesh>();
		GameObject[] array = (GameObject[])(object)new GameObject[6] { tileGen.flatTile, tileGen.slopeTile, tileGen.wallFlat, tileGen.wallLeftUp, tileGen.wallLeftDown, tileGen.wallLeftCross };
		foreach (GameObject val in array)
		{
			MeshCollider val2 = (((Object)(object)val == (Object)null) ? null : val.GetComponent<MeshCollider>());
			if ((Object)(object)val2 != (Object)null && (Object)(object)val2.sharedMesh != (Object)null)
			{
				dictionary[((Object)val).name] = val2.sharedMesh;
			}
		}
		return dictionary;
	}

	private static string StripClone(string name)
	{
		if (!name.EndsWith("(Clone)", StringComparison.Ordinal))
		{
			return name;
		}
		return name.Substring(0, name.Length - "(Clone)".Length);
	}
}
public readonly record struct ConsoleDevState(bool DevEnabled);
public readonly record struct ConsoleToggleState(bool Invulnerable, bool Editor, bool Hud, bool Coordinates);
public readonly record struct ConsoleBindResult(HarnessCommand? Command, string Reply, string Error, bool ListHistory = false)
{
	public bool Ok => Error == null;
}
public sealed class ConsoleVerb
{
	private readonly Func<IReadOnlyList<string>, ConsoleToggleState, IReadOnlyList<string>, ConsoleBindResult> _bind;

	private Func<int, IReadOnlyList<string>, IEnumerable<string>> _candidates;

	public string Name { get; }

	public string Help { get; }

	public bool Gated { get; }

	public string Usage { get; }

	public string[] Aliases { get; private set; } = Array.Empty<string>();

	public bool RawError { get; private set; }

	public ConsoleVerb(string name, string help, bool gated, Func<IReadOnlyList<string>, ConsoleToggleState, IReadOnlyList<string>, ConsoleBindResult> bind, string usage = null)
	{
		Name = name;
		Help = help;
		Gated = gated;
		_bind = bind;
		Usage = usage ?? ("usage: " + name);
	}

	public ConsoleVerb WithRawError()
	{
		RawError = true;
		return this;
	}

	public ConsoleVerb WithAliases(params string[] aliases)
	{
		Aliases = aliases;
		return this;
	}

	public ConsoleVerb WithCandidates(Func<int, IReadOnlyList<string>, IEnumerable<string>> candidates)
	{
		_candidates = candidates;
		return this;
	}

	internal IEnumerable<string> Candidates(int argumentIndex, IReadOnlyList<string> levels)
	{
		return _candidates?.Invoke(argumentIndex, levels) ?? Enumerable.Empty<string>();
	}

	internal ConsoleBindResult Bind(IReadOnlyList<string> args, ConsoleToggleState toggles, IReadOnlyList<string> levels)
	{
		return _bind(args, toggles, levels);
	}
}
public readonly record struct ConsoleCompletion(IReadOnlyList<string> Matches, int Index, string Prefix, IReadOnlyList<string> Lines = null, string Original = "")
{
	public string Text
	{
		get
		{
			IReadOnlyList<string> matches = Matches;
			if (matches == null || matches.Count <= 0 || Index < 0 || Index >= matches.Count)
			{
				return "";
			}
			return matches[Index];
		}
	}

	public string Completion
	{
		get
		{
			if (Text.Length < Prefix.Length)
			{
				return "";
			}
			return Text.Substring(Prefix.Length);
		}
	}

	public string Line
	{
		get
		{
			IReadOnlyList<string> lines = Lines;
			if (lines == null || lines.Count <= 0 || Index < 0 || Index >= lines.Count)
			{
				return Original;
			}
			return lines[Index];
		}
	}

	public ConsoleCompletion Next()
	{
		IReadOnlyList<string> matches = Matches;
		if (matches == null || matches.Count <= 0)
		{
			return this;
		}
		return this with
		{
			Index = (Index + 1) % matches.Count
		};
	}

	public ConsoleCompletion Prev()
	{
		IReadOnlyList<string> matches = Matches;
		if (matches == null || matches.Count <= 0)
		{
			return this;
		}
		return this with
		{
			Index = (Index - 1 + matches.Count) % matches.Count
		};
	}
}
public sealed class ConsoleCommandRegistry
{
	private readonly record struct OptionSet(int? Map, int? Stage, int? Tier, int? Seed, int? Size, bool Unseeded, bool Bad)
	{
		public static OptionSet Rejected { get; } = new OptionSet(null, null, null, null, null, Unseeded: false, Bad: true);
	}

	public const string GatedReply = "requires MEGABONK_DEV";

	private const int MinDamageAmount = 1;

	private const int MaxDamageAmount = 99;

	private static readonly string[] PerfActions = new string[13]
	{
		"report", "status", "start", "reset", "spawn", "timescale", "toggle", "vsync", "render", "physics",
		"animation", "health", "census"
	};

	private readonly Dictionary<string, ConsoleVerb> _byName = new Dictionary<string, ConsoleVerb>(StringComparer.OrdinalIgnoreCase);

	private readonly List<ConsoleVerb> _verbs = new List<ConsoleVerb>();

	public static ConsoleCommandRegistry Default { get; } = Build();

	public IReadOnlyList<ConsoleVerb> Verbs => _verbs;

	public ConsoleVerb Find(string name)
	{
		if (name == null || !_byName.TryGetValue(name, out var value))
		{
			return null;
		}
		return value;
	}

	public ConsoleBindResult Bind(string line, ConsoleDevState dev, ConsoleToggleState toggles, IReadOnlyList<string> levels = null)
	{
		ConsoleTokens consoleTokens = ConsoleCommandTokenizer.Tokenize(line);
		if (consoleTokens.Tokens == null)
		{
			return new ConsoleBindResult(null, null, consoleTokens.Error);
		}
		if (consoleTokens.IsBlank)
		{
			return new ConsoleBindResult(null, null, null);
		}
		ConsoleVerb consoleVerb = Find(consoleTokens.Verb);
		if (consoleVerb == null)
		{
			return new ConsoleBindResult(null, null, UnknownVerb(consoleTokens.Verb));
		}
		if (consoleVerb.Gated && !dev.DevEnabled)
		{
			return new ConsoleBindResult(null, null, "requires MEGABONK_DEV");
		}
		if (consoleVerb.Name == "help")
		{
			if (consoleTokens.Arguments.Count > 1)
			{
				return new ConsoleBindResult(null, null, consoleVerb.Usage);
			}
			return new ConsoleBindResult(null, Help((consoleTokens.Arguments.Count == 1) ? consoleTokens.Arguments[0] : null, dev.DevEnabled), null);
		}
		ConsoleBindResult result = consoleVerb.Bind(consoleTokens.Arguments, toggles, levels);
		if (result.Error == "no match")
		{
			return new ConsoleBindResult(null, null, consoleVerb.Usage);
		}
		if (result.Error != null && !consoleVerb.RawError && !result.Error.StartsWith("usage:", StringComparison.Ordinal))
		{
			return new ConsoleBindResult(null, null, result.Error + "\n" + consoleVerb.Usage);
		}
		return result;
	}

	public ConsoleCompletion Complete(string line, IReadOnlyList<string> levels = null)
	{
		if (line == null)
		{
			line = "";
		}
		ConsoleLastWord word = ConsoleCommandTokenizer.LastWord(line);
		string head = line.Substring(0, word.Start);
		List<string> list = (from name in Candidates(head, word.WordsBefore, levels)
			where name.StartsWith(word.Text, StringComparison.OrdinalIgnoreCase)
			select name).Distinct<string>(StringComparer.OrdinalIgnoreCase).ToList();
		return new ConsoleCompletion(list, (list.Count == 0) ? (-1) : 0, word.Text, list.Select((string m) => head + QuoteWord(m)).ToList(), line);
	}

	private IEnumerable<string> Candidates(string head, int wordsBefore, IReadOnlyList<string> levels)
	{
		object obj;
		if (wordsBefore != 0)
		{
			obj = Find(ConsoleCommandTokenizer.Tokenize(head).Verb)?.Candidates(wordsBefore - 1, levels);
			if (obj == null)
			{
				return Enumerable.Empty<string>();
			}
		}
		else
		{
			IEnumerable<string> enumerable = _verbs.SelectMany(VerbNames).OrderBy<string, string>((string name) => name, StringComparer.Ordinal);
			obj = enumerable;
		}
		return (IEnumerable<string>)obj;
	}

	private static string QuoteWord(string word)
	{
		if (!word.Any(char.IsWhiteSpace))
		{
			return word;
		}
		return "\"" + word + "\"";
	}

	private string Help(string filter, bool dev)
	{
		List<(string Names, string Help)> rows = (from verb in _verbs
			where (dev || !verb.Gated) && (filter == null || verb.Name.StartsWith(filter, StringComparison.OrdinalIgnoreCase) || verb.Aliases.Any((string a) => a.StartsWith(filter, StringComparison.OrdinalIgnoreCase)))
			select (Names: verb.Name + ((verb.Aliases.Length != 0) ? (", " + string.Join(", ", verb.Aliases)) : ""), Help: verb.Help)).ToList();
		if (rows.Count != 0)
		{
			return string.Join("\n", rows.Select(((string Names, string Help) row) => row.Names.PadRight(rows.Max(((string Names, string Help) r) => r.Names.Length) + 2) + row.Help));
		}
		return "no verb matches " + filter;
	}

	private string UnknownVerb(string typed)
	{
		List<string> list = Suggest(typed);
		string text = "unknown verb '" + typed + "'";
		if (list.Count != 0)
		{
			return text + "; did you mean " + string.Join(", ", list) + "?";
		}
		return text;
	}

	private static IEnumerable<string> VerbNames(ConsoleVerb verb)
	{
		yield return verb.Name;
		string[] aliases = verb.Aliases;
		for (int i = 0; i < aliases.Length; i++)
		{
			yield return aliases[i];
		}
	}

	private List<string> Suggest(string typed)
	{
		string lower = typed.ToLowerInvariant();
		int threshold = Math.Max(2, typed.Length / 2);
		return (from row in (from name in _verbs.SelectMany(VerbNames)
				select (name: name, distance: Distance(lower, name.ToLowerInvariant())) into row
				where row.distance <= threshold || row.name.StartsWith(typed, StringComparison.OrdinalIgnoreCase)
				orderby row.distance
				select row).ThenBy<(string, int), string>(((string name, int distance) row) => row.name, StringComparer.Ordinal)
			select row.name).Distinct<string>(StringComparer.OrdinalIgnoreCase).Take(3).ToList();
	}

	private static int Distance(string a, string b)
	{
		int[] array = new int[b.Length + 1];
		int[] array2 = new int[b.Length + 1];
		for (int i = 0; i <= b.Length; i++)
		{
			array[i] = i;
		}
		for (int j = 1; j <= a.Length; j++)
		{
			array2[0] = j;
			for (int k = 1; k <= b.Length; k++)
			{
				int num = ((a[j - 1] != b[k - 1]) ? 1 : 0);
				array2[k] = Math.Min(Math.Min(array2[k - 1] + 1, array[k] + 1), array[k - 1] + num);
			}
			int[] array3 = array2;
			array2 = array;
			array = array3;
		}
		return array[b.Length];
	}

	private ConsoleVerb Add(ConsoleVerb verb)
	{
		_verbs.Add(verb);
		_byName[verb.Name] = verb;
		string[] aliases = verb.Aliases;
		foreach (string key in aliases)
		{
			_byName[key] = verb;
		}
		return verb;
	}

	private static ConsoleCommandRegistry Build()
	{
		ConsoleCommandRegistry consoleCommandRegistry = new ConsoleCommandRegistry();
		consoleCommandRegistry.Add(new ConsoleVerb("help", "list verbs, aliases and one line of help", gated: false, (IReadOnlyList<string> args, ConsoleToggleState _, IReadOnlyList<string> _) => (args.Count > 1) ? NoMatch() : new ConsoleBindResult(null, null, null)).WithAliases("?"));
		consoleCommandRegistry.Add(new ConsoleVerb("clear", "clear the console scrollback", gated: false, (IReadOnlyList<string> _, ConsoleToggleState _, IReadOnlyList<string> _) => NoCommand()).WithAliases("cls"));
		consoleCommandRegistry.Add(new ConsoleVerb("history", "list the lines typed in earlier sessions and this one", gated: false, (IReadOnlyList<string> _, ConsoleToggleState _, IReadOnlyList<string> _) => new ConsoleBindResult(null, "", null, ListHistory: true)));
		consoleCommandRegistry.Add(new ConsoleVerb("state", "read the game's current state", gated: false, (IReadOnlyList<string> _, ConsoleToggleState _, IReadOnlyList<string> _) => Command(HarnessCommandKind.State)));
		float[] values;
		consoleCommandRegistry.Add(new ConsoleVerb("player.teleport", "move the player to a world position", gated: true, delegate(IReadOnlyList<string> args, ConsoleToggleState _, IReadOnlyList<string> _)
		{
			if (args.Count != 3 || !Floats(args, out values))
			{
				return NoMatch();
			}
			TeleportArgs teleport = new TeleportArgs
			{
				Position = values
			};
			return Command(new HarnessCommand(HarnessCommandKind.Teleport, null, default(CameraPose), Enabled: false, null, null, teleport));
		}, "usage: player.teleport x y z").WithAliases("tp"));
		consoleCommandRegistry.Add(new ConsoleVerb("player.teleport_cell", "move the player to a grid cell", gated: true, delegate(IReadOnlyList<string> args, ConsoleToggleState _, IReadOnlyList<string> _)
		{
			if (args.Count != 2 || !Ints(args, out values))
			{
				return NoMatch();
			}
			TeleportArgs teleport = new TeleportArgs
			{
				Cell = values
			};
			return Command(new HarnessCommand(HarnessCommandKind.Teleport, null, default(CameraPose), Enabled: false, null, null, teleport));
		}));
		consoleCommandRegistry.Add(new ConsoleVerb("player.god", "make the player survive damage", gated: true, delegate(IReadOnlyList<string> args, ConsoleToggleState toggles, IReadOnlyList<string> _)
		{
			bool? flag = Flag(args, toggles.Invulnerable);
			if (!flag.HasValue)
			{
				return NoMatch();
			}
			bool valueOrDefault = flag == true;
			return Enabled(valueOrDefault ? HarnessCommandKind.Invulnerable : HarnessCommandKind.Vulnerable, valueOrDefault);
		}).WithAliases("tgm"));
		consoleCommandRegistry.Add(new ConsoleVerb("player.kill", "end the run at once", gated: true, (IReadOnlyList<string> _, ConsoleToggleState _, IReadOnlyList<string> _) => Command(HarnessCommandKind.Kill)));
		consoleCommandRegistry.Add(new ConsoleVerb("player.damage", "apply 1-99 damage, fatal with 'lethal'", gated: true, delegate(IReadOnlyList<string> args, ConsoleToggleState _, IReadOnlyList<string> _)
		{
			int count = args.Count;
			bool flag = (uint)(count - 1) <= 1u;
			if (flag && Int(args[0], 1, 99, out var parsed))
			{
				bool? flag2 = Nonlethal(args);
				if (flag2.HasValue)
				{
					bool valueOrDefault = flag2 == true;
					DamageArgs damage = new DamageArgs
					{
						Amount = parsed,
						Nonlethal = valueOrDefault
					};
					return Command(new HarnessCommand(HarnessCommandKind.Damage, null, default(CameraPose), Enabled: false, null, null, null, 0, null, default(LoadOverrides), null, null, damage));
				}
			}
			return NoMatch();
		}));
		consoleCommandRegistry.Add(new ConsoleVerb("player.add_item", "read or set an item amount", gated: true, delegate(IReadOnlyList<string> args, ConsoleToggleState _, IReadOnlyList<string> _)
		{
			int parsed = 0;
			int count = args.Count;
			bool flag = (uint)(count - 1) <= 1u;
			if (!flag || args[0].Length <= 0 || (args.Count != 1 && !Int(args[1], 0, 999, out parsed)))
			{
				return NoMatch();
			}
			ItemArgs item = new ItemArgs
			{
				Name = args[0],
				Amount = ((args.Count == 2) ? new int?(parsed) : ((int?)null))
			};
			return Command(new HarnessCommand(HarnessCommandKind.Item, null, default(CameraPose), Enabled: false, null, null, null, 0, null, default(LoadOverrides), item));
		}));
		consoleCommandRegistry.Add(new ConsoleVerb("player.fall_damage", "read the live fall-damage inputs", gated: true, (IReadOnlyList<string> _, ConsoleToggleState _, IReadOnlyList<string> _) => Command(HarnessCommandKind.FallDamage)));
		consoleCommandRegistry.Add(new ConsoleVerb("enemies.kill", "kill nearest, all or bosses", gated: true, delegate(IReadOnlyList<string> args, ConsoleToggleState _, IReadOnlyList<string> _)
		{
			string text = ((args.Count == 0) ? "all" : args[0].ToLowerInvariant());
			if (Array.IndexOf(EnemyKillTargets.Names, text) < 0)
			{
				return NoMatch();
			}
			string killTarget = text;
			return Command(new HarnessCommand(HarnessCommandKind.KillEnemies, null, default(CameraPose), Enabled: false, null, null, null, 0, null, default(LoadOverrides), null, null, null, null, null, Skip: false, null, null, killTarget));
		}).WithAliases("killall"));
		consoleCommandRegistry.Add(new ConsoleVerb("enemies.spawns", "allow or stop new enemy spawns", gated: true, delegate(IReadOnlyList<string> args, ConsoleToggleState _, IReadOnlyList<string> _)
		{
			bool? flag = Flag(args, current: true);
			if (!flag.HasValue)
			{
				return NoMatch();
			}
			bool valueOrDefault = flag == true;
			return Enabled(HarnessCommandKind.Spawns, valueOrDefault);
		}));
		consoleCommandRegistry.Add(new ConsoleVerb("run.freeze", "stop gameplay", gated: true, (IReadOnlyList<string> _, ConsoleToggleState _, IReadOnlyList<string> _) => Command(HarnessCommandKind.Freeze)));
		consoleCommandRegistry.Add(new ConsoleVerb("run.resume", "start gameplay again", gated: true, (IReadOnlyList<string> _, ConsoleToggleState _, IReadOnlyList<string> _) => Command(HarnessCommandKind.Resume)));
		consoleCommandRegistry.Add(new ConsoleVerb("run.restart", "run the death screen's Retry", gated: true, (IReadOnlyList<string> _, ConsoleToggleState _, IReadOnlyList<string> _) => Command(HarnessCommandKind.RestartRun)));
		consoleCommandRegistry.Add(new ConsoleVerb("run.dismiss_levelup", "pick an upgrade in the level-up dialog", gated: true, delegate(IReadOnlyList<string> args, ConsoleToggleState _, IReadOnlyList<string> _)
		{
			int parsed = 0;
			if (args.Count > 1 || (args.Count != 0 && !Int(args[0], 0, int.MaxValue, out parsed)))
			{
				return NoMatch();
			}
			int choice = ((args.Count == 1) ? parsed : 0);
			return Command(new HarnessCommand(HarnessCommandKind.DismissLevelUp, null, default(CameraPose), Enabled: false, null, null, null, choice));
		}));
		consoleCommandRegistry.Add(new ConsoleVerb("run.dismiss_offers", "close, pick or skip the open reward window", gated: true, delegate(IReadOnlyList<string> args, ConsoleToggleState _, IReadOnlyList<string> _)
		{
			switch (args.Count)
			{
			case 0:
				return Command(new HarnessCommand(HarnessCommandKind.DismissOffers, null));
			case 1:
			{
				if (args[0] == "skip")
				{
					return Command(new HarnessCommand(HarnessCommandKind.DismissOffers, null, default(CameraPose), Enabled: false, null, null, null, 0, null, default(LoadOverrides), null, null, null, null, null, Skip: true));
				}
				if (Int(args[0], 0, int.MaxValue, out var parsed))
				{
					int? offer = parsed;
					return Command(new HarnessCommand(HarnessCommandKind.DismissOffers, null, default(CameraPose), Enabled: false, null, null, null, 0, null, default(LoadOverrides), null, null, null, null, offer));
				}
				break;
			}
			}
			return NoMatch();
		}));
		consoleCommandRegistry.Add(new ConsoleVerb("run.interact", "activate the nearest interactable, or one type", gated: true, delegate(IReadOnlyList<string> args, ConsoleToggleState _, IReadOnlyList<string> _)
		{
			if (args.Count > 1 || (args.Count != 0 && args[0].Length <= 0))
			{
				return NoMatch();
			}
			InteractArgs interact = new InteractArgs
			{
				Type = ((args.Count == 1) ? args[0] : null)
			};
			return Command(new HarnessCommand(HarnessCommandKind.Interact, null, default(CameraPose), Enabled: false, null, null, null, 0, null, default(LoadOverrides), null, null, null, null, null, Skip: false, interact));
		}));
		consoleCommandRegistry.Add(new ConsoleVerb("run.press_death_confirm", "press the death screen's confirm", gated: true, (IReadOnlyList<string> _, ConsoleToggleState _, IReadOnlyList<string> _) => Command(HarnessCommandKind.PressDeathConfirm)));
		consoleCommandRegistry.Add(new ConsoleVerb("run.press_summary_restart", "press the run summary's restart", gated: true, (IReadOnlyList<string> _, ConsoleToggleState _, IReadOnlyList<string> _) => Command(HarnessCommandKind.PressSummaryRestart)));
		consoleCommandRegistry.Add(new ConsoleVerb("level.list", "list the saved custom-level files", gated: false, (IReadOnlyList<string> _, ConsoleToggleState _, IReadOnlyList<string> _) => Command(HarnessCommandKind.ListLevels)));
		consoleCommandRegistry.Add(new ConsoleVerb("level.load", "load a level by path or title, with map/stage/tier/seed/noseed", gated: true, (IReadOnlyList<string> args, ConsoleToggleState toggles, IReadOnlyList<string> levels) => LoadLevel(args, toggles, levels)).WithAliases("coc").WithRawError().WithCandidates(LevelTitles));
		consoleCommandRegistry.Add(new ConsoleVerb("level.save", "save the editor's level, optionally under a name", gated: true, (IReadOnlyList<string> args, ConsoleToggleState _, IReadOnlyList<string> _) => (args.Count > 1 || (args.Count != 0 && args[0].Trim().Length <= 0)) ? NoMatch() : Command(new HarnessCommand(HarnessCommandKind.SaveLevel, (args.Count == 1) ? args[0] : null))));
		consoleCommandRegistry.Add(new ConsoleVerb("level.new", "write a blank level and edit it, with map/stage/tier/size", gated: true, (IReadOnlyList<string> args, ConsoleToggleState _, IReadOnlyList<string> _) => NewLevel(args)));
		consoleCommandRegistry.Add(new ConsoleVerb("editor", "enter or leave editor mode", gated: true, delegate(IReadOnlyList<string> args, ConsoleToggleState toggles, IReadOnlyList<string> _)
		{
			bool? flag = Flag(args, toggles.Editor);
			if (!flag.HasValue)
			{
				return NoMatch();
			}
			bool valueOrDefault = flag == true;
			return Enabled(HarnessCommandKind.Editor, valueOrDefault);
		}).WithAliases("tfc"));
		consoleCommandRegistry.Add(new ConsoleVerb("camera.set", "hold the camera at a pose", gated: true, (IReadOnlyList<string> args, ConsoleToggleState _, IReadOnlyList<string> _) => (args.Count != 6 || !Floats(args, out values)) ? NoMatch() : Command(new HarnessCommand(HarnessCommandKind.Camera, null, new CameraPose(values[0], values[1], values[2], values[3], values[4], values[5])))));
		consoleCommandRegistry.Add(new ConsoleVerb("camera.clear", "return the camera to the game", gated: true, (IReadOnlyList<string> _, ConsoleToggleState _, IReadOnlyList<string> _) => Command(HarnessCommandKind.CameraClear)));
		consoleCommandRegistry.Add(new ConsoleVerb("ui.hud", "show or hide the stock HUD", gated: false, delegate(IReadOnlyList<string> args, ConsoleToggleState toggles, IReadOnlyList<string> _)
		{
			bool? flag = Flag(args, toggles.Hud);
			if (!flag.HasValue)
			{
				return NoMatch();
			}
			bool valueOrDefault = flag == true;
			return Enabled(HarnessCommandKind.Hud, valueOrDefault);
		}).WithAliases("tm"));
		consoleCommandRegistry.Add(new ConsoleVerb("ui.coordinates", "show or hide coordinates", gated: false, delegate(IReadOnlyList<string> args, ConsoleToggleState toggles, IReadOnlyList<string> _)
		{
			bool? flag = Flag(args, toggles.Coordinates);
			if (!flag.HasValue)
			{
				return NoMatch();
			}
			bool valueOrDefault = flag == true;
			return Enabled(HarnessCommandKind.Coordinates, valueOrDefault);
		}));
		string[] perfActions = PerfActions;
		foreach (string action in perfActions)
		{
			consoleCommandRegistry.Add(new ConsoleVerb("perf." + action, PerfHelp(action), gated: true, (IReadOnlyList<string> args, ConsoleToggleState _, IReadOnlyList<string> _) => Perf(action, args), PerfUsage(action)));
		}
		consoleCommandRegistry.Add(new ConsoleVerb("time_scale", "hold MyTime.timeScale, or release it with no value", gated: true, (IReadOnlyList<string> args, ConsoleToggleState _, IReadOnlyList<string> _) => Perf("timescale", args), "usage: time_scale [value]"));
		consoleCommandRegistry.Add(new ConsoleVerb("debug.screenshot", "save the rendered frame as a PNG", gated: true, (IReadOnlyList<string> args, ConsoleToggleState _, IReadOnlyList<string> _) => (args.Count != 1 || args[0].Trim().Length <= 0) ? NoMatch() : Command(new HarnessCommand(HarnessCommandKind.Screenshot, args[0]))));
		consoleCommandRegistry.Add(new ConsoleVerb("debug.query_objects", "list loaded objects of a type with chosen fields", gated: true, delegate(IReadOnlyList<string> args, ConsoleToggleState _, IReadOnlyList<string> _)
		{
			if (args.Count < 1 || args[0].Length <= 0 || !args.Skip(1).All((string f) => f.Length > 0))
			{
				return NoMatch();
			}
			QueryArgs query = new QueryArgs
			{
				TypeName = args[0],
				Fields = args.Skip(1).ToArray()
			};
			return Command(new HarnessCommand(HarnessCommandKind.QueryObjects, null, default(CameraPose), Enabled: false, null, null, null, 0, query));
		}));
		consoleCommandRegistry.Add(new ConsoleVerb("debug.material_dump", "dump the materials under the named objects", gated: true, (IReadOnlyList<string> args, ConsoleToggleState _, IReadOnlyList<string> _) => (args.Count > 1 || (args.Count != 0 && args[0].Trim().Length <= 0)) ? NoMatch() : Command(new HarnessCommand(HarnessCommandKind.MaterialDump, (args.Count == 1) ? args[0] : null))));
		consoleCommandRegistry.Add(new ConsoleVerb("debug.shader_report", "list the shaders the game ships and uses", gated: true, (IReadOnlyList<string> _, ConsoleToggleState _, IReadOnlyList<string> _) => Command(HarnessCommandKind.ShaderReport)));
		consoleCommandRegistry.Add(new ConsoleVerb("debug.heartbeat", "start or stop the kill-floor heartbeat", gated: true, delegate(IReadOnlyList<string> args, ConsoleToggleState _, IReadOnlyList<string> _)
		{
			bool? flag = Flag(args, current: true);
			if (!flag.HasValue)
			{
				return NoMatch();
			}
			bool valueOrDefault = flag == true;
			return Enabled(HarnessCommandKind.Heartbeat, valueOrDefault);
		}));
		consoleCommandRegistry.Add(new ConsoleVerb("debug.cells", "start or stop the cell-change log", gated: true, delegate(IReadOnlyList<string> args, ConsoleToggleState _, IReadOnlyList<string> _)
		{
			bool? flag = Flag(args, current: true);
			if (!flag.HasValue)
			{
				return NoMatch();
			}
			bool valueOrDefault = flag == true;
			return Enabled(HarnessCommandKind.Cells, valueOrDefault);
		}));
		consoleCommandRegistry.Add(new ConsoleVerb("debug.ui_tree", "list the editor widgets, or the one at a pixel", gated: true, delegate(IReadOnlyList<string> args, ConsoleToggleState _, IReadOnlyList<string> _)
		{
			switch (args.Count)
			{
			case 0:
			{
				InputArgs input = new InputArgs
				{
					Action = "ui-tree"
				};
				return Command(new HarnessCommand(HarnessCommandKind.UiTree, null, default(CameraPose), Enabled: false, null, input));
			}
			case 2:
			{
				if (Float(args[0], out var parsed) && Float(args[1], out var parsed2))
				{
					InputArgs input = new InputArgs
					{
						Action = "ui-tree",
						X = parsed,
						Y = parsed2
					};
					return Command(new HarnessCommand(HarnessCommandKind.UiTree, null, default(CameraPose), Enabled: false, null, input));
				}
				break;
			}
			}
			return NoMatch();
		}));
		consoleCommandRegistry.Add(new ConsoleVerb("debug.click_widget", "click the named editor widget", gated: true, delegate(IReadOnlyList<string> args, ConsoleToggleState _, IReadOnlyList<string> _)
		{
			if (args.Count != 1 || args[0].Length <= 0)
			{
				return NoMatch();
			}
			InputArgs input = new InputArgs
			{
				Action = "click-widget",
				Text = args[0]
			};
			return Command(new HarnessCommand(HarnessCommandKind.ClickWidget, null, default(CameraPose), Enabled: false, null, input));
		}));
		consoleCommandRegistry.Add(new ConsoleVerb("app.quit", "quit the game", gated: true, (IReadOnlyList<string> _, ConsoleToggleState _, IReadOnlyList<string> _) => Command(HarnessCommandKind.Quit)).WithAliases("qqq"));
		consoleCommandRegistry.Add(new ConsoleVerb("music.play", "resume paused music, or play track n", gated: false, (IReadOnlyList<string> args, ConsoleToggleState _, IReadOnlyList<string> _) => (args.Count != 0) ? MusicTrack(args) : MusicTransport(args, "play"), "usage: music.play [n]"));
		consoleCommandRegistry.Add(new ConsoleVerb("music.pause", "pause the current music", gated: false, (IReadOnlyList<string> args, ConsoleToggleState _, IReadOnlyList<string> _) => MusicTransport(args, "pause")));
		consoleCommandRegistry.Add(new ConsoleVerb("music.next", "go to the next track", gated: false, (IReadOnlyList<string> args, ConsoleToggleState _, IReadOnlyList<string> _) => MusicTransport(args, "next")));
		consoleCommandRegistry.Add(new ConsoleVerb("music.prev", "go to the previous track", gated: false, (IReadOnlyList<string> args, ConsoleToggleState _, IReadOnlyList<string> _) => MusicTransport(args, "prev")));
		consoleCommandRegistry.Add(new ConsoleVerb("music.track", "jump to track n", gated: false, (IReadOnlyList<string> args, ConsoleToggleState _, IReadOnlyList<string> _) => MusicTrack(args), "usage: music.track n"));
		consoleCommandRegistry.Add(new ConsoleVerb("music.list", "list the tracks, marking the current one", gated: false, (IReadOnlyList<string> args, ConsoleToggleState _, IReadOnlyList<string> _) => MusicTransport(args, "list")));
		consoleCommandRegistry.Add(new ConsoleVerb("music.now", "show the current track", gated: false, (IReadOnlyList<string> args, ConsoleToggleState _, IReadOnlyList<string> _) => MusicTransport(args, "now")));
		return consoleCommandRegistry;
	}

	private static ConsoleBindResult MusicTrack(IReadOnlyList<string> args)
	{
		if (args.Count != 1 || !Int(args[0], 1, int.MaxValue, out var parsed))
		{
			return NoMatch();
		}
		MusicArgs music = new MusicArgs
		{
			Action = "track",
			Track = parsed
		};
		return Command(new HarnessCommand(HarnessCommandKind.Music, null, default(CameraPose), Enabled: false, null, null, null, 0, null, default(LoadOverrides), null, null, null, null, null, Skip: false, null, null, null, music));
	}

	private static ConsoleBindResult MusicTransport(IReadOnlyList<string> args, string action)
	{
		if (args.Count != 0)
		{
			return NoMatch();
		}
		MusicArgs music = new MusicArgs
		{
			Action = action
		};
		return Command(new HarnessCommand(HarnessCommandKind.Music, null, default(CameraPose), Enabled: false, null, null, null, 0, null, default(LoadOverrides), null, null, null, null, null, Skip: false, null, null, null, music));
	}

	private static ConsoleBindResult NoCommand()
	{
		return new ConsoleBindResult(null, "", null);
	}

	private static ConsoleBindResult NoMatch()
	{
		return new ConsoleBindResult(null, null, "no match");
	}

	private static ConsoleBindResult Command(HarnessCommandKind kind)
	{
		return new ConsoleBindResult(new HarnessCommand(kind, null), null, null);
	}

	private static ConsoleBindResult Command(HarnessCommand command)
	{
		return new ConsoleBindResult(command, null, null);
	}

	private static ConsoleBindResult Enabled(HarnessCommandKind kind, bool enabled)
	{
		bool enabled2 = enabled;
		return new ConsoleBindResult(new HarnessCommand(kind, null, default(CameraPose), enabled2), null, null);
	}

	private static string PerfHelp(string action)
	{
		return action switch
		{
			"report" => "frame percentiles for the last window", 
			"status" => "the live profiler toggles", 
			"start" => "clear the window and start measuring", 
			"reset" => "restore every profiler setting", 
			"spawn" => "add enemies around the player", 
			"timescale" => "hold or release MyTime.timeScale", 
			"toggle" => "switch one tick or patch probe", 
			"vsync" => "lift or restore the vsync cap", 
			"render" => "hide or show enemy renderers", 
			"physics" => "freeze or unfreeze enemy rigidbodies", 
			"animation" => "stop or resume enemy animation", 
			"health" => "park the player's hit points", 
			"census" => "count components by type", 
			_ => "frame profiler", 
		};
	}

	private static string PerfUsage(string action)
	{
		switch (action)
		{
		case "toggle":
			return "usage: perf.toggle <target> <on|off>";
		case "render":
		case "vsync":
		case "animation":
		case "physics":
			return "usage: perf." + action + " <on|off>";
		case "spawn":
			return $"usage: perf.spawn <1-{300}>";
		case "timescale":
			return "usage: perf.timescale [value]";
		case "health":
			return "usage: perf.health [hp]";
		default:
			return "usage: perf." + action;
		}
	}

	private static ConsoleBindResult Perf(string action, IReadOnlyList<string> args)
	{
		switch (action)
		{
		case "spawn":
		{
			if (args.Count != 1 || !Int(args[0], 1, 300, out var parsed3))
			{
				return NoMatch();
			}
			PerfArgs perf = new PerfArgs
			{
				Action = action,
				Count = parsed3
			};
			return Command(new HarnessCommand(HarnessCommandKind.Perf, null, default(CameraPose), Enabled: false, null, null, null, 0, null, default(LoadOverrides), null, null, null, perf));
		}
		case "timescale":
		{
			float parsed = 0f;
			if (args.Count > 1 || (args.Count != 0 && (!Float(args[0], out parsed) || !PerfLimits.ValidTimeScale(parsed))))
			{
				return NoMatch();
			}
			PerfArgs perf = new PerfArgs
			{
				Action = action,
				Value = ((args.Count == 1) ? new float?(parsed) : ((float?)null))
			};
			return Command(new HarnessCommand(HarnessCommandKind.Perf, null, default(CameraPose), Enabled: false, null, null, null, 0, null, default(LoadOverrides), null, null, null, perf));
		}
		case "toggle":
			if (args.Count == 2 && args[0].Length > 0)
			{
				bool? flag = OnOff(args[1]);
				if (flag.HasValue)
				{
					bool valueOrDefault = flag == true;
					PerfArgs perf = new PerfArgs
					{
						Action = action,
						Target = args[0],
						Enabled = valueOrDefault
					};
					return Command(new HarnessCommand(HarnessCommandKind.Perf, null, default(CameraPose), Enabled: false, null, null, null, 0, null, default(LoadOverrides), null, null, null, perf));
				}
			}
			return NoMatch();
		case "vsync":
		case "animation":
		case "render":
		case "physics":
			if (args.Count == 1)
			{
				bool? flag = OnOff(args[0]);
				if (flag.HasValue)
				{
					bool valueOrDefault2 = flag == true;
					PerfArgs perf = new PerfArgs
					{
						Action = action,
						Enabled = valueOrDefault2
					};
					return Command(new HarnessCommand(HarnessCommandKind.Perf, null, default(CameraPose), Enabled: false, null, null, null, 0, null, default(LoadOverrides), null, null, null, perf));
				}
			}
			return NoMatch();
		case "health":
		{
			int parsed2 = 0;
			if (args.Count > 1 || (args.Count != 0 && !Int(args[0], 1, 100000000, out parsed2)))
			{
				return NoMatch();
			}
			PerfArgs perf = new PerfArgs
			{
				Action = action,
				Hp = ((args.Count == 1) ? new int?(parsed2) : ((int?)null))
			};
			return Command(new HarnessCommand(HarnessCommandKind.Perf, null, default(CameraPose), Enabled: false, null, null, null, 0, null, default(LoadOverrides), null, null, null, perf));
		}
		default:
		{
			if (args.Count != 0)
			{
				return NoMatch();
			}
			PerfArgs perf = new PerfArgs
			{
				Action = action
			};
			return Command(new HarnessCommand(HarnessCommandKind.Perf, null, default(CameraPose), Enabled: false, null, null, null, 0, null, default(LoadOverrides), null, null, null, perf));
		}
		}
	}

	private static ConsoleBindResult LoadLevel(IReadOnlyList<string> args, ConsoleToggleState toggles, IReadOnlyList<string> levels)
	{
		if (args.Count == 0 || string.IsNullOrWhiteSpace(args[0]))
		{
			return NoMatch();
		}
		string error;
		string text = ResolveLevelTarget(args[0], levels, out error);
		if (text == null)
		{
			return new ConsoleBindResult(null, null, error);
		}
		OptionSet optionSet = ParseOverrides(args.Skip(1).ToArray(), allowSize: false);
		if (optionSet.Bad)
		{
			return NoMatch();
		}
		bool flag = !text.Contains('/') && !text.Contains('\\');
		bool flag2 = optionSet.Map.HasValue || optionSet.Stage.HasValue || optionSet.Tier.HasValue || optionSet.Seed.HasValue || optionSet.Unseeded;
		if (toggles.Editor && flag && !flag2)
		{
			return Command(new HarnessCommand(HarnessCommandKind.EditorLoad, text));
		}
		LoadOverrides overrides = new LoadOverrides(optionSet.Map, optionSet.Stage, optionSet.Tier, optionSet.Seed, null, optionSet.Unseeded);
		return Command(new HarnessCommand(HarnessCommandKind.LoadLevel, text, default(CameraPose), Enabled: false, null, null, null, 0, null, overrides));
	}

	private static ConsoleBindResult NewLevel(IReadOnlyList<string> args)
	{
		string text = ((args.Count > 0 && args[0].Trim().Length > 0) ? args[0] : null);
		OptionSet optionSet = ParseOverrides(args.Skip((text != null) ? 1 : 0).ToArray(), allowSize: true);
		if (!optionSet.Bad)
		{
			NewLevelArgs? newLevel = new NewLevelArgs(optionSet.Map ?? 1, optionSet.Stage.GetValueOrDefault(), optionSet.Tier.GetValueOrDefault(), optionSet.Size ?? 7);
			return Command(new HarnessCommand(HarnessCommandKind.NewLevel, text, default(CameraPose), Enabled: false, null, null, null, 0, null, default(LoadOverrides), null, null, null, null, null, Skip: false, null, newLevel));
		}
		return NoMatch();
	}

	private static OptionSet ParseOverrides(IReadOnlyList<string> args, bool allowSize)
	{
		int? map = null;
		int? stage = null;
		int? tier = null;
		int? seed = null;
		int? size = null;
		bool unseeded = false;
		for (int i = 0; i < args.Count; i++)
		{
			bool flag = i == args.Count - 1;
			if (args[i] == "noseed" && flag)
			{
				unseeded = true;
				continue;
			}
			if (flag)
			{
				return OptionSet.Rejected;
			}
			bool flag2 = true;
			switch (args[i])
			{
			case "map":
			{
				flag2 = Int(args[i + 1], 0, int.MaxValue, out var parsed4) && ValidMap(parsed4) && Set(parsed4, delegate(int v)
				{
					map = v;
				});
				break;
			}
			case "stage":
			{
				flag2 = Int(args[i + 1], 0, int.MaxValue, out var parsed3) && Set(parsed3, delegate(int v)
				{
					stage = v;
				});
				break;
			}
			case "tier":
			{
				flag2 = Int(args[i + 1], 0, int.MaxValue, out var parsed5) && Set(parsed5, delegate(int v)
				{
					tier = v;
				});
				break;
			}
			case "seed":
			{
				flag2 = Int(args[i + 1], int.MinValue, int.MaxValue, out var parsed2) && Set(parsed2, delegate(int v)
				{
					seed = v;
				});
				break;
			}
			case "size":
				if (allowSize)
				{
					flag2 = Int(args[i + 1], 3, int.MaxValue, out var parsed) && Set(parsed, delegate(int v)
					{
						size = v;
					});
					break;
				}
				goto default;
			default:
				flag2 = false;
				break;
			}
			if (!flag2)
			{
				return OptionSet.Rejected;
			}
			i++;
		}
		return new OptionSet(map, stage, tier, seed, size, unseeded, Bad: false);
	}

	private static bool Set<T>(T value, Action<T> assign)
	{
		assign(value);
		return true;
	}

	private static bool ValidMap(int value)
	{
		return Enum.GetValues<EMap>().Any((EMap m) => m != EMap.None && m == (EMap)value);
	}

	private static string ResolveLevelTarget(string target, IReadOnlyList<string> levels, out string error)
	{
		error = null;
		bool flag = target.EndsWith(".json", StringComparison.OrdinalIgnoreCase);
		if (target.Contains('/') || target.Contains('\\'))
		{
			return target;
		}
		string fileName = (flag ? target : (target + ".mblevel.json"));
		if (levels == null || levels.Count == 0)
		{
			return fileName;
		}
		string wanted = Normalize(target);
		List<string> list = levels.Where((string l) => Normalize(LevelStem(l)) == wanted).ToList();
		if (list.Count == 1)
		{
			return list[0];
		}
		if (list.Count > 1)
		{
			error = "'" + target + "' is ambiguous: " + string.Join(", ", list);
			return null;
		}
		string text = levels.FirstOrDefault((string l) => string.Equals(l, fileName, StringComparison.OrdinalIgnoreCase));
		if (text != null)
		{
			return text;
		}
		error = "no level named '" + target + "'; run level.list";
		return null;
	}

	private static IEnumerable<string> LevelTitles(int argumentIndex, IReadOnlyList<string> levels)
	{
		if (argumentIndex != 0 || levels == null)
		{
			return Enumerable.Empty<string>();
		}
		return levels.Select(LevelStem);
	}

	private static string Normalize(string value)
	{
		return new string((value ?? "").Where(char.IsLetterOrDigit).Select(char.ToLowerInvariant).ToArray());
	}

	private static string LevelStem(string fileName)
	{
		string fileNameWithoutExtension = Path.GetFileNameWithoutExtension(fileName);
		if (!fileNameWithoutExtension.EndsWith(".mblevel", StringComparison.OrdinalIgnoreCase))
		{
			return fileNameWithoutExtension;
		}
		return fileNameWithoutExtension.Substring(0, fileNameWithoutExtension.Length - ".mblevel".Length);
	}

	private static bool? Flag(IReadOnlyList<string> args, bool current)
	{
		if (args.Count != 1)
		{
			if (args.Count != 0)
			{
				return null;
			}
			return !current;
		}
		return OnOff(args[0]);
	}

	private static bool? OnOff(string value)
	{
		if (!string.Equals(value, "on", StringComparison.OrdinalIgnoreCase))
		{
			if (!string.Equals(value, "off", StringComparison.OrdinalIgnoreCase))
			{
				return null;
			}
			return false;
		}
		return true;
	}

	private static bool? Nonlethal(IReadOnlyList<string> args)
	{
		switch (args.Count)
		{
		case 1:
			return true;
		case 2:
			if (string.Equals(args[1], "lethal", StringComparison.OrdinalIgnoreCase))
			{
				return false;
			}
			if (string.Equals(args[1], "nonlethal", StringComparison.OrdinalIgnoreCase))
			{
				return true;
			}
			return OnOff(args[1]);
		default:
			return null;
		}
	}

	private static bool Int(string value, int min, int max, out int parsed)
	{
		if (int.TryParse(value, NumberStyles.Integer, CultureInfo.InvariantCulture, out parsed) && parsed >= min)
		{
			return parsed <= max;
		}
		return false;
	}

	private static bool Ints(IReadOnlyList<string> args, out int[] values)
	{
		values = null;
		if (args.Count != 2)
		{
			return false;
		}
		values = new int[2];
		if (Int(args[0], int.MinValue, int.MaxValue, out values[0]))
		{
			return Int(args[1], int.MinValue, int.MaxValue, out values[1]);
		}
		return false;
	}

	private static bool Float(string va