using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using System.Text.RegularExpressions;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using ConsoleTables;
using Dawn;
using GameNetcodeStuff;
using HarmonyLib;
using LethalLevelLoader;
using LethalLib.Modules;
using LethalQuantities;
using LethalQuantities.Json;
using LethalQuantities.Objects;
using LethalRegeneration.config;
using Microsoft.CodeAnalysis;
using MrovLib;
using MrovLib.Compatibility;
using MrovLib.ContentType;
using MrovLib.Events;
using On;
using StoreRotationConfig.Api;
using TerminalFormatter.Compatibility;
using TerminalFormatter.Nodes;
using TerminalFormatter.Patches;
using UnityEngine;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: IgnoresAccessChecksTo("AmazingAssets.TerrainToMesh")]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp-firstpass")]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp")]
[assembly: IgnoresAccessChecksTo("ClientNetworkTransform")]
[assembly: IgnoresAccessChecksTo("com.olegknyazev.softmask")]
[assembly: IgnoresAccessChecksTo("DissonanceVoip")]
[assembly: IgnoresAccessChecksTo("EasyTextEffects")]
[assembly: IgnoresAccessChecksTo("Facepunch Transport for Netcode for GameObjects")]
[assembly: IgnoresAccessChecksTo("Facepunch.Steamworks.Win64")]
[assembly: IgnoresAccessChecksTo("LethalLevelLoader")]
[assembly: IgnoresAccessChecksTo("MrovLib")]
[assembly: IgnoresAccessChecksTo("Unity.AI.Navigation")]
[assembly: IgnoresAccessChecksTo("Unity.Animation.Rigging")]
[assembly: IgnoresAccessChecksTo("Unity.Animation.Rigging.DocCodeExamples")]
[assembly: IgnoresAccessChecksTo("Unity.Burst")]
[assembly: IgnoresAccessChecksTo("Unity.Burst.Unsafe")]
[assembly: IgnoresAccessChecksTo("Unity.Collections")]
[assembly: IgnoresAccessChecksTo("Unity.Collections.LowLevel.ILSupport")]
[assembly: IgnoresAccessChecksTo("Unity.InputSystem")]
[assembly: IgnoresAccessChecksTo("Unity.InputSystem.ForUI")]
[assembly: IgnoresAccessChecksTo("Unity.Jobs")]
[assembly: IgnoresAccessChecksTo("Unity.Mathematics")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.Common")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.MetricTypes")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.NetStats")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.NetStatsMonitor.Component")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.NetStatsMonitor.Configuration")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.NetStatsMonitor.Implementation")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.NetStatsReporting")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.NetworkProfiler.Runtime")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.NetworkSolutionInterface")]
[assembly: IgnoresAccessChecksTo("Unity.Netcode.Components")]
[assembly: IgnoresAccessChecksTo("Unity.Netcode.Runtime")]
[assembly: IgnoresAccessChecksTo("Unity.Networking.Transport")]
[assembly: IgnoresAccessChecksTo("Unity.ProBuilder.Csg")]
[assembly: IgnoresAccessChecksTo("Unity.ProBuilder")]
[assembly: IgnoresAccessChecksTo("Unity.ProBuilder.KdTree")]
[assembly: IgnoresAccessChecksTo("Unity.ProBuilder.Poly2Tri")]
[assembly: IgnoresAccessChecksTo("Unity.ProBuilder.Stl")]
[assembly: IgnoresAccessChecksTo("Unity.Profiling.Core")]
[assembly: IgnoresAccessChecksTo("Unity.RenderPipelines.Core.Runtime")]
[assembly: IgnoresAccessChecksTo("Unity.RenderPipelines.Core.ShaderLibrary")]
[assembly: IgnoresAccessChecksTo("Unity.RenderPipelines.HighDefinition.Config.Runtime")]
[assembly: IgnoresAccessChecksTo("Unity.RenderPipelines.HighDefinition.Runtime")]
[assembly: IgnoresAccessChecksTo("Unity.RenderPipelines.ShaderGraph.ShaderGraphLibrary")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Authentication")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Analytics")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Components")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Configuration")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Device")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Environments")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Environments.Internal")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Internal")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Networking")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Registration")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Scheduler")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Telemetry")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Threading")]
[assembly: IgnoresAccessChecksTo("Unity.Services.QoS")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Relay")]
[assembly: IgnoresAccessChecksTo("Unity.TextMeshPro")]
[assembly: IgnoresAccessChecksTo("Unity.Timeline")]
[assembly: IgnoresAccessChecksTo("Unity.VisualEffectGraph.Runtime")]
[assembly: IgnoresAccessChecksTo("UnityEngine.ARModule")]
[assembly: IgnoresAccessChecksTo("UnityEngine.NVIDIAModule")]
[assembly: IgnoresAccessChecksTo("UnityEngine.UI")]
[assembly: AssemblyCompany("TerminalFormatter")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyDescription("A template for Lethal Company")]
[assembly: AssemblyFileVersion("0.2.34.0")]
[assembly: AssemblyInformationalVersion("0.2.34+f4cec4730e3e577b6cd83079308c497cc8c87a22")]
[assembly: AssemblyProduct("TerminalFormatter")]
[assembly: AssemblyTitle("TerminalFormatter")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

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

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace TerminalFormatter
{
	internal class DawnLibCompatibility : CompatibilityBase
	{
		public DawnLibCompatibility(string guid, string version = null)
			: base(guid, version)
		{
		}

		public void Init()
		{
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Expected O, but got Unknown
			Type type = AccessTools.TypeByName("Dawn.MoonRegistrationHandler");
			Plugin.harmony.Patch((MethodBase)AccessTools.Method(type, "DynamicMoonCatalogue", (Type[])null, (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(AccessTools.Method(typeof(DawnLibCompatibility), "InsertMoonCatalogueSkip", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null);
		}

		public (bool locked, bool hidden) GetLevelStatus(SelectableLevel level)
		{
			TerminalPurchaseResult val = SelectableLevelExtensions.GetDawnInfo(level).DawnPurchaseInfo.PurchasePredicate.CanPurchase();
			HiddenPurchaseResult val2 = (HiddenPurchaseResult)(object)((val is HiddenPurchaseResult) ? val : null);
			if (val2 == null)
			{
				if (!(val is FailedPurchaseResult))
				{
					if (val is SuccessPurchaseResult)
					{
						return (false, false);
					}
					return (false, false);
				}
				return (true, false);
			}
			return (val2.IsFailure, true);
		}

		public static IEnumerable<CodeInstruction> InsertMoonCatalogueSkip(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Expected O, but got Unknown
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Expected O, but got Unknown
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Expected O, but got Unknown
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Expected O, but got Unknown
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Expected O, but got Unknown
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Expected O, but got Unknown
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Expected O, but got Unknown
			CodeMatcher val = new CodeMatcher(instructions, (ILGenerator)null);
			val.Start().Insert((CodeInstruction[])(object)new CodeInstruction[6]
			{
				new CodeInstruction(OpCodes.Ldarg_0, (object)null),
				new CodeInstruction(OpCodes.Ldarg_1, (object)null),
				new CodeInstruction(OpCodes.Ldarg_2, (object)null),
				new CodeInstruction(OpCodes.Ldarg_3, (object)null),
				new CodeInstruction(OpCodes.Callvirt, (object)AccessTools.Method(typeof(orig_TextPostProcess), "Invoke", (Type[])null, (Type[])null)),
				new CodeInstruction(OpCodes.Ret, (object)null)
			});
			return val.InstructionEnumeration();
		}
	}
	internal class LategameUpgradesCompatibility : CompatibilityBase
	{
		internal static Assembly LGUAssembly;

		public LategameUpgradesCompatibility(string guid, string version = null)
			: base(guid, version)
		{
			if (((CompatibilityBase)this).IsModPresent)
			{
				Init();
			}
		}

		public static void Init()
		{
			LGUAssembly = ((object)Chainloader.PluginInfos["com.malco.lethalcompany.moreshipupgrades"].Instance).GetType().Assembly;
		}

		internal static int GetMoonPrice(int price)
		{
			string text = "MoreShipUpgrades.UpgradeComponents.TierUpgrades.EfficientEngines";
			Type type = Plugin.LGUCompat.GetModAssembly.GetType(text ?? "");
			if (type == null)
			{
				((Logger)Plugin.debugLogger).LogWarning("Could not find " + text + " type");
				return price;
			}
			MethodInfo method = type.GetMethod("GetDiscountedMoonPrice", BindingFlags.Static | BindingFlags.Public);
			if (method == null)
			{
				((Logger)Plugin.debugLogger).LogWarning("Could not find GetDiscountedMoonPrice method in EfficientEngines");
				return price;
			}
			return (int)method.Invoke(null, new object[1] { price });
		}
	}
	internal class LLLCompatibility : CompatibilityBase
	{
		public LLLCompatibility(string guid, string version = null)
			: base(guid, version)
		{
		}

		[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
		public void Init()
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Expected O, but got Unknown
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Expected O, but got Unknown
			if (((CompatibilityBase)this).IsModPresent)
			{
				Plugin.harmony.Patch((MethodBase)AccessTools.Method(typeof(Patches), "TerminalLoadNewNode_Postfix", (Type[])null, (Type[])null), new HarmonyMethod(typeof(LLLCompatibility), "LLLLoadNodePatch", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				if (((CompatibilityBase)Plugin.DawnLibCompat).IsModPresent)
				{
					Plugin.harmony.Patch((MethodBase)AccessTools.Method(typeof(TerminalManager), "SwapRouteNodeToLockedNode", (Type[])null, (Type[])null), new HarmonyMethod(typeof(LLLCompatibility), "SwapRouteNodeToLockedNode", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				}
				GetLLLSettings();
			}
		}

		public static void GetLLLSettings()
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			if (Enum.TryParse<PreviewInfoType>(ConfigManager.LastUsedPreview.Value, out PreviewInfoType result))
			{
				Settings.levelPreviewInfoType = result;
			}
			if (Enum.TryParse<FilterInfoType>(ConfigManager.LastUsedFilter.Value, out FilterInfoType result2))
			{
				Settings.levelPreviewFilterType = result2;
			}
			if (Enum.TryParse<SortInfoType>(ConfigManager.LastUsedSort.Value, out SortInfoType result3))
			{
				Settings.levelPreviewSortType = result3;
			}
		}

		public static bool LLLLoadNodePatch(Terminal __0, ref TerminalNode __1)
		{
			if ((Object)(object)__1 == (Object)(object)Variables.LastReplacedNode)
			{
				return false;
			}
			return true;
		}

		public static string InvokeMoonOverrideInfoEvent(ExtendedLevel extendedLevel, PreviewInfoType infoType)
		{
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			Type typeFromHandle = typeof(TerminalManager);
			EventInfo @event = typeFromHandle.GetEvent("onBeforePreviewInfoTextAdded", BindingFlags.Static | BindingFlags.Public);
			FieldInfo field = typeFromHandle.GetField("onBeforePreviewInfoTextAdded", BindingFlags.Static | BindingFlags.NonPublic);
			if (field != null && field.GetValue(null) is Delegate @delegate)
			{
				object[] args = new object[2] { extendedLevel, infoType };
				Delegate[] invocationList = @delegate.GetInvocationList();
				int num = 0;
				if (num < invocationList.Length)
				{
					Delegate delegate2 = invocationList[num];
					object obj = delegate2.DynamicInvoke(args);
					return obj as string;
				}
			}
			return null;
		}

		public static bool SwapRouteNodeToLockedNode()
		{
			return false;
		}

		public static bool IsLevelLocked(SelectableLevel level)
		{
			return SharedMethods.IsMoonLockedLLL(level);
		}

		public static bool IsLevelHidden(SelectableLevel level)
		{
			return SharedMethods.IsMoonHiddenLLL(level);
		}
	}
	internal class LethalLibCompatibility
	{
		public static void Init()
		{
		}

		public static bool IsLLItemDisabled(Item item)
		{
			return Items.shopItems.Find((ShopItem x) => (Object)(object)x.item == (Object)(object)item)?.wasRemoved ?? false;
		}

		public static bool IsLLUpgradeDisabled(UnlockableItem unlockable)
		{
			return Unlockables.registeredUnlockables.Find((RegisteredUnlockable x) => x.unlockable == unlockable)?.disabled ?? false;
		}
	}
	internal class LethalQuantitiesCompatibility : CompatibilityBase
	{
		public LethalQuantitiesCompatibility(string guid, string version = null)
			: base(guid, version)
		{
			if (((CompatibilityBase)this).IsModPresent)
			{
				Init();
			}
		}

		public static void Init()
		{
		}

		public static string GetLevelRiskLevel(SelectableLevel level)
		{
			Type type = ((object)Plugin.INSTANCE).GetType();
			FieldInfo field = type.GetField("presets", BindingFlags.Instance | BindingFlags.NonPublic);
			Dictionary<Guid, LevelPreset> dictionary = (Dictionary<Guid, LevelPreset>)field.GetValue(Plugin.INSTANCE);
			LevelPreset value;
			return (dictionary.TryGetValue(SelectableLevelCache.getGuid(level), out value) ? value : null)?.riskLevel.value;
		}
	}
	internal class LethalRegenCompatibility
	{
		internal static bool IsUpgradeInStore;

		public static void Init()
		{
			IsUpgradeInStore = ConfigurationSync<Configuration>.Instance.HealingUpgradeEnabled;
		}

		public static int GetCost()
		{
			return ConfigurationSync<Configuration>.Instance.HealingUpgradePrice;
		}

		public static bool IsUpgradeBought()
		{
			return ConfigurationSync<Configuration>.Instance.HealingUpgradeUnlocked;
		}
	}
	internal class WeatherTweaksCompatibility
	{
		internal static string nspace = "WeatherTweaks";

		internal static MethodInfo GetPlanetCurrentWeather;

		public static void Init()
		{
			Assembly assembly = ((object)Chainloader.PluginInfos["WeatherTweaks"].Instance).GetType().Assembly;
			Type type = assembly.GetType(nspace + ".Variables");
			if (!(type != null))
			{
				return;
			}
			GetPlanetCurrentWeather = type.GetMethod("GetPlanetCurrentWeather", BindingFlags.Static | BindingFlags.Public);
			if (GetPlanetCurrentWeather != null)
			{
				((Logger)Plugin.debugLogger).LogInfo($"Method {GetPlanetCurrentWeather} found - BetaWeatherTweaks");
				return;
			}
			GetPlanetCurrentWeather = type.GetMethod("GetPlanetCurrentWeather", BindingFlags.Static | BindingFlags.NonPublic);
			if (GetPlanetCurrentWeather != null)
			{
				((Logger)Plugin.debugLogger).LogInfo($"Method {GetPlanetCurrentWeather} found");
			}
		}
	}
	public class ConfigManager
	{
		internal static ConfigFile configFile;

		public static ConfigManager Instance { get; private set; }

		public static ConfigEntry<LoggingType> LoggingLevels { get; private set; }

		public static ConfigEntry<bool> ShowDifficultyInAll { get; private set; }

		public static ConfigEntry<bool> DetailedScanPage { get; private set; }

		public static ConfigEntry<int> DivideShopPage { get; private set; }

		public static ConfigEntry<bool> UseShortenedWeathers { get; private set; }

		public static ConfigEntry<int> DifficultyStringLength { get; private set; }

		public static ConfigEntry<bool> AlwaysDisplayHiddenMoons { get; private set; }

		public static ConfigEntry<bool> ShowNumberedPlanetNames { get; private set; }

		public static ConfigEntry<bool> ShowDecorations { get; private set; }

		public static ConfigEntry<bool> ShowGroupDividerLines { get; private set; }

		public static ConfigEntry<bool> ShowHelpText { get; private set; }

		public static ConfigEntry<string> LastUsedPreview { get; private set; }

		public static ConfigEntry<string> LastUsedFilter { get; private set; }

		public static ConfigEntry<string> LastUsedSort { get; private set; }

		public static ConfigEntry<int> LinesToScroll { get; private set; }

		public static void Init(ConfigFile config)
		{
			Instance = new ConfigManager(config);
		}

		private ConfigManager(ConfigFile config)
		{
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Expected O, but got Unknown
			configFile = config;
			LoggingLevels = configFile.Bind<LoggingType>("Debug", "Logging Levels", (LoggingType)0, "Set the logging level for the mod");
			ShowDifficultyInAll = configFile.Bind<bool>("General", "Show Difficulty in All", false, "Show difficulty in `preview all` setting");
			DetailedScanPage = configFile.Bind<bool>("General", "Detailed Scan Page", true, "Enable detailed scan page");
			UseShortenedWeathers = configFile.Bind<bool>("Moons", "Use Shortened Weathers", false, "Use shortened weathers in moons catalogue");
			DifficultyStringLength = configFile.Bind<int>("Moons", "Difficulty String Length", 4, new ConfigDescription("Multiplier for the amount of scrap spawned", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 8), Array.Empty<object>()));
			ShowNumberedPlanetNames = configFile.Bind<bool>("General", "Show Numbered Planet Names", false, "Show numbered planet names in terminal");
			AlwaysDisplayHiddenMoons = configFile.Bind<bool>("Moons", "Always Display Hidden Moons", false, "Always display hidden moons in moons catalogue");
			ShowDecorations = configFile.Bind<bool>("General", "Show Decorations", false, "Show decorations in terminal");
			ShowGroupDividerLines = configFile.Bind<bool>("General", "Show Group Divider Lines", false, "Show group divider lines in terminal");
			ShowHelpText = configFile.Bind<bool>("General", "Show Help Text", false, "Show help text in terminal");
			DivideShopPage = configFile.Bind<int>("Store", "Divide shop page into groups", 5, "Number of items per shop section (set to 0 to disable)");
			LastUsedPreview = configFile.Bind<string>("Last Used LLL Option", "Last Used Preview", "All", "Last used preview setting");
			LastUsedFilter = configFile.Bind<string>("Last Used LLL Option", "Last Used Filter", "None", "Last used filter setting");
			LastUsedSort = configFile.Bind<string>("Last Used LLL Option", "Last Used Sort", "Price", "Last used sort setting");
			LinesToScroll = configFile.Bind<int>("General", "Lines to Scroll", 15, "Number of lines to scroll per mouse wheel tick");
			LinesToScroll.SettingChanged += delegate
			{
				TerminalScrollMousePatch.CurrentText = "";
			};
		}
	}
	public class Header
	{
		public string CreateHeader(string text)
		{
			StringBuilder stringBuilder = new StringBuilder();
			int length = text.Length;
			stringBuilder.Append("  ╔");
			for (int i = 0; i < length + 2; i++)
			{
				stringBuilder.Append("═");
			}
			stringBuilder.Append("╗\n");
			stringBuilder.Append("╭─╢ ");
			stringBuilder.Append(text);
			stringBuilder.Append(" ╟&╮\n");
			stringBuilder.Append("│ ╚");
			for (int j = 0; j < length + 2; j++)
			{
				stringBuilder.Append("═");
			}
			stringBuilder.Append("╝^│\n");
			return stringBuilder.ToString();
		}

		public string CreateHeaderWithoutLines(string text, int padLeft = 2)
		{
			StringBuilder stringBuilder = new StringBuilder();
			int length = text.Length;
			for (int i = 0; i < padLeft; i++)
			{
				stringBuilder.Append(" ");
			}
			stringBuilder.Append("╔");
			for (int j = 0; j < length + 2; j++)
			{
				stringBuilder.Append("═");
			}
			stringBuilder.Append("╗\n");
			for (int k = 0; k < padLeft; k++)
			{
				stringBuilder.Append(" ");
			}
			stringBuilder.Append("║ ");
			stringBuilder.Append(text);
			stringBuilder.Append(" ║\n");
			for (int l = 0; l < padLeft; l++)
			{
				stringBuilder.Append(" ");
			}
			stringBuilder.Append("╚");
			for (int m = 0; m < length + 2; m++)
			{
				stringBuilder.Append("═");
			}
			stringBuilder.Append("╝\n");
			return stringBuilder.ToString();
		}

		internal string CreateNumberedHeader(string text, int padLeft = 2, Dictionary<int, string> replaceNumbers = null)
		{
			string text2 = CreateHeaderWithoutLines(text, padLeft);
			StringBuilder stringBuilder = new StringBuilder();
			string[] array = text2.Split('\n');
			for (int i = 0; i < array.Length; i++)
			{
				stringBuilder.Append("  ");
				stringBuilder.Append(array[i].Trim());
				stringBuilder.Append("  " + ((replaceNumbers != null && replaceNumbers.ContainsKey(i)) ? replaceNumbers[i] : ""));
				stringBuilder.Append("\n");
			}
			return stringBuilder.ToString();
		}
	}
	public class Logger : Logger
	{
		public Logger(string SourceName, LoggingType defaultLoggingType = 1)
			: base(SourceName, defaultLoggingType)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			((Logger)this).ModName = SourceName;
			((Logger)this).LogSource = Logger.CreateLogSource("TerminalFormatter");
			((Logger)this)._name = SourceName;
		}

		public override bool ShouldLog(LoggingType type)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			return ConfigManager.LoggingLevels.Value >= type;
		}
	}
	[BepInPlugin("TerminalFormatter", "TerminalFormatter", "0.2.34")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class Plugin : BaseUnityPlugin
	{
		internal static ManualLogSource logger;

		internal static Logger debugLogger = new Logger("Debug", (LoggingType)2);

		internal static Harmony harmony = new Harmony("TerminalFormatter");

		internal static TerminalNode LockedNode;

		internal static bool isLLibPresent = false;

		internal static bool isLRegenPresent = false;

		internal static bool isWTPresent = false;

		internal static CompatibilityBase LGUCompat;

		internal static CompatibilityBase LQCompat;

		internal static CompatibilityBase SRCCompat;

		internal static DawnLibCompatibility DawnLibCompat;

		internal static LLLCompatibility LLLCompat;

		internal static bool isLLLPresent => ((CompatibilityBase)LLLCompat).IsModPresent;

		internal static bool isLGUPresent => LGUCompat.IsModPresent;

		internal static bool isLQPresent => LQCompat.IsModPresent;

		internal static bool isSRCPresent => SRCCompat.IsModPresent;

		private void Awake()
		{
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Expected O, but got Unknown
			logger = ((BaseUnityPlugin)this).Logger;
			harmony.PatchAll();
			ConfigManager.Init(((BaseUnityPlugin)this).Config);
			EventManager.TerminalStart.AddListener((ParameterEvent<Terminal>)delegate(Terminal terminal)
			{
				Variables.Terminal = terminal;
			});
			EventManager.MainMenuLoaded.AddListener((Event)delegate
			{
				MainMenuInit();
			});
			if (Chainloader.PluginInfos.ContainsKey("evaisa.lethallib"))
			{
				logger.LogWarning((object)"LethalLib found, setting up compatibility patches");
				isLLibPresent = true;
			}
			if (Chainloader.PluginInfos.ContainsKey("Toskan4134.LethalRegeneration"))
			{
				logger.LogWarning((object)"LethalRegeneration found, setting up compatibility patches");
				LethalRegenCompatibility.Init();
				isLRegenPresent = true;
			}
			LGUCompat = (CompatibilityBase)(object)new LategameUpgradesCompatibility("com.malco.lethalcompany.moreshipupgrades");
			LQCompat = (CompatibilityBase)(object)new LethalQuantitiesCompatibility("LethalQuantities");
			SRCCompat = (CompatibilityBase)(object)new StoreRotationConfigCompatibility("pacoito.StoreRotationConfig");
			if (Chainloader.PluginInfos.ContainsKey("WeatherTweaks"))
			{
				logger.LogWarning((object)"WeatherTweaks found, setting up compatibility patches");
				WeatherTweaksCompatibility.Init();
				isWTPresent = true;
			}
			new Route();
			new RouteAfter();
			new Scan();
			new Store();
			new Buy();
			new BuyAfter();
			new CannotAfford();
			new Bestiary();
			new Storage();
			LockedNode = ScriptableObject.CreateInstance<TerminalNode>();
			((Object)LockedNode).name = "RouteLocked";
			LockedNode.clearPreviousText = true;
			LockedNode.acceptAnything = true;
			LockedNode.displayText = "You cannot route to the selected moon. The route is locked.";
			LockedNode.terminalOptions = Array.Empty<CompatibleNoun>();
			((BaseUnityPlugin)this).Logger.LogInfo((object)"Plugin TerminalFormatter is loaded!");
		}

		private void MainMenuInit()
		{
			DawnLibCompat = new DawnLibCompatibility("com.github.teamxiaolan.dawnlib");
			if (((CompatibilityBase)DawnLibCompat).IsModPresent)
			{
				logger.LogWarning((object)"DawnLib found, setting up compatibility patches");
				DawnLibCompat.Init();
			}
			LLLCompat = new LLLCompatibility("imabatby.lethallevelloader");
			if (((CompatibilityBase)LLLCompat).IsModPresent)
			{
				LLLCompat.Init();
				new Moons();
				new RouteLocked();
				new Simulate();
			}
			else
			{
				new MoonsNoLLL();
			}
			LGUCompat = (CompatibilityBase)(object)new LategameUpgradesCompatibility("com.malco.lethalcompany.moreshipupgrades");
		}
	}
	internal class Settings
	{
		internal static List<TerminalFormatterNode> RegisteredNodes = new List<TerminalFormatterNode>();

		public static readonly int terminalWidth = 48;

		public static bool firstUse = true;

		internal static readonly int planetWeatherWidth = 18;

		internal static readonly int planetNameWidth = terminalWidth + 2 - planetWeatherWidth - 9;

		internal static readonly int itemNameWidth = terminalWidth - 9 - 10;

		internal static readonly int dividerLength = 17;

		internal static Dictionary<string, string> WeathersShortened = new Dictionary<string, string>
		{
			{ "None", "Non" },
			{ "DustClouds", "Dust" },
			{ "Foggy", "Fog" },
			{ "Rainy", "Rny" },
			{ "Flooded", "Fld" },
			{ "Stormy", "Strm" },
			{ "Eclipsed", "Eclps" }
		};

		internal static List<string> MoonsToIgnore = new List<string>(2) { "71 Gordion", "44 Liquidation" };

		internal static List<string> HiddenMoons = new List<string>(2) { "5 Embrion", "68 Artifice" };

		internal static List<string> MoonsOrderVanilla = new List<string>(9) { "Experimentation", "Assurance", "Vow", "March", "Offense", "Adamance", "Rend", "Dine", "Titan" };

		internal static readonly ManualLogSource logger = Plugin.logger;
	}
	public class SharedMethods
	{
		public static string GetWeather(SelectableLevel level)
		{
			string weather = SharedMethods.GetWeather(level);
			int num = Settings.planetWeatherWidth - 1;
			bool flag = false;
			if (Plugin.isLLLPresent)
			{
				flag = ShouldShowDifficulty(level);
			}
			if (flag)
			{
				num -= 7;
			}
			if (weather.Length >= num || ConfigManager.UseShortenedWeathers.Value)
			{
				CollectionExtensions.Do<KeyValuePair<string, string>>((IEnumerable<KeyValuePair<string, string>>)Settings.WeathersShortened, (Action<KeyValuePair<string, string>>)delegate(KeyValuePair<string, string> pair)
				{
					weather = Regex.Replace(weather, pair.Key, pair.Value);
					weather = weather.Replace(" ", "");
				});
			}
			return weather;
		}

		public static string GetNumberlessPlanetName(SelectableLevel level)
		{
			return SharedMethods.GetNumberlessPlanetName(level);
		}

		public static List<SelectableLevel> GetGameLevels()
		{
			return SharedMethods.GetGameLevels();
		}

		public static int GetPrice(int beforeDiscountPrice)
		{
			if (Plugin.isLGUPresent)
			{
				return LategameUpgradesCompatibility.GetMoonPrice(beforeDiscountPrice);
			}
			return beforeDiscountPrice;
		}

		public static bool ShouldShowDifficulty(SelectableLevel level)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Invalid comparison between Unknown and I4
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Invalid comparison between Unknown and I4
			if (!ConfigManager.ShowDifficultyInAll.Value || (int)Settings.levelPreviewInfoType != 4)
			{
				return (int)Settings.levelPreviewInfoType == 1;
			}
			return true;
		}

		public static string GetLevelRiskLevel(SelectableLevel level)
		{
			if (Plugin.LQCompat.IsModPresent)
			{
				string levelRiskLevel = LethalQuantitiesCompatibility.GetLevelRiskLevel(level);
				if (levelRiskLevel != null)
				{
					return levelRiskLevel;
				}
				return level.riskLevel;
			}
			return level.riskLevel;
		}
	}
	public abstract class TerminalFormatterNode
	{
		public string name;

		public string AdditionalInfo;

		public List<string> terminalNode;

		public ConfigEntry<bool> Enabled;

		public StringBuilder stringBuilder = new StringBuilder();

		public virtual bool IsNodeValid(TerminalNode node, Terminal terminal)
		{
			return true;
		}

		public abstract string GetNodeText(TerminalNode node, Terminal terminal);

		public TerminalFormatterNode(string name, List<string> terminalNode)
		{
			this.name = name;
			this.terminalNode = terminalNode;
			Enabled = ConfigManager.configFile.Bind<bool>("Nodes", name, true, "Enable node " + name);
			Settings.RegisteredNodes.Add(this);
			((Logger)Plugin.debugLogger).LogInfo("Registered node " + name);
		}
	}
	[HarmonyPatch(typeof(Terminal))]
	[HarmonyPatch(typeof(Terminal))]
	public class TerminalPatches
	{
		private static TerminalNode lastNode;

		[HarmonyPrefix]
		[HarmonyPatch(typeof(Terminal), "LoadNewNode")]
		[HarmonyPriority(500)]
		public static bool CheckIfLocked(Terminal __instance, TerminalNode node)
		{
			if ((Object)(object)node == (Object)null)
			{
				return true;
			}
			lastNode = node;
			if (!((CompatibilityBase)Plugin.LLL).IsModPresent && !((CompatibilityBase)Plugin.DawnLibCompat).IsModPresent)
			{
				return true;
			}
			if (!((Object)node).name.ToLower().Contains("route") && !node.buyRerouteToMoon.Equals(-2))
			{
				return true;
			}
			if (((Object)node).name == "RouteLocked")
			{
				((Logger)Plugin.debugLogger).LogDebug("Node is RouteLocked");
				return true;
			}
			Route val = ((IEnumerable<Route>)ContentManager.Routes).FirstOrDefault((Func<Route, bool>)((Route x) => (Object)(object)x.Nodes.Node == (Object)(object)node));
			if (val == null)
			{
				((Logger)Plugin.debugLogger).LogDebug("Level is null");
				return true;
			}
			if ((Object)(object)val.Level == (Object)null)
			{
				return true;
			}
			if (node.displayText.ToLower().Contains("route locked!") && ((CompatibilityBase)Plugin.DawnLibCompat).IsModPresent)
			{
				if (Plugin.DawnLibCompat.GetLevelStatus(val.Level).locked)
				{
					((Logger)Plugin.debugLogger).LogInfo("Node is locked by DawnLib!!");
					__instance.LoadNewNode(Plugin.LockedNode);
					return false;
				}
				return true;
			}
			if (SharedMethods.IsMoonLockedLLL(val.Level))
			{
				((Logger)Plugin.debugLogger).LogInfo("Node is locked!!");
				__instance.LoadNewNode(Plugin.LockedNode);
				return false;
			}
			return true;
		}

		[HarmonyPrefix]
		[HarmonyPatch("LoadNewNode")]
		[HarmonyPriority(0)]
		[HarmonyAfter(new string[] { "imabatby.lethallevelloader", "com.github.teamxiaolan.dawnlib" })]
		public static bool LoadNewTerminalFormatterNode(Terminal __instance, TerminalNode node)
		{
			__instance.modifyingText = true;
			((Selectable)__instance.screenText).interactable = true;
			string text = null;
			Variables.LastReplacedNode = null;
			List<TerminalFormatterNode> list = Settings.RegisteredNodes.Where((TerminalFormatterNode formatterNode) => formatterNode.terminalNode.Any((string y) => ((Object)node).name.Contains(y))).ToList();
			if (list != null)
			{
				((Logger)Plugin.debugLogger).LogDebug($"Possible nodes count: {list.Count}");
				for (int i = 0; i < list.Count; i++)
				{
					TerminalFormatterNode terminalFormatterNode = list[i];
					if (terminalFormatterNode == null)
					{
						continue;
					}
					((Logger)Plugin.debugLogger).LogDebug("Checking if node " + terminalFormatterNode.name + " is valid...");
					if (!terminalFormatterNode.IsNodeValid(node, __instance))
					{
						((Logger)Plugin.debugLogger).LogDebug("Node " + terminalFormatterNode.name + " is not valid");
						continue;
					}
					if (!terminalFormatterNode.Enabled.Value)
					{
						((Logger)Plugin.debugLogger).LogDebug("Node " + terminalFormatterNode.name + " is not enabled");
						continue;
					}
					((Logger)Plugin.debugLogger).LogDebug("Using node " + terminalFormatterNode.name);
					text = terminalFormatterNode.GetNodeText(node, __instance);
					break;
				}
				if (text != null)
				{
					StringBuilder stringBuilder = new StringBuilder();
					if (Object.op_Implicit((Object)(object)__instance.displayingPersistentImage))
					{
						stringBuilder.Append("\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n");
					}
					stringBuilder.Append("\n\n");
					stringBuilder.Append(text);
					stringBuilder.Append("\n" + new string('-', Settings.dividerLength) + "\n");
					((Logger)Plugin.debugLogger).LogMessage("New display text:\n" + text);
					if (node.playSyncedClip != -1)
					{
						__instance.PlayTerminalAudioServerRpc(node.playSyncedClip);
					}
					else if ((Object)(object)node.playClip != (Object)null)
					{
						__instance.terminalAudio.PlayOneShot(node.playClip);
					}
					__instance.LoadTerminalImage(node);
					__instance.currentNode = node;
					__instance.screenText.text = stringBuilder.ToString();
					__instance.currentText = stringBuilder.ToString();
					__instance.textAdded = 0;
					Settings.firstUse = false;
					Variables.LastReplacedNode = node;
					return false;
				}
				return true;
			}
			return true;
		}
	}
	public class Variables
	{
		public static Terminal Terminal;

		public static TerminalNode LastReplacedNode;
	}
	public static class PluginInfo
	{
		public const string PLUGIN_GUID = "TerminalFormatter";

		public const string PLUGIN_NAME = "TerminalFormatter";

		public const string PLUGIN_VERSION = "0.2.34";
	}
}
namespace TerminalFormatter.Patches
{
	public static class String
	{
		public static string Sanitized(this string currentString)
		{
			return new string(currentString.SkipToLetters().RemoveWhitespace().ToLowerInvariant()
				.AsSpan());
		}

		public static string RemoveWhitespace(this string input)
		{
			return new string((from c in input.ToCharArray()
				where !char.IsWhiteSpace(c)
				select c).ToArray());
		}

		public static string SkipToLetters(this string input)
		{
			return new string(input.SkipWhile((char c) => !char.IsLetter(c)).ToArray());
		}

		public static string StripSpecialCharacters(this string input)
		{
			string text = string.Empty;
			for (int i = 0; i < input.Length; i++)
			{
				char c = input[i];
				if (char.IsLetterOrDigit(c) || c.ToString() == " ")
				{
					text += c;
				}
			}
			return text;
		}
	}
	[HarmonyPatch(typeof(PlayerControllerB), "ScrollMouse_performed", new Type[] { typeof(CallbackContext) })]
	internal class TerminalScrollMousePatch
	{
		private static float scrollAmount = 1f / 3f;

		public static string CurrentText { get; internal set; } = "";


		private static void ScrollMouse_performed(Scrollbar scrollbar, float scrollDirection)
		{
			if ((Object)(object)scrollbar == (Object)null)
			{
				((Logger)Plugin.debugLogger).LogWarning("scrollbar is null - too bad!");
				return;
			}
			if (string.CompareOrdinal(Variables.Terminal.currentText, CurrentText) != 0)
			{
				CurrentText = Variables.Terminal.currentText;
				int num = CurrentText.Count((char c) => c.Equals('\n')) + 1;
				scrollAmount = (float)ConfigManager.LinesToScroll.Value / (float)num;
			}
			scrollbar.value += scrollDirection * scrollAmount;
		}

		private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Expected O, but got Unknown
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Expected O, but got Unknown
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Expected O, but got Unknown
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Expected O, but got Unknown
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Expected O, but got Unknown
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Expected O, but got Unknown
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Expected O, but got Unknown
			return new CodeMatcher(instructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[2]
			{
				new CodeMatch((OpCode?)OpCodes.Ldarg_0, (object)null, (string)null),
				new CodeMatch((OpCode?)OpCodes.Ldfld, (object)AccessTools.Field(typeof(PlayerControllerB), "terminalScrollVertical"), (string)null)
			}).Insert((CodeInstruction[])(object)new CodeInstruction[5]
			{
				new CodeInstruction(OpCodes.Ldarg_0, (object)null),
				new CodeInstruction(OpCodes.Ldfld, (object)AccessTools.Field(typeof(PlayerControllerB), "terminalScrollVertical")),
				new CodeInstruction(OpCodes.Ldloc_0, (object)null),
				new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(TerminalScrollMousePatch), "ScrollMouse_performed", (Type[])null, (Type[])null)),
				new CodeInstruction(OpCodes.Ret, (object)null)
			}).InstructionEnumeration();
		}
	}
}
namespace TerminalFormatter.Nodes
{
	public class Bestiary : TerminalFormatterNode
	{
		public Bestiary()
			: base("Bestiary", new List<string>(1) { "0_Bestiary" })
		{
			AdditionalInfo = " Welcome to the Bestiary! \n Use INFO after creature name to learn more.";
		}

		public override string GetNodeText(TerminalNode node, Terminal terminal)
		{
			string value = new Header().CreateHeaderWithoutLines("BESTIARY");
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.Append(value);
			List<int> scannedCreatures = terminal.scannedEnemyIDs;
			if (ConfigManager.ShowHelpText.Value)
			{
				stringBuilder.Append((AdditionalInfo != null) ? ("\n" + AdditionalInfo + "\n\n") : "");
			}
			else
			{
				stringBuilder.Append("\n");
			}
			if (terminal.scannedEnemyIDs == null || terminal.scannedEnemyIDs.Count == 0)
			{
				stringBuilder.Append(" NO DATA COLLECTED");
				stringBuilder.Append(" \n");
				stringBuilder.Append(" Scan creatures to unlock their data.");
				return stringBuilder.ToString();
			}
			List<Creature> list = ContentManager.Creatures.Where((Creature x) => scannedCreatures.Contains(x.InfoNode.creatureFileID)).ToList();
			foreach (Creature item in list)
			{
				if (ConfigManager.ShowDecorations.Value)
				{
					stringBuilder.Append(" * ");
				}
				else
				{
					stringBuilder.Append(" ");
				}
				stringBuilder.Append(item.Name);
				stringBuilder.Append("\n");
			}
			return stringBuilder.ToString();
		}
	}
	public class Buy : TerminalFormatterNode
	{
		internal BuyableThing LastResolvedBuyable;

		public Buy()
			: base("Buy", new List<string>(5) { "buy", "BuyNode", "Buy", "Buy1", "Node1" })
		{
		}

		public BuyableThing ResolveNodeIntoBuyable(TerminalNode node)
		{
			((Logger)Plugin.debugLogger).LogDebug("Resolving node " + ((Object)node).name + " into Buyable");
			return (from x in ContentManager.Buyables
				where x.Nodes != null && (Object)(object)x.Nodes.Node != (Object)null
				where (Object)(object)x.Nodes.Node == (Object)(object)node || ((Object)x.Nodes.Node).name == ((Object)node).name
				select x).FirstOrDefault();
		}

		public override bool IsNodeValid(TerminalNode node, Terminal terminal)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			BuyableThing val = ResolveNodeIntoBuyable(node);
			if (val != null)
			{
				Plugin.logger.LogDebug((object)$"Resolved Item: {val.Name}({val.Type})");
			}
			return val != null;
		}

		public override string GetNodeText(TerminalNode node, Terminal terminal)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			ConsoleTable val = new ConsoleTable(new string[2] { "Title", "Things" });
			BuyableThing val2 = (LastResolvedBuyable = ResolveNodeIntoBuyable(node));
			string value = new Header().CreateHeaderWithoutLines("CONFIRM PURCHASE");
			StringBuilder stringBuilder = new StringBuilder();
			val.AddRow(new object[2] { "ITEM:", val2.Name });
			bool flag = typeof(BuyableItem) == ((object)val2).GetType();
			if (flag)
			{
				val.AddRow(new object[2]
				{
					"PRICE:",
					$"${val2.Price}"
				});
			}
			if (node.buyItemIndex >= 0 && terminal.itemSalesPercentages[node.buyItemIndex] != 100)
			{
				val.AddRow(new object[2]
				{
					"DISCOUNT:",
					$"{100 - terminal.itemSalesPercentages[node.buyItemIndex]}%"
				});
			}
			if (flag)
			{
				val.AddRow(new object[2]
				{
					"AMOUNT:",
					terminal.playerDefinedAmount.ToString()
				});
			}
			val.AddRow(new object[2] { "", "" });
			val.AddRow(new object[2]
			{
				"TOTAL: ",
				$"${terminal.totalCostOfItems}  (${terminal.groupCredits - terminal.totalCostOfItems} after purchase)"
			});
			stringBuilder.Append(value);
			stringBuilder.Append("\n\n");
			stringBuilder.Append("Please CONFIRM or DENY the purchase:");
			stringBuilder.Append("\n\n");
			stringBuilder.Append(val.ToStringCustomDecoration(false, false, false));
			return stringBuilder.ToString();
		}
	}
	public class BuyAfter : TerminalFormatterNode
	{
		internal BuyableThing LastResolvedBuyable;

		public BuyAfter()
			: base("BuyAfter", new List<string>(9) { "Node2", "node2", "confirm", "2", "buy", "BuyNode", "Buy", "Buy1", "Node1" })
		{
		}

		public BuyableThing ResolveNodeIntoBuyable(TerminalNode node)
		{
			((Logger)Plugin.debugLogger).LogDebug("Resolving node " + ((Object)node).name + " into Buyable");
			return (from x in ContentManager.Buyables
				where x.Nodes != null && (Object)(object)x.Nodes.NodeConfirm != (Object)null
				where (Object)(object)x.Nodes.NodeConfirm == (Object)(object)node || ((Object)x.Nodes.NodeConfirm).name == ((Object)node).name
				select x).FirstOrDefault();
		}

		public override bool IsNodeValid(TerminalNode node, Terminal terminal)
		{
			BuyableThing val = ResolveNodeIntoBuyable(node);
			return val != null;
		}

		public override string GetNodeText(TerminalNode node, Terminal terminal)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			ConsoleTable val = new ConsoleTable(new string[2] { "Title", "Things" });
			BuyableThing val2 = (LastResolvedBuyable = ResolveNodeIntoBuyable(node));
			string value = new Header().CreateHeaderWithoutLines("SUCCESS!");
			StringBuilder stringBuilder = new StringBuilder();
			val.AddRow(new object[2] { "ITEM:", val2.Name });
			bool flag = typeof(BuyableItem) == ((object)val2).GetType();
			int playerDefinedAmount = terminal.playerDefinedAmount;
			stringBuilder.Append(value);
			stringBuilder.Append("\n\n");
			stringBuilder.Append("Thank you for your purchase!\n");
			if (flag)
			{
				stringBuilder.Append(string.Format("Your {0} ({1} x {2}) {3} on {4} way!", (playerDefinedAmount == 1) ? "item" : "items", terminal.playerDefinedAmount, val2.Name, (playerDefinedAmount == 1) ? "is" : "are", (playerDefinedAmount == 1) ? "its" : "their"));
			}
			else
			{
				stringBuilder.Append("Your unlockable is now available!");
			}
			return stringBuilder.ToString();
		}
	}
	public class CannotAfford : TerminalFormatterNode
	{
		public CannotAfford()
			: base("CannotAfford", new List<string>(1) { "CannotAfford" })
		{
		}

		public override bool IsNodeValid(TerminalNode node, Terminal terminal)
		{
			node.clearPreviousText = true;
			return true;
		}

		public override string GetNodeText(TerminalNode node, Terminal terminal)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			ConsoleTable val = new ConsoleTable(new string[2] { "Title", "Things" });
			string value = new Header().CreateHeaderWithoutLines("COMPANY STORE");
			StringBuilder stringBuilder = new StringBuilder();
			val.AddRow(new object[2]
			{
				"YOUR CREDITS:",
				$"${terminal.groupCredits}"
			});
			val.AddRow(new object[2]
			{
				"TOTAL:",
				$"${terminal.totalCostOfItems}"
			});
			stringBuilder.Append(value);
			stringBuilder.Append("\n\n");
			stringBuilder.Append("You cannot afford this purchase!");
			stringBuilder.Append("\n\n");
			stringBuilder.Append(val.ToStringCustomDecoration(false, false, false));
			return stringBuilder.ToString();
		}
	}
	public class Moons : TerminalFormatterNode
	{
		public Moons()
			: base("Moons", new List<string>(4) { "MoonsCatalogue", "preview", "sort", "filter" })
		{
			AdditionalInfo = " Welcome to the exomoons catalogue! \n Use ROUTE to to set the autopilot route. \n Use INFO to learn about any moon.";
		}

		public override bool IsNodeValid(TerminalNode node, Terminal terminal)
		{
			return true;
		}

		public override string GetNodeText(TerminalNode node, Terminal terminal)
		{
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_013c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: Expected O, but got Unknown
			//IL_0161: Unknown result type (might be due to invalid IL or missing references)
			//IL_0168: Expected O, but got Unknown
			//IL_018e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0195: Expected O, but got Unknown
			//IL_01fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0201: Invalid comparison between Unknown and I4
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Invalid comparison between Unknown and I4
			//IL_0725: Unknown result type (might be due to invalid IL or missing references)
			//IL_072b: Invalid comparison between Unknown and I4
			//IL_0402: Unknown result type (might be due to invalid IL or missing references)
			//IL_0408: Invalid comparison between Unknown and I4
			//IL_03fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0400: Invalid comparison between Unknown and I4
			//IL_04b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ba: Invalid comparison between Unknown and I4
			//IL_04bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_04c2: Invalid comparison between Unknown and I4
			//IL_04f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_04f7: Invalid comparison between Unknown and I4
			//IL_04f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ff: Invalid comparison between Unknown and I4
			//IL_0531: Unknown result type (might be due to invalid IL or missing references)
			string text = "";
			bool value = ConfigManager.ShowDecorations.Value;
			object result2;
			object result3;
			if (((Object)node).name.Contains("preview") && Enum.TryParse(typeof(PreviewInfoType), TerminalManager.GetTerminalEventEnum(node.terminalEvent), out object result))
			{
				Settings.levelPreviewInfoType = (PreviewInfoType)result;
			}
			else if (((Object)node).name.Contains("sort") && Enum.TryParse(typeof(SortInfoType), TerminalManager.GetTerminalEventEnum(node.terminalEvent), out result2))
			{
				Settings.levelPreviewSortType = (SortInfoType)result2;
			}
			else if (((Object)node).name.Contains("filter") && Enum.TryParse(typeof(FilterInfoType), TerminalManager.GetTerminalEventEnum(node.terminalEvent), out result3))
			{
				Settings.levelPreviewFilterType = (FilterInfoType)result3;
				if ((int)Settings.levelPreviewFilterType == 2)
				{
					text = TerminalManager.GetTerminalEventString(node.terminalEvent);
					FieldInfo field = typeof(TerminalManager).GetField("currentTagFilter", BindingFlags.Static | BindingFlags.NonPublic);
					if (field != null)
					{
						field.SetValue(null, TerminalManager.GetTerminalEventString(node.terminalEvent));
					}
				}
			}
			MethodInfo method = typeof(TerminalManager).GetMethod("RefreshExtendedLevelGroups", BindingFlags.Static | BindingFlags.NonPublic);
			method.Invoke(null, null);
			MoonsCataloguePage val = (MoonsCataloguePage)SharedMethods.GetLLLMoonsCataloguePage();
			ConsoleTable val2 = new ConsoleTable(new string[3] { "", "", "" });
			ConsoleTable val3 = new ConsoleTable(new string[4] { "Name", "Price", "Weather", "Difficulty" });
			StringBuilder stringBuilder = new StringBuilder();
			string text2 = "MOONS CATALOGUE";
			Dictionary<int, string> replaceNumbers = new Dictionary<int, string>
			{
				{
					0,
					"PREVIEW: " + ((object)(PreviewInfoType)(ref Settings.levelPreviewInfoType)).ToString().ToUpper()
				},
				{
					1,
					"SORT: " + ((object)(SortInfoType)(ref Settings.levelPreviewSortType)).ToString().ToUpper()
				},
				{
					2,
					"FILTER: " + (((int)Settings.levelPreviewFilterType == 2) ? ("<color=#0be697>TAG</color> (" + text + ")") : ((object)(FilterInfoType)(ref Settings.levelPreviewFilterType)).ToString().ToUpper())
				}
			};
			string value2 = new Header().CreateNumberedHeader(text2, 2, replaceNumbers);
			ConfigManager.LastUsedFilter.Value = ((object)(FilterInfoType)(ref Settings.levelPreviewFilterType)).ToString();
			ConfigManager.LastUsedSort.Value = ((object)(SortInfoType)(ref Settings.levelPreviewSortType)).ToString();
			ConfigManager.LastUsedPreview.Value = ((object)(PreviewInfoType)(ref Settings.levelPreviewInfoType)).ToString();
			List<ExtendedLevel> list = new List<ExtendedLevel>();
			foreach (ExtendedLevelGroup extendedLevelGroup in val.ExtendedLevelGroups)
			{
				foreach (ExtendedLevel extendedLevels in extendedLevelGroup.extendedLevelsList)
				{
					bool flag = false;
					if (((CompatibilityBase)Plugin.DawnLibCompat).IsModPresent)
					{
						(bool locked, bool hidden) levelStatus = Plugin.DawnLibCompat.GetLevelStatus(extendedLevels.SelectableLevel);
						bool item = levelStatus.locked;
						bool item2 = levelStatus.hidden;
						flag = item || item2;
					}
					else
					{
						flag = SharedMethods.IsMoonHiddenLLL(extendedLevels.SelectableLevel) && !ConfigManager.AlwaysDisplayHiddenMoons.Value;
					}
					if (!flag && !list.Contains(extendedLevels))
					{
						list.Add(extendedLevels);
					}
				}
			}
			int num = 1;
			foreach (ExtendedLevel item3 in list)
			{
				string text3 = item3.NumberlessPlanetName;
				string value3 = Regex.Match(item3.SelectableLevel.PlanetName, "^\\d+").Value;
				if (ConfigManager.ShowNumberedPlanetNames.Value)
				{
					text3 = value3.PadLeft(3, '0') + " " + text3;
				}
				if (value)
				{
					text3 = "* " + text3;
				}
				bool flag2 = (ConfigManager.ShowDifficultyInAll.Value && (int)Settings.levelPreviewInfoType == 4) || (int)Settings.levelPreviewInfoType == 1;
				int num2 = (flag2 ? (Settings.planetNameWidth - 2) : Settings.planetNameWidth);
				text3 = ((text3.Length <= Settings.planetNameWidth) ? (text3 ?? "").PadRight(num2) : (text3.Substring(0, num2 - 3) + "..."));
				int num3 = (flag2 ? ConfigManager.DifficultyStringLength.Value : 0);
				string levelRiskLevel = SharedMethods.GetLevelRiskLevel(item3.SelectableLevel);
				string text4 = "";
				text4 = ((levelRiskLevel.Length <= num3) ? levelRiskLevel.PadRight(num3) : (levelRiskLevel.Substring(0, num3) ?? ""));
				string text5 = (((int)Settings.levelPreviewInfoType == 4 || (int)Settings.levelPreviewInfoType == 0) ? $"${SharedMethods.GetPrice(item3.RoutePrice)}" : "");
				bool flag3 = (int)Settings.levelPreviewInfoType == 4 || (int)Settings.levelPreviewInfoType == 2;
				string weather = SharedMethods.GetWeather(item3.SelectableLevel);
				string text6 = (flag3 ? weather.PadRight(Settings.planetWeatherWidth - 2) : "");
				string text7 = LLLCompatibility.InvokeMoonOverrideInfoEvent(item3, Settings.levelPreviewInfoType);
				if (text7 != null && text7 != string.Empty)
				{
					((Logger)Plugin.debugLogger).LogWarning("override preview info for " + item3.SelectableLevel.PlanetName + ":\n" + text7);
					Regex regex = new Regex("\\ {2,}");
					val2.AddRow(new object[3]
					{
						text3 + " " + regex.Replace(text7, "  "),
						"",
						""
					});
				}
				else
				{
					val2.AddRow(new object[3]
					{
						text3 + text4,
						text5 ?? "",
						(text6 ?? "").PadLeft(Settings.planetWeatherWidth)
					});
					val3.AddRow(new object[4] { text3, text5, text6, text4 });
				}
				if (Settings.moonsCatalogueSplitCount == 0)
				{
					continue;
				}
				if (num % Settings.moonsCatalogueSplitCount == 0)
				{
					num = 1;
					if (ConfigManager.ShowGroupDividerLines.Value)
					{
						val2.AddRow(new object[3]
						{
							"".PadRight(num2, '-'),
							"".PadRight(5, '-'),
							"".PadRight(Settings.planetWeatherWidth - 2, '-')
						});
					}
					else
					{
						val2.AddRow(new object[3] { "", "", "" });
					}
				}
				else
				{
					num++;
				}
			}
			string value4 = val2.ToStringCustomDecoration(false, false, false);
			stringBuilder.Append(value2);
			if (ConfigManager.ShowHelpText.Value)
			{
				stringBuilder.Append((AdditionalInfo != null) ? ("\n" + AdditionalInfo + "\n\n") : "");
			}
			stringBuilder.Append(((int)Settings.levelPreviewFilterType == 2) ? " If you enabled tag filtering by accident: \n Use the <color=#0be697>filter none</color> command to disable it.\n\n" : "");
			stringBuilder.Append($" The Company // Buying at {Mathf.RoundToInt(StartOfRound.Instance.companyBuyingRate * 100f)}% \n\n");
			stringBuilder.Append(value4);
			string text8 = stringBuilder.ToString().TrimEnd();
			((Logger)Plugin.debugLogger).LogDebug("All strings:\n" + val3.ToMinimalString());
			((Logger)Plugin.debugLogger).LogDebug("Final string:\n" + text8);
			return text8;
		}
	}
	public class MoonsNoLLL : TerminalFormatterNode
	{
		public MoonsNoLLL()
			: base("Moons", new List<string>(1) { "MoonsCatalogue" })
		{
			AdditionalInfo = " Welcome to the exomoons catalogue! \n Use ROUTE to set the autopilot. \n Use INFO to learn about a moon.";
		}

		public override bool IsNodeValid(TerminalNode node, Terminal terminal)
		{
			return true;
		}

		public override string GetNodeText(TerminalNode node, Terminal terminal)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Expected O, but got Unknown
			ConsoleTable val = new ConsoleTable(new string[3] { "Name", "Price", "Weather" });
			StringBuilder stringBuilder = new StringBuilder();
			string text = "MOONS CATALOGUE";
			string value = new Header().CreateNumberedHeader(text);
			bool value2 = ConfigManager.ShowDecorations.Value;
			List<Route> list = (from keyval in ContentManager.Routes.Where((Route keyval) => (Object)(object)keyval.Nodes.Node != (Object)null).ToList()
				orderby Settings.MoonsOrderVanilla.IndexOf(SharedMethods.GetNumberlessPlanetName(keyval.Level))
				select keyval).ToList();
			int num = 1;
			if (value2)
			{
				val.AddRow(new object[3] { "", "", "" });
			}
			foreach (Route item in list)
			{
				SelectableLevel level = item.Level;
				if (!ConfigManager.AlwaysDisplayHiddenMoons.Value)
				{
					if (Settings.HiddenMoons.Contains(level.PlanetName) || Settings.MoonsToIgnore.Contains(level.PlanetName))
					{
						continue;
					}
				}
				else if (Settings.MoonsToIgnore.Contains(level.PlanetName))
				{
					continue;
				}
				int price = SharedMethods.GetPrice(item.Nodes.Node.itemCost);
				string text2 = (ConfigManager.ShowNumberedPlanetNames.Value ? level.PlanetName : SharedMethods.GetNumberlessPlanetName(level));
				if (value2)
				{
					text2 = "* " + text2;
				}
				val.AddRow(new object[3]
				{
					text2,
					$"${price}",
					SharedMethods.GetWeather(level).PadRight(Settings.planetWeatherWidth)
				});
				if (num % 3 == 0)
				{
					num = 1;
					val.AddRow(new object[3] { "", "", "" });
				}
				else
				{
					num++;
				}
			}
			stringBuilder.Append(value);
			stringBuilder.Append((AdditionalInfo != null) ? (AdditionalInfo + "\n\n") : "");
			stringBuilder.Append($" The Company is buying at {Mathf.RoundToInt(StartOfRound.Instance.companyBuyingRate * 100f)}%. \n\n");
			stringBuilder.Append(val.ToStringCustomDecoration(true, false, false));
			return stringBuilder.ToString();
		}
	}
	public class Route : TerminalFormatterNode
	{
		public Route()
			: base("Route", new List<string>(2) { "route", "Route" })
		{
		}

		public Route ResolveNodeIntoRoute(TerminalNode node)
		{
			return ContentManager.Routes.Where((Route x) => (Object)(object)x.Nodes.Node == (Object)(object)node).FirstOrDefault();
		}

		public override bool IsNodeValid(TerminalNode node, Terminal terminal)
		{
			Route val = ResolveNodeIntoRoute(node);
			return val != null;
		}

		public override string GetNodeText(TerminalNode node, Terminal terminal)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			ConsoleTable val = new ConsoleTable(new string[2] { "Title", "Things" });
			Route val2 = ResolveNodeIntoRoute(node);
			string value = new Header().CreateHeaderWithoutLines("CONFIRM ROUTE");
			StringBuilder stringBuilder = new StringBuilder();
			SelectableLevel level = val2.Level;
			string weather = SharedMethods.GetWeather(level);
			int price = SharedMethods.GetPrice(node.itemCost);
			val.AddRow(new object[2]
			{
				"PLANET:",
				SharedMethods.GetNumberlessPlanetName(level)
			});
			val.AddRow(new object[2]
			{
				"PRICE:",
				$"${price} (${terminal.groupCredits - price} after routing)"
			});
			val.AddRow(new object[2]
			{
				"WEATHER:",
				(weather == "") ? "Clear" : weather
			});
			stringBuilder.Append(value);
			stringBuilder.Append("\n\n");
			stringBuilder.Append("Please CONFIRM or DENY routing the autopilot:");
			stringBuilder.Append("\n\n");
			stringBuilder.Append(val.ToStringCustomDecoration(false, false, false));
			return stringBuilder.ToString();
		}
	}
	public class RouteAfter : TerminalFormatterNode
	{
		public RouteAfter()
			: base("RouteAfter", new List<string>(2) { "route", "Route" })
		{
		}

		public Route ResolveNodeIntoRoute(TerminalNode node)
		{
			return ContentManager.Routes.Where((Route x) => (Object)(object)x.Nodes.NodeConfirm == (Object)(object)node).FirstOrDefault();
		}

		public override bool IsNodeValid(TerminalNode node, Terminal terminal)
		{
			Route val = ResolveNodeIntoRoute(node);
			return val != null;
		}

		public override string GetNodeText(TerminalNode node, Terminal terminal)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			ConsoleTable val = new ConsoleTable(new string[2] { "Title", "Things" });
			Route val2 = ResolveNodeIntoRoute(node);
			string value = new Header().CreateHeaderWithoutLines("SUCCESS!");
			StringBuilder stringBuilder = new StringBuilder();
			SelectableLevel level = val2.Level;
			string weather = SharedMethods.GetWeather(level);
			int price = SharedMethods.GetPrice(node.itemCost);
			val.AddRow(new object[2]
			{
				"PLANET:",
				SharedMethods.GetNumberlessPlanetName(level)
			});
			val.AddRow(new object[2]
			{
				"WEATHER:",
				(weather == "") ? "Clear" : weather
			});
			stringBuilder.Append(value);
			stringBuilder.Append("\n\n");
			stringBuilder.Append("Thank you for your purchase!\n");
			stringBuilder.Append("You're currently headed to:");
			stringBuilder.Append("\n\n");
			stringBuilder.Append(val.ToStringCustomDecoration(false, false, false));
			return stringBuilder.ToString();
		}
	}
	public class RouteLocked : TerminalFormatterNode
	{
		public RouteLocked()
			: base("RouteLocked", new List<string>(1) { "RouteLocked" })
		{
		}

		public override bool IsNodeValid(TerminalNode node, Terminal terminal)
		{
			return true;
		}

		public override string GetNodeText(TerminalNode node, Terminal terminal)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			ConsoleTable val = new ConsoleTable(new string[2] { "Title", "Things" });
			string value = new Header().CreateHeaderWithoutLines("ROUTE LOCKED");
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.Append(value);
			stringBuilder.Append("\n\n");
			stringBuilder.Append("You cannot currently route to the selected moon.");
			stringBuilder.Append("\n\n");
			stringBuilder.Append(val.ToStringCustomDecoration(false, false, false));
			return stringBuilder.ToString();
		}
	}
	public class Scan : TerminalFormatterNode
	{
		public Scan()
			: base("Scan", new List<string>(1) { "ScanInfo" })
		{
		}

		public override bool IsNodeValid(TerminalNode node, Terminal terminal)
		{
			return true;
		}

		public override string GetNodeText(TerminalNode node, Terminal terminal)
		{
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Expected O, but got Unknown
			StringBuilder stringBuilder = new StringBuilder();
			bool flag = StartOfRound.Instance.inShipPhase;
			if (StartOfRound.Instance.currentLevel.PlanetName.Contains("Gordion"))
			{
				flag = true;
			}
			int num = 0;
			int num2 = 0;
			List<GrabbableObject> source = ((!flag) ? (from item in Object.FindObjectsOfType<GrabbableObject>()
				where item.itemProperties.isScrap && !item.isInShipRoom && !item.isInElevator
				select item).ToList() : (from item in Object.FindObjectsOfType<GrabbableObject>()
				where item.itemProperties.isScrap && (item.isInElevator || item.isInShipRoom)
				select item).ToList());
			source = source.OrderBy((GrabbableObject x) => x.scrapValue).ToList();
			ConsoleTable val = new ConsoleTable(new string[3] { "Name", "Price", "Two-handed?" });
			foreach (GrabbableObject item in source)
			{
				val.AddRow(new object[3]
				{
					item.itemProperties.itemName.PadRight(Settings.itemNameWidth),
					$"${item.scrapValue}",
					item.itemProperties.twoHanded ? "●" : "○"
				});
				num++;
				num2 += item.scrapValue;
			}
			string text = "SCANNER";
			Dictionary<int, string> replaceNumbers = new Dictionary<int, string>
			{
				{
					0,
					"SCANNING " + (flag ? "SHIP" : "MOON")
				},
				{
					1,
					"ITEMS: " + num
				},
				{
					2,
					"VALUE: $" + num2
				}
			};
			string value = new Header().CreateNumberedHeader(text, 2, replaceNumbers);
			stringBuilder.Append(value);
			if (ConfigManager.DetailedScanPage.Value || flag)
			{
				stringBuilder.Append(val.ToStringCustomDecoration(true, false, false));
			}
			return stringBuilder.ToString();
		}
	}
	public class Simulate : TerminalFormatterNode
	{
		public Simulate()
			: base("Simulate", new List<string>(1) { "simulate" })
		{
		}

		public override bool IsNodeValid(TerminalNode node, Terminal terminal)
		{
			return true;
		}

		[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
		public override string GetNodeText(TerminalNode node, Terminal terminal)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Expected O, but got Unknown
			ConsoleTable val = new ConsoleTable(new string[3] { "Interior", "Weight", "Chance" });
			SelectableLevel theFuckingLevelFromSimulateNode = GetTheFuckingLevelFromSimulateNode(node);
			Plugin.logger.LogInfo((object)("Simulating for level: " + theFuckingLevelFromSimulateNode.PlanetName));
			Dictionary<int, string> replaceNumbers = new Dictionary<int, string> { 
			{
				1,
				"PLANET: " + SharedMethods.GetNumberlessPlanetName(theFuckingLevelFromSimulateNode)
			} };
			string value = new Header().CreateNumberedHeader("SIMULATING ARRIVAL", 2, replaceNumbers);
			PatchedContent.ExtendedLevelDictionary.TryGetValue(theFuckingLevelFromSimulateNode, out var value2);
			List<ExtendedDungeonFlowWithRarity> validExtendedDungeonFlows = DungeonManager.GetValidExtendedDungeonFlows(value2, false);
			Dictionary<string, int> dungeonFlowRarities = new Dictionary<string, int>();
			int totalRarityPool = 0;
			CollectionExtensions.Do<ExtendedDungeonFlowWithRarity>((IEnumerable<ExtendedDungeonFlowWithRarity>)validExtendedDungeonFlows, (Action<ExtendedDungeonFlowWithRarity>)delegate(ExtendedDungeonFlowWithRarity dungeonFlow)
			{
				totalRarityPool += dungeonFlow.rarity;
				dungeonFlowRarities.Add(dungeonFlow.extendedDungeonFlow.DungeonName, dungeonFlow.rarity);
			});
			dungeonFlowRarities = dungeonFlowRarities.OrderBy((KeyValuePair<string, int> o) => -o.Value).ToDictionary((KeyValuePair<string, int> k) => k.Key, (KeyValuePair<string, int> v) => v.Value);
			foreach (var (text2, num2) in dungeonFlowRarities)
			{
				val.AddRow(new object[3]
				{
					text2.PadRight(Settings.planetNameWidth),
					num2,
					(((float)num2 / (float)totalRarityPool * 100f).ToString("F2") + "%").PadLeft(4)
				});
			}
			val.AddRow(new object[3] { "", "", "" });
			val.AddRow(new object[3] { "", "", "" });
			val.AddRow(new object[3]
			{
				"",
				totalRarityPool.ToString().PadRight(6),
				"100%".ToString().PadLeft(4)
			});
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.Append(value);
			if (value2.NumberlessPlanetName == "March")
			{
				stringBuilder.AppendLine("\nData for March will always be innacurate\n");
			}
			stringBuilder.Append("\n");
			stringBuilder.Append(val.ToStringCustomDecoration(true, false, false));
			return stringBuilder.ToString();
		}

		public SelectableLevel GetTheFuckingLevelFromSimulateNode(TerminalNode node)
		{
			List<SelectableLevel> levels = LevelHelper.Levels;
			List<TerminalNode> list = (from n in ((IEnumerable<TerminalKeyword>)ContentManager.Verbs).FirstOrDefault((Func<TerminalKeyword, bool>)((TerminalKeyword verb) => ((Object)verb).name.ToLower() == "simulatekeyword")).compatibleNouns.ToList()
				select n.result).ToList();
			int index = list.IndexOf(node);
			return levels[index];
		}
	}
	public class Storage : TerminalFormatterNode
	{
		public Storage()
			: base("Storage", new List<string>(1) { "ItemsInStorage" })
		{
			AdditionalInfo = " Welcome to the Storage! \n Type item's name to retrieve it. \n To store items, use [X] while moving the object.";
		}

		public override string GetNodeText(TerminalNode node, Terminal terminal)
		{
			string value = new Header().CreateHeaderWithoutLines("STORAGE");
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.Append(value);
			if (ConfigManager.ShowHelpText.Value)
			{
				stringBuilder.Append((AdditionalInfo != null) ? ("\n" + AdditionalInfo + "\n\n") : "");
			}
			else
			{
				stringBuilder.Append("\n");
			}
			List<UnlockableItem> list = StartOfRound.Instance.unlockablesList.unlockables.Where((UnlockableItem unlockable) => unlockable.inStorage).ToList();
			if (list.Count == 0)
			{
				stringBuilder.Append("No items stored.\n");
				return stringBuilder.ToString();
			}
			foreach (UnlockableItem item in list)
			{
				if (ConfigManager.ShowDecorations.Value)
				{
					stringBuilder.Append(" * ");
				}
				else
				{
					stringBuilder.Append(" ");
				}
				stringBuilder.Append(item.unlockableName);
				stringBuilder.Append("\n");
			}
			return stringBuilder.ToString();
		}
	}
	public class Store : TerminalFormatterNode
	{
		public Store()
			: base("Store", new List<string>(1) { "0_StoreHub" })
		{
			AdditionalInfo = " Welcome to the Company store. \n Use words BUY and INFO on any item. \n Order items in bulk by typing a number.";
		}

		public override bool IsNodeValid(TerminalNode node, Terminal terminal)
		{
			return true;
		}

		public override string GetNodeText(TerminalNode node, Terminal terminal)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Expected O, but got Unknown
			ConsoleTable val = new ConsoleTable(new string[3] { "Name", "Price", "Owned" });
			GameObject val2 = GameObject.Find("/Environment/HangarShip");
			List<GrabbableObject> list = val2.GetComponentsInChildren<GrabbableObject>().ToList();
			bool value = ConfigManager.ShowDecorations.Value;
			string text = "COMPANY STORE";
			string value2 = new Header().CreateHeaderWithoutLines(text);
			stringBuilder = new StringBuilder().Append(value2);
			if (ConfigManager.ShowHelpText.Value)
			{
				stringBuilder.Append((AdditionalInfo != null) ? ("\n" + AdditionalInfo + "\n\n") : "");
			}
			val.AddRow(new object[3] { "[ITEMS]", "", "" });
			if (value)
			{
				val.AddRow(new object[3]
				{
					new string('-', Settings.dividerLength) ?? "",
					"",
					""
				});
			}
			List<BuyableItem> list2 = ContentManager.Items.OrderBy((BuyableItem x) => x.Item.itemName).ToList();
			int num = 1;
			foreach (BuyableItem item2 in list2)
			{
				Item item = item2.Item;
				int buyItemIndex = ((BuyableThing)item2).Nodes.Node.buyItemIndex;
				string text2 = item.itemName;
				int count = list.FindAll((GrabbableObject x) => x.itemProperties.itemName == item.itemName).Count;
				int discount = item2.Discount;
				if (buyItemIndex == -1)
				{
					continue;
				}
				if (value)
				{
					text2 = "* " + text2;
				}
				if (Plugin.isLLibPresent && LethalLibCompatibility.IsLLItemDisabled(item))
				{
					continue;
				}
				string text3 = ((item2.Discount != 0) ? string.Format(" {0}-{1}%{2}", value ? "(" : "", discount, value ? ")" : "") : "");
				text2 = ((text2.Length + text3.Length <= Settings.itemNameWidth) ? (text2.PadRight(Settings.itemNameWidth - text3.Length) + text3).PadRight(Settings.itemNameWidth) : (text2.Substring(0, Settings.itemNameWidth - 4 - text3.Length) + "... " + text3));
				val.AddRow(new object[3]
				{
					text2,
					$"${(int)((float)((BuyableThing)item2).Price * item2.DiscountPercentage)}",
					((count == 0) ? "" : ("×" + count.ToString("D2"))) ?? ""
				});
				if (ConfigManager.DivideShopPage.Value == 0)
				{
					continue;
				}
				if (num % ConfigManager.DivideShopPage.Value == 0)
				{
					num = 1;
					if (ConfigManager.ShowGroupDividerLines.Value)
					{
						val.AddRow(new object[3]
						{
							"".PadRight(Settings.itemNameWidth, '-'),
							"".PadRight(5, '-'),
							"".PadRight(5, '-')
						});
					}
					else
					{
						val.AddRow(new object[3] { "", "", "" });
					}
				}
				else
				{
					num++;
				}
			}
			List<BuyableUnlockable> list3 = (from x in ContentManager.Unlockables
				orderby x.Unlockable.unlockableName
				where !x.IsUnlocked
				select x).ToList();
			if (list3.Count > 0)
			{
				val.AddRow(new object[3] { "", "", "" });
				val.AddRow(new object[3] { "[UPGRADES]", "", "" });
				num = 1;
				if (value)
				{
					val.AddRow(new object[3]
					{
						new string('-', Settings.dividerLength) ?? "",
						"",
						""
					});
				}
			}
			foreach (BuyableUnlockable item3 in list3)
			{
				UnlockableItem unlockable = item3.Unlockable;
				bool flag = unlockable.hasBeenUnlockedByPlayer || unlockable.alreadyUnlocked;
				TerminalNode node2 = ((BuyableThing)item3).Nodes.Node;
				string text4 = unlockable.unlockableName;
				if (value)
				{
					text4 = "* " + text4;
				}
				if ((Plugin.isLLibPresent && LethalLibCompatibility.IsLLUpgradeDisabled(unlockable)) || flag)
				{
					continue;
				}
				val.AddRow(new object[3]
				{
					text4.PadRight(Settings.itemNameWidth),
					$"${((BuyableThing)item3).Price}",
					""
				});
				if (ConfigManager.DivideShopPage.Value == 0)
				{
					continue;
				}
				if (num % ConfigManager.DivideShopPage.Value == 0)
				{
					num = 1;
					if (ConfigManager.ShowGroupDividerLines.Value)
					{
						val.AddRow(new object[3]
						{
							"".PadRight(Settings.itemNameWidth, '-'),
							"".PadRight(5, '-'),
							"".PadRight(5, '-')
						});
					}
					else
					{
						val.AddRow(new object[3] { "", "", "" });
					}
				}
				else
				{
					num++;
				}
			}
			if (Plugin.isLRegenPresent && !LethalRegenCompatibility.IsUpgradeBought() && LethalRegenCompatibility.IsUpgradeInStore)
			{
				val.AddRow(new object[3] { "", "", "" });
				val.AddRow(new object[3] { "[REGENERATION]", "", "" });
				if (value)
				{
					val.AddRow(new object[3]
					{
						new string('-', Settings.dividerLength) ?? "",
						"",
						""
					});
				}
				val.AddRow(new object[3]
				{
					"Natural Regeneration",
					$"${LethalRegenCompatibility.GetCost()}",
					""
				});
			}
			val.AddRow(new object[3] { "", "", "" });
			val.AddRow(new object[3] { "[VEHICLES]", "", "" });
			num = 1;
			if (value)
			{
				val.AddRow(new object[3]
				{
					new string('-', Settings.dividerLength) ?? "",
					"",
					""
				});
			}
			List<BuyableCar> list4 = ContentManager.Vehicles.OrderBy((BuyableCar x) => ((BuyableThing)x).Name).ToList();
			foreach (BuyableCar item4 in list4)
			{
				string text5 = ((BuyableThing)item4).Name;
				if (value)
				{
					text5 = "* " + text5;
				}
				val.AddRow(new object[3]
				{
					text5,
					$"${((BuyableThing)item4).Price}",
					""
				});
				if (ConfigManager.DivideShopPage.Value == 0)
				{
					continue;
				}
				if (num % ConfigManager.DivideShopPage.Value == 0)
				{
					num = 1;
					if (ConfigManager.ShowGroupDividerLines.Value)
					{
						val.AddRow(new object[3]
						{
							"".PadRight(Settings.itemNameWidth, '-'),
							"".PadRight(5, '-'),
							"".PadRight(5, '-')
						});
					}
					else
					{
						val.AddRow(new object[3] { "", "", "" });
					}
				}
				else
				{
					num++;
				}
			}
			List<BuyableDecoration> list5 = (from x in ContentManager.Decorations
				orderby ((BuyableThing)x).Name
				where x.InRotation && !((BuyableUnlockable)x).IsUnlocked
				select x).ToList();
			if (list5.Count > 0)
			{
				val.AddRow(new object[3] { "", "", "" });
				val.AddRow(new object[3] { "[DECORATIONS]", "", "" });
				if (value)
				{
					val.AddRow(new object[3]
					{
						new string('-', Settings.dividerLength) ?? "",
						"",
						""
					});
				}
			}
			num = 1;
			foreach (BuyableDecoration item5 in list5)
			{
				UnlockableItem decoration = item5.Decoration;
				string text6 = ((BuyableThing)item5).Name;
				if (value)
				{
					text6 = "* " + text6;
				}
				if ((Plugin.isLLibPresent && LethalLibCompatibility.IsLLUpgradeDisabled(decoration)) || decoration.hasBeenUnlockedByPlayer || decoration.alreadyUnlocked)
				{
					continue;
				}
				if (Plugin.isSRCPresent)
				{
					int discount2;
					int discountedPrice = StoreRotationConfigCompatibility.GetDiscountedPrice((BuyableThing)(object)item5, out discount2);
					if (discount2 > 0)
					{
						string text7 = string.Format(" {0}-{1}%{2}", value ? ((object)'(') : "", discount2, value ? ((object)')') : "");
						text6 = ((text6.Length + text7.Length <= Settings.itemNameWidth) ? (text6.PadRight(Settings.itemNameWidth - text7.Length) + text7).PadRight(Settings.itemNameWidth) : (text6.Substring(0, Settings.itemNameWidth - 4 - text7.Length) + "..." + text7));
					}
					val.AddRow(new object[3]
					{
						text6,
						$"${discountedPrice}",
						""
					});
				}
				else
				{
					val.AddRow(new object[3]
					{
						text6,
						$"${((BuyableThing)item5).Price}",
						""
					});
				}
				if (ConfigManager.DivideShopPage.Value == 0)
				{
					continue;
				}
				if (num % ConfigManager.DivideShopPage.Value == 0)
				{
					num = 1;
					if (ConfigManager.ShowGroupDividerLines.Value)
					{
						val.AddRow(new object[3]
						{
							"".PadRight(Settings.itemNameWidth, '-'),
							"".PadRight(5, '-'),
							"".PadRight(5, '-')
						});
					}
					else
					{
						val.AddRow(new object[3] { "", "", "" });
					}
				}
				else
				{
					num++;
				}
			}
			List<BuyableSuit> list6 = (from x in ContentManager.Suits
				orderby ((BuyableThing)x).Name
				where x.InRotation && !x.IsUnlocked
				select x).ToList();
			if (list6.Count > 0)
			{
				val.AddRow(new object[3] { "", "", "" });
				val.AddRow(new object[3] { "[SUITS]", "", "" });
				num = 1;
				if (value)
				{
					val.AddRow(new object[3]
					{
						new string('-', Settings.dividerLength) ?? "",
						"",
						""
					});
				}
			}
			foreach (BuyableSuit item6 in list6)
			{
				UnlockableItem suit = item6.Suit;
				string text8 = ((BuyableThing)item6).Name;
				if (value)
				{
					text8 = "* " + text8;
				}
				if (item6.IsUnlocked)
				{
					continue;
				}
				if (Plugin.isSRCPresent)
				{
					int discount3;
					int discountedPrice2 = StoreRotationConfigCompatibility.GetDiscountedPrice((BuyableThing)(object)item6, out discount3);
					if (discount3 > 0)
					{
						string text9 = string.Format(" {0}-{1}%{2}", value ? ((object)'(') : "", discount3, value ? ((object)')') : "");
						text8 = ((text8.Length + text9.Length <= Settings.itemNameWidth) ? (text8.PadRight(Settings.itemNameWidth - text9.Length) + text9).PadRight(Settings.itemNameWidth) : (text8.Substring(0, Settings.itemNameWidth - 4 - text9.Length) + "..." + text9));
					}
					val.AddRow(new object[3]
					{
						text8,
						$"${discountedPrice2}",
						""
					});
				}
				else
				{
					val.AddRow(new object[3]
					{
						text8,
						$"${((BuyableThing)item6).Price}",
						""
					});
				}
				if (ConfigManager.DivideShopPage.Value == 0)
				{
					continue;
				}
				if (num % ConfigManager.DivideShopPage.Value == 0)
				{
					num = 1;
					if (ConfigManager.ShowGroupDividerLines.Value)
					{
						val.AddRow(new object[3]
						{
							"".PadRight(Settings.itemNameWidth, '-'),
							"".PadRight(5, '-'),
							"".PadRight(5, '-')
						});
					}
					else
					{
						val.AddRow(new object[3] { "", "", "" });
					}
				}
				else
				{
					num++;
				}
			}
			val.AddRow(new object[3] { "", "", "" });
			string value3 = val.ToStringCustomDecoration(true, true, false);
			stringBuilder.Append(value3);
			return stringBuilder.ToString().TrimEnd();
		}
	}
}
namespace TerminalFormatter.Compatibility
{
	internal class StoreRotationConfigCompatibility : CompatibilityBase
	{
		public StoreRotationConfigCompatibility(string guid, string version = null)
			: base(guid, version)
		{
			if (((CompatibilityBase)this).IsModPresent)
			{
				Init();
			}
		}

		public static void Init()
		{
			UnpatchTerminalScroll();
		}

		public static int GetDiscountedPrice(BuyableThing buyable, out int discount)
		{
			return RotationSalesAPI.GetDiscountedPrice(buyable.Nodes.Node, ref discount);
		}

		public static void UnpatchTerminalScroll()
		{
			Plugin.harmony.Unpatch((MethodBase)AccessTools.Method(typeof(PlayerControllerB), "ScrollMouse_performed", (Type[])null, (Type[])null), (HarmonyPatchType)3, "pacoito.StoreRotationConfig");
		}
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	internal sealed class IgnoresAccessChecksToAttribute : Attribute
	{
		public IgnoresAccessChecksToAttribute(string assemblyName)
		{
		}
	}
}