using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Text;
using System.Threading;
using Keel;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("Keel")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("2.0.0.0")]
[assembly: AssemblyInformationalVersion("2.0.0")]
[assembly: AssemblyProduct("Keel")]
[assembly: AssemblyTitle("Keel")]
[assembly: AssemblyVersion("2.0.0.0")]
namespace Keel
{
	internal static class Starter
	{
		private static readonly string[] BepInExStarters = new string[2] { "BepInEx.Preloader.dll", "BepInEx.Unity.Mono.Preloader.dll" };

		private const string CoreName = "Keel.Core.";

		private static string _log;

		internal static void Begin()
		{
			try
			{
				string text = Environment.GetEnvironmentVariable("DOORSTOP_INVOKE_DLL_PATH");
				if (string.IsNullOrEmpty(text))
				{
					text = typeof(Starter).Assembly.Location;
				}
				string? directoryName = Path.GetDirectoryName(Path.GetFullPath(text));
				string environmentVariable = Environment.GetEnvironmentVariable("DOORSTOP_PROCESS_PATH");
				string text2 = Path.GetDirectoryName(directoryName);
				if (string.IsNullOrEmpty(text2))
				{
					text2 = Directory.GetCurrentDirectory();
				}
				Open(directoryName);
				Line("Keel is starting in " + text2 + ".");
				string text3 = Path.Combine(directoryName, "Keel.cfg");
				Read(text3, out var startBepInEx, out var skip);
				AppDomain.CurrentDomain.SetData("Keel.BepInEx", BepInEx(text2, environmentVariable, startBepInEx));
				Run(directoryName, text3, skip);
			}
			catch (Exception e)
			{
				Line("Keel couldn't start: " + Inner(e));
			}
		}

		private static string BepInEx(string game, string exe, bool start)
		{
			string path = Path.Combine(Path.Combine(game, "BepInEx"), "core");
			string[] bepInExStarters = BepInExStarters;
			foreach (string path2 in bepInExStarters)
			{
				string text = Path.Combine(path, path2);
				if (!File.Exists(text))
				{
					continue;
				}
				if (!start)
				{
					Line("BepInEx is installed here too, but Keel.cfg says not to start it, so it stays off.");
					return "off";
				}
				Line("BepInEx is installed here too, so Keel starts it first.");
				DateTime since = DateTime.UtcNow.AddSeconds(-2.0);
				try
				{
					Environment.SetEnvironmentVariable("DOORSTOP_INVOKE_DLL_PATH", text);
					Assembly assembly = Assembly.LoadFrom(text);
					Type type = assembly.GetType("Doorstop.Entrypoint") ?? assembly.GetType("BepInEx.Preloader.Entrypoint");
					MethodInfo methodInfo = ((type == null) ? null : type.GetMethod("Start", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, Type.EmptyTypes, null));
					MethodInfo methodInfo2 = ((type == null) ? null : type.GetMethod("Main", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, Type.EmptyTypes, null));
					MethodInfo methodInfo3 = ((type == null) ? null : type.GetMethod("Main", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[1] { typeof(string[]) }, null));
					if (methodInfo != null)
					{
						methodInfo.Invoke(null, null);
					}
					else if (methodInfo2 != null)
					{
						methodInfo2.Invoke(null, null);
					}
					else
					{
						if (!(methodInfo3 != null))
						{
							Line("BepInEx's starter, " + text + ", has no way in that Keel knows, so BepInEx didn't start.");
							return "unknown";
						}
						methodInfo3.Invoke(null, new object[1] { new string[1] { exe ?? string.Empty } });
					}
				}
				catch (Exception e)
				{
					Line("BepInEx failed to start: " + Inner(e));
					return "failed";
				}
				string text2 = NewPreloaderLog(game, since) ?? NewPreloaderLog(ProgramFolder(exe), since);
				if (text2 != null)
				{
					Line("BepInEx ran into a problem while starting, which it wrote to " + text2 + ", so Keel won't count on it running any mods.");
					return "failed";
				}
				Line("BepInEx started.");
				return "started";
			}
			return "none";
		}

		private static string NewPreloaderLog(string folder, DateTime since)
		{
			try
			{
				string[] files = Directory.GetFiles(folder, "preloader_*.log");
				foreach (string text in files)
				{
					if (File.GetLastWriteTimeUtc(text) >= since)
					{
						return text;
					}
				}
			}
			catch (Exception)
			{
			}
			return null;
		}

		private static string ProgramFolder(string exe)
		{
			try
			{
				return Path.GetDirectoryName(exe);
			}
			catch (Exception)
			{
				return null;
			}
		}

		private static void Run(string home, string settings, List<string> skip)
		{
			int skipped;
			List<KeyValuePair<Version, string>> list = Cores(home, skip, out skipped);
			string marker = Path.Combine(home, "Keel.starting");
			string file;
			int num = Stopped(marker, out file);
			foreach (KeyValuePair<Version, string> item in list)
			{
				string fileName = Path.GetFileName(item.Value);
				string version = Three(item.Key);
				int num2 = (string.Equals(fileName, file, StringComparison.OrdinalIgnoreCase) ? num : 0);
				if (num2 >= 2)
				{
					Line("Keel passed over " + fileName + ", because the game stopped twice in a row while Keel was handing over to it. " + Added(settings, version, "the game stopped twice in a row while Keel was handing over to " + fileName));
					Remove(marker);
					continue;
				}
				Mark(marker, fileName, num2 + 1);
				MethodInfo boot;
				bool loaded;
				bool handedBack;
				string text = Check(item.Value, item.Key, out boot, out loaded, out handedBack);
				if (text != null && !loaded)
				{
					Remove(marker);
					Line("Keel passed over " + fileName + ", because " + text + ".");
					continue;
				}
				if (text != null)
				{
					Remove(marker);
					string text2 = fileName + " can't run, because " + text + ", and no other core can load in the same start, so no Keel mods start this time.";
					Line(handedBack ? text2 : (text2 + " " + Added(settings, version, fileName + " couldn't run: " + text)));
					return;
				}
				Line("Keel hands over to " + fileName + ".");
				try
				{
					boot.Invoke(null, new object[1] { home });
					return;
				}
				catch (Exception e)
				{
					Line(fileName + " failed while starting, so no Keel mods start this time. " + Added(settings, version, fileName + " failed while starting") + " What went wrong: " + Inner(e));
					return;
				}
				finally
				{
					Remove(marker);
				}
			}
			Line("Keel found no core it can run in " + home + ", so no Keel mods start." + ((skipped == 0) ? string.Empty : (" SkipCores in Keel.cfg passes over " + skipped.ToString(CultureInfo.InvariantCulture) + ((skipped == 1) ? " core here: take it out to try it again." : " cores here: take one out to try it again."))));
		}

		private static List<KeyValuePair<Version, string>> Cores(string home, List<string> skip, out int skipped)
		{
			skipped = 0;
			List<KeyValuePair<Version, string>> list = new List<KeyValuePair<Version, string>>();
			string[] files;
			try
			{
				files = Directory.GetFiles(home, "Keel.Core.*.dll");
			}
			catch (Exception ex)
			{
				Line("Keel couldn't look for cores in " + home + ": " + ex.Message);
				return list;
			}
			string[] array = files;
			foreach (string text in array)
			{
				string fileName = Path.GetFileName(text);
				Version version = Named(fileName);
				if (version == null)
				{
					Line("Keel passed over " + fileName + ", because a core's name is Keel.Core., then a version such as 2.0.0, then .dll.");
				}
				else if (skip.Contains(Three(version)))
				{
					skipped++;
					Line("Keel passed over " + fileName + ", because SkipCores in Keel.cfg names it.");
				}
				else
				{
					list.Add(new KeyValuePair<Version, string>(version, text));
				}
			}
			list.Sort(delegate(KeyValuePair<Version, string> a, KeyValuePair<Version, string> b)
			{
				int num = b.Key.CompareTo(a.Key);
				return (num == 0) ? string.CompareOrdinal(a.Value, b.Value) : num;
			});
			return list;
		}

		private static Version Named(string file)
		{
			if (file.Length <= "Keel.Core.".Length + 4 || !file.StartsWith("Keel.Core.", StringComparison.OrdinalIgnoreCase) || !file.EndsWith(".dll", StringComparison.OrdinalIgnoreCase))
			{
				return null;
			}
			string[] array = file.Substring("Keel.Core.".Length, file.Length - "Keel.Core.".Length - 4).Split(new char[1] { '.' });
			if (array.Length != 3)
			{
				return null;
			}
			int[] array2 = new int[3];
			for (int i = 0; i < 3; i++)
			{
				string text = array[i];
				if (text.Length == 0 || text.Length > 9 || (text.Length > 1 && text[0] == '0'))
				{
					return null;
				}
				int num = 0;
				string text2 = text;
				foreach (char c in text2)
				{
					if (c < '0' || c > '9')
					{
						return null;
					}
					num = num * 10 + (c - 48);
				}
				array2[i] = num;
			}
			return new Version(array2[0], array2[1], array2[2]);
		}

		private static string Check(string path, Version named, out MethodInfo boot, out bool loaded, out bool handedBack)
		{
			boot = null;
			loaded = false;
			handedBack = false;
			try
			{
				AssemblyName assemblyName = AssemblyName.GetAssemblyName(path);
				if (assemblyName.Name != "Keel.Core")
				{
					return "it isn't one of Keel's cores";
				}
				if (!Same(assemblyName.Version, named))
				{
					return "its name says " + Three(named) + ", but the file itself is " + Three(assemblyName.Version);
				}
				Assembly assembly = Assembly.LoadFrom(path);
				loaded = true;
				Version version = assembly.GetName().Version;
				if (!Same(version, named))
				{
					handedBack = true;
					return "the game already has core " + Three(version) + " loaded" + From(assembly);
				}
				Type type = assembly.GetType("Keel.Boot");
				if (type != null)
				{
					boot = type.GetMethod("Start", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[1] { typeof(string) }, null);
				}
				return (boot == null) ? "it has no way in that this Keel.dll knows" : null;
			}
			catch (Exception e)
			{
				return (loaded ? "it failed as it loaded: " : "it couldn't be loaded: ") + Inner(e).Message.TrimEnd(new char[1] { '.' });
			}
		}

		private static bool Same(Version v, Version named)
		{
			if (v != null && v.Major == named.Major && v.Minor == named.Minor)
			{
				return v.Build == named.Build;
			}
			return false;
		}

		private static string From(Assembly a)
		{
			try
			{
				string location = a.Location;
				return string.IsNullOrEmpty(location) ? string.Empty : (", from " + location);
			}
			catch (Exception)
			{
				return string.Empty;
			}
		}

		private static int Stopped(string marker, out string file)
		{
			file = null;
			try
			{
				if (!File.Exists(marker))
				{
					return 0;
				}
				string[] array = File.ReadAllLines(marker);
				if (array.Length == 0)
				{
					return 0;
				}
				string[] array2 = array[0].Trim().Split(new char[1] { ' ' });
				if (array2.Length != 2 || !int.TryParse(array2[1], NumberStyles.None, CultureInfo.InvariantCulture, out var result))
				{
					return 0;
				}
				for (int i = 1; i < array.Length; i++)
				{
					string text = array[i].Trim();
					if (text.StartsWith("Process ", StringComparison.Ordinal) && int.TryParse(text.Substring(8), NumberStyles.None, CultureInfo.InvariantCulture, out var result2) && Running(result2))
					{
						result = Math.Max(result - 1, 0);
						break;
					}
				}
				file = array2[0];
				return result;
			}
			catch (Exception)
			{
				return 0;
			}
		}

		private static void Mark(string marker, string file, int tries)
		{
			try
			{
				string newLine = Environment.NewLine;
				string text = file + " " + tries.ToString(CultureInfo.InvariantCulture) + newLine + "Keel writes this file just before it hands over to a core, and deletes it once the core has" + newLine + "taken over, before the game loads. If it's still here and the process named below isn't running," + newLine + "the game stopped during that hand-over. After two such starts in a row, Keel passes over that" + newLine + "core and adds it to SkipCores in Keel.cfg." + newLine;
				try
				{
					text = text + ThisGame() + newLine;
				}
				catch (Exception)
				{
				}
				File.WriteAllText(marker, text);
			}
			catch (Exception)
			{
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private static string ThisGame()
		{
			using Process process = Process.GetCurrentProcess();
			return "Process " + process.Id.ToString(CultureInfo.InvariantCulture);
		}

		private static bool Running(int pid)
		{
			try
			{
				return SameProgram(pid);
			}
			catch (Exception)
			{
				return false;
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private static bool SameProgram(int pid)
		{
			using Process process = Process.GetCurrentProcess();
			if (pid == process.Id || !Leader(pid))
			{
				return false;
			}
			using Process process2 = Process.GetProcessById(pid);
			return string.Equals(Path.GetFileName(process2.ProcessName), Path.GetFileName(process.ProcessName), StringComparison.OrdinalIgnoreCase);
		}

		private static bool Leader(int pid)
		{
			string text = pid.ToString(CultureInfo.InvariantCulture);
			string path = "/proc/" + text + "/status";
			if (!File.Exists(path))
			{
				return true;
			}
			string[] array = File.ReadAllLines(path);
			foreach (string text2 in array)
			{
				if (text2.StartsWith("Tgid:", StringComparison.Ordinal))
				{
					return string.Equals(text2.Substring(5).Trim(), text, StringComparison.Ordinal);
				}
			}
			return true;
		}

		private static void Remove(string marker)
		{
			int num = 25;
			for (int i = 0; i < 6; i++)
			{
				if (i > 0)
				{
					Thread.Sleep(num);
					num *= 2;
				}
				try
				{
					if (File.Exists(marker))
					{
						File.Delete(marker);
					}
					return;
				}
				catch (Exception)
				{
				}
				try
				{
					File.WriteAllText(marker, string.Empty);
					return;
				}
				catch (Exception)
				{
				}
			}
			Line("Keel couldn't delete or empty " + marker + ", so the next start may take this one for a start where the game stopped.");
		}

		private static void Read(string path, out bool startBepInEx, out List<string> skip)
		{
			startBepInEx = true;
			skip = new List<string>();
			try
			{
				if (!File.Exists(path))
				{
					return;
				}
				string[] array = File.ReadAllLines(path);
				for (int i = 0; i < array.Length; i++)
				{
					if (!Setting(array[i], out var key, out var value))
					{
						continue;
					}
					if (string.Equals(key, "StartBepInEx", StringComparison.OrdinalIgnoreCase))
					{
						string text = value.ToLowerInvariant();
						startBepInEx = text != "false" && text != "no" && text != "off" && text != "0";
					}
					else
					{
						if (!string.Equals(key, "SkipCores", StringComparison.OrdinalIgnoreCase))
						{
							continue;
						}
						string[] array2 = value.Split(new char[1] { ',' });
						for (int j = 0; j < array2.Length; j++)
						{
							string text2 = array2[j].Trim().Trim(new char[1] { '"' }).Trim();
							if (text2.Length != 0)
							{
								Version version = Listed(text2);
								if (version == null)
								{
									Line("SkipCores in Keel.cfg names " + text2 + ", which isn't a version such as 2.1.0, so Keel ignores it.");
								}
								else if (!skip.Contains(Three(version)))
								{
									skip.Add(Three(version));
								}
							}
						}
					}
				}
			}
			catch (Exception ex)
			{
				Line("Keel couldn't read " + path + ", so it goes by the defaults: " + ex.Message);
			}
		}

		private static bool Setting(string raw, out string key, out string value)
		{
			key = null;
			value = null;
			string text = raw.Trim();
			if (text.StartsWith("#", StringComparison.Ordinal))
			{
				return false;
			}
			int num = text.IndexOf('=');
			if (num < 0)
			{
				return false;
			}
			key = text.Substring(0, num).Trim();
			value = text.Substring(num + 1).Trim().Trim(new char[1] { '"' });
			return true;
		}

		private static Version Listed(string entry)
		{
			if (entry.StartsWith("Keel.Core.", StringComparison.OrdinalIgnoreCase))
			{
				entry = entry.Substring("Keel.Core.".Length);
			}
			if (entry.EndsWith(".dll", StringComparison.OrdinalIgnoreCase))
			{
				entry = entry.Substring(0, entry.Length - 4);
			}
			return Named("Keel.Core." + entry + ".dll");
		}

		private static string Added(string settings, string version, string reason)
		{
			if (!Skip(settings, version, reason))
			{
				return "To pass over it, add " + version + " to SkipCores in Keel.cfg.";
			}
			return "Keel added " + version + " to SkipCores in Keel.cfg, so the next start passes over it.";
		}

		private static bool Skip(string path, string version, string reason)
		{
			try
			{
				string newLine = Environment.NewLine;
				bool flag = File.Exists(path);
				string contents = (flag ? newLine : ("## Settings for Keel" + newLine + newLine)) + "## Keel added the line below on " + DateTime.Now.ToString("yyyy-MM-dd", CultureInfo.InvariantCulture) + ", because " + reason.Replace('\r', ' ').Replace('\n', ' ') + "." + newLine + "## Take that line out to try the core again." + newLine + "SkipCores = " + version + newLine;
				File.AppendAllText(path, contents, flag ? EncodingOf(path) : new UTF8Encoding(encoderShouldEmitUTF8Identifier: false));
				return true;
			}
			catch (Exception)
			{
				return false;
			}
		}

		private static Encoding EncodingOf(string path)
		{
			byte[] array = new byte[4];
			int num;
			using (FileStream fileStream = File.OpenRead(path))
			{
				num = fileStream.Read(array, 0, 4);
			}
			if (num >= 4 && array[0] == byte.MaxValue && array[1] == 254 && array[2] == 0 && array[3] == 0)
			{
				return new UTF32Encoding(bigEndian: false, byteOrderMark: false);
			}
			if (num >= 4 && array[0] == 0 && array[1] == 0 && array[2] == 254 && array[3] == byte.MaxValue)
			{
				return new UTF32Encoding(bigEndian: true, byteOrderMark: false);
			}
			if (num >= 2 && array[0] == byte.MaxValue && array[1] == 254)
			{
				return new UnicodeEncoding(bigEndian: false, byteOrderMark: false);
			}
			if (num >= 2 && array[0] == 254 && array[1] == byte.MaxValue)
			{
				return new UnicodeEncoding(bigEndian: true, byteOrderMark: false);
			}
			return new UTF8Encoding(encoderShouldEmitUTF8Identifier: false);
		}

		private static string Three(Version v)
		{
			if (v == null)
			{
				return "no version";
			}
			return v.Major.ToString(CultureInfo.InvariantCulture) + "." + v.Minor.ToString(CultureInfo.InvariantCulture) + "." + Math.Max(v.Build, 0).ToString(CultureInfo.InvariantCulture);
		}

		private static void Open(string home)
		{
			string text = Path.Combine(home, "Keel.log");
			try
			{
				if (File.Exists(text))
				{
					File.Copy(text, Path.Combine(home, "Keel.previous.log"), overwrite: true);
				}
			}
			catch (Exception)
			{
			}
			try
			{
				File.WriteAllText(text, string.Empty);
				_log = text;
			}
			catch (Exception)
			{
				_log = null;
			}
		}

		private static void Line(string text)
		{
			if (_log == null)
			{
				return;
			}
			try
			{
				File.AppendAllText(_log, DateTime.Now.ToString("HH:mm:ss", CultureInfo.InvariantCulture) + "  " + text + Environment.NewLine);
			}
			catch (Exception)
			{
			}
		}

		private static Exception Inner(Exception e)
		{
			if (!(e is TargetInvocationException) || e.InnerException == null)
			{
				return e;
			}
			return e.InnerException;
		}
	}
}
namespace Doorstop
{
	internal static class Entrypoint
	{
		public static void Start()
		{
			Starter.Begin();
		}
	}
}

using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.ExceptionServices;
using System.Runtime.Versioning;
using System.Security.Cryptography;
using System.Text;
using System.Threading;
using UnityEngine;
using UnityEngine.SceneManagement;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("Keel.Core")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("2.0.0.0")]
[assembly: AssemblyInformationalVersion("2.0.0")]
[assembly: AssemblyProduct("Keel.Core")]
[assembly: AssemblyTitle("Keel.Core")]
[assembly: AssemblyVersion("2.0.0.0")]
namespace Keel;

internal static class Boot
{
	internal static void Start(string home)
	{
		Loader.Begin(home);
	}
}
internal static class Loader
{
	internal static readonly string Version = Three(typeof(Loader).Assembly.GetName().Version);

	private static string _home;

	private static string _game;

	private static bool _bepinex;

	private static int _listening;

	private static bool _resolving;

	private static bool _sharedLoaded;

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

	internal static void Begin(string home)
	{
		try
		{
			_home = home;
			_game = Path.GetDirectoryName(Path.GetFullPath(home));
			if (string.IsNullOrEmpty(_game))
			{
				_game = Directory.GetCurrentDirectory();
			}
			Note.Open(Path.Combine(_home, "Keel.log"));
			Note.Line("Keel " + Version + " is running" + Fingerprint() + ".");
			_bepinex = AppDomain.CurrentDomain.GetData("Keel.BepInEx") as string == "started";
			Settings();
			try
			{
				Services.Publish();
			}
			catch (Exception ex)
			{
				Note.Line("Keel couldn't offer its core to mods: " + ex.Message);
			}
			Wait();
		}
		catch (Exception ex2)
		{
			Note.Line("Keel couldn't start: " + ex2);
		}
	}

	internal static string Three(Version v)
	{
		if (!(v == null))
		{
			return v.Major + "." + v.Minor + "." + Math.Max(v.Build, 0);
		}
		return "?";
	}

	private static string Fingerprint()
	{
		string text = "Keel.Core." + Version + ".dll";
		string text2 = Path.Combine(_home, text);
		string text3 = null;
		try
		{
			text3 = typeof(Loader).Assembly.Location;
		}
		catch (Exception)
		{
		}
		string text4 = text;
		string path = text2;
		if (text3 != null && text3.Length == 0)
		{
			return ", which wasn't loaded from a file";
		}
		if (!string.IsNullOrEmpty(text3))
		{
			try
			{
				if (!string.Equals(Path.GetFullPath(text3), Path.GetFullPath(text2), StringComparison.OrdinalIgnoreCase))
				{
					text4 = text3;
					path = text3;
				}
			}
			catch (Exception)
			{
			}
		}
		try
		{
			byte[] array;
			using (SHA256 sHA = SHA256.Create())
			{
				array = sHA.ComputeHash(File.ReadAllBytes(path));
			}
			StringBuilder stringBuilder = new StringBuilder(array.Length * 2);
			byte[] array2 = array;
			foreach (byte b in array2)
			{
				stringBuilder.Append(b.ToString("x2", CultureInfo.InvariantCulture));
			}
			return ", from " + text4 + " (SHA-256 " + stringBuilder?.ToString() + ")";
		}
		catch (Exception)
		{
			return ", from " + text4;
		}
	}

	private static void Settings()
	{
		string text = Path.Combine(_home, "Keel.cfg");
		try
		{
			string text2 = (File.Exists(text) ? File.ReadAllText(text) : null);
			bool flag = false;
			bool flag2 = false;
			if (text2 != null)
			{
				string[] array = text2.Split('\r', '\n');
				for (int i = 0; i < array.Length; i++)
				{
					string text3 = array[i].Trim();
					if (text3.StartsWith("#", StringComparison.Ordinal))
					{
						continue;
					}
					int num = text3.IndexOf('=');
					if (num >= 0)
					{
						string a = text3.Substring(0, num).Trim();
						if (string.Equals(a, "StartBepInEx", StringComparison.OrdinalIgnoreCase))
						{
							flag = true;
						}
						else if (string.Equals(a, "SkipCores", StringComparison.OrdinalIgnoreCase))
						{
							flag2 = true;
						}
					}
				}
			}
			if (flag && flag2)
			{
				return;
			}
			string newLine = Environment.NewLine;
			StringBuilder stringBuilder = new StringBuilder(1024);
			if (text2 == null)
			{
				stringBuilder.Append("## Settings for Keel").Append(newLine).Append(newLine);
			}
			else
			{
				int num2 = 0;
				for (int j = text2.TrimEnd('\r', '\n', ' ', '\t').Length; j < text2.Length; j++)
				{
					if (text2[j] == '\n' || (text2[j] == '\r' && (j + 1 == text2.Length || text2[j + 1] != '\n')))
					{
						num2++;
					}
				}
				if (text2.Trim().Length > 0 && num2 < 2)
				{
					stringBuilder.Append((num2 == 0) ? (newLine + newLine) : newLine);
				}
			}
			if (!flag)
			{
				stringBuilder.Append("[BepInEx]").Append(newLine).Append(newLine)
					.Append("## Whether Keel starts BepInEx too, when BepInEx is installed in this game")
					.Append(newLine)
					.Append("## folder. If you've switched BepInEx off, set this to false and it stays off.")
					.Append(newLine)
					.Append("# Setting type: Boolean")
					.Append(newLine)
					.Append("# Default value: true")
					.Append(newLine)
					.Append("StartBepInEx = true")
					.Append(newLine);
				if (!flag2)
				{
					stringBuilder.Append(newLine);
				}
			}
			if (!flag2)
			{
				stringBuilder.Append("[Cores]").Append(newLine).Append(newLine)
					.Append("## Versions of Keel's core to pass over, with commas between them, such as")
					.Append(newLine)
					.Append("## 2.1.0. Keel runs the newest core that isn't listed. It adds a core here")
					.Append(newLine)
					.Append("## itself, with a note saying when and why, when the core fails as Keel hands")
					.Append(newLine)
					.Append("## over to it, or the game stops twice in a row during that hand-over.")
					.Append(newLine)
					.Append("# Setting type: String")
					.Append(newLine)
					.Append("SkipCores =")
					.Append(newLine);
			}
			File.AppendAllText(text, stringBuilder.ToString(), (text2 == null) ? new UTF8Encoding(encoderShouldEmitUTF8Identifier: false) : EncodingOf(text));
		}
		catch (Exception ex)
		{
			Note.Line("Keel couldn't write its settings in " + text + ": " + ex.Message);
		}
	}

	private static Encoding EncodingOf(string path)
	{
		byte[] array = new byte[4];
		int num;
		using (FileStream fileStream = File.OpenRead(path))
		{
			num = fileStream.Read(array, 0, 4);
		}
		if (num >= 4 && array[0] == byte.MaxValue && array[1] == 254 && array[2] == 0 && array[3] == 0)
		{
			return new UTF32Encoding(bigEndian: false, byteOrderMark: false);
		}
		if (num >= 4 && array[0] == 0 && array[1] == 0 && array[2] == 254 && array[3] == byte.MaxValue)
		{
			return new UTF32Encoding(bigEndian: true, byteOrderMark: false);
		}
		if (num >= 2 && array[0] == byte.MaxValue && array[1] == 254)
		{
			return new UnicodeEncoding(bigEndian: false, byteOrderMark: false);
		}
		if (num >= 2 && array[0] == 254 && array[1] == byte.MaxValue)
		{
			return new UnicodeEncoding(bigEndian: true, byteOrderMark: false);
		}
		return new UTF8Encoding(encoderShouldEmitUTF8Identifier: false);
	}

	private static void Wait()
	{
		AppDomain.CurrentDomain.AssemblyLoad += Loaded;
		Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
		for (int i = 0; i < assemblies.Length; i++)
		{
			if (IsUnity(assemblies[i]))
			{
				Listen();
				return;
			}
		}
		Note.Line("Waiting for the game to load.");
	}

	private static void Loaded(object sender, AssemblyLoadEventArgs args)
	{
		if (IsUnity(args.LoadedAssembly))
		{
			Listen();
		}
	}

	private static bool IsUnity(Assembly a)
	{
		try
		{
			return a.GetName().Name == "UnityEngine.CoreModule";
		}
		catch (Exception)
		{
			return false;
		}
	}

	[MethodImpl(MethodImplOptions.NoInlining)]
	private static void Listen()
	{
		if (Interlocked.Exchange(ref _listening, 1) != 0)
		{
			return;
		}
		AppDomain.CurrentDomain.AssemblyLoad -= Loaded;
		try
		{
			Scenes.Listen();
			Note.Line("The game is loading. Mods will start with its first scene.");
		}
		catch (Exception ex)
		{
			Note.Line("Keel couldn't watch for the game's first scene, so no mods will start: " + ex);
		}
	}

	internal static void StartMods(string scene)
	{
		Note.Line("The first scene, " + scene + ", has loaded.");
		string[] directories;
		try
		{
			directories = Directory.GetDirectories(_home);
		}
		catch (Exception ex)
		{
			Note.Line("Keel couldn't look in " + _home + ": " + ex.Message);
			return;
		}
		Array.Sort(directories, (IComparer<string>?)StringComparer.OrdinalIgnoreCase);
		_mods.Clear();
		string[] array = directories;
		foreach (string text in array)
		{
			if (File.Exists(Path.Combine(text, Path.GetFileName(text) + ".dll")))
			{
				_mods.Add(text);
			}
		}
		if (_mods.Count == 0)
		{
			Note.Line("There are no mods in " + _home + ".");
			return;
		}
		if (!_resolving)
		{
			_resolving = true;
			AppDomain.CurrentDomain.AssemblyResolve += FromModFolders;
		}
		LoadShared();
		HashSet<string> hashSet = (_bepinex ? BepInExPlugins() : new HashSet<string>());
		List<KeyValuePair<string, MethodInfo>> list = new List<KeyValuePair<string, MethodInfo>>();
		foreach (string mod in _mods)
		{
			string fileName = Path.GetFileName(mod);
			if (hashSet.Contains(fileName + ".dll"))
			{
				Note.Line(fileName + " is in BepInEx's plugins folder too, so BepInEx runs that copy and this one stays off.");
				continue;
			}
			try
			{
				string text2 = Path.Combine(mod, fileName + ".dll");
				Assembly assembly = Assembly.LoadFrom(text2);
				string location = assembly.Location;
				if (!string.IsNullOrEmpty(location) && !string.Equals(Path.GetFullPath(location), Path.GetFullPath(text2), StringComparison.OrdinalIgnoreCase))
				{
					Note.Line(fileName + " is already loaded from " + location + ", so the copy in " + mod + " stays off.");
				}
				else
				{
					Type type = assembly.GetType("Keel.Entry");
					MethodInfo methodInfo = ((type == null) ? null : type.GetMethod("Start", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[1] { typeof(string) }, null));
					if (methodInfo == null)
					{
						Note.Line(fileName + ".dll isn't built on Keel, so it was left alone.");
					}
					else
					{
						list.Add(new KeyValuePair<string, MethodInfo>(mod, methodInfo));
					}
				}
			}
			catch (Exception e)
			{
				Note.Line(fileName + " couldn't be loaded: " + Inner(e));
			}
		}
		if (list.Count > 0)
		{
			Modded();
		}
		foreach (KeyValuePair<string, MethodInfo> item in list)
		{
			string fileName2 = Path.GetFileName(item.Key);
			try
			{
				Note.Line((string)item.Value.Invoke(null, new object[1] { item.Key }));
			}
			catch (Exception e2)
			{
				Note.Line(fileName2 + " failed to start: " + Inner(e2));
			}
		}
	}

	private static HashSet<string> BepInExPlugins()
	{
		HashSet<string> hashSet = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
		string text = Path.Combine(Path.Combine(_game, "BepInEx"), "plugins");
		if (Directory.Exists(text))
		{
			Collect(text, hashSet, 0);
		}
		return hashSet;
	}

	private static void Collect(string folder, HashSet<string> names, int depth)
	{
		try
		{
			string[] files = Directory.GetFiles(folder, "*.dll");
			foreach (string path in files)
			{
				names.Add(Path.GetFileName(path));
			}
		}
		catch (Exception ex)
		{
			Note.Line("Keel couldn't look in " + folder + ": " + ex.Message);
		}
		if (depth < 16)
		{
			string[] directories;
			try
			{
				directories = Directory.GetDirectories(folder);
			}
			catch (Exception)
			{
				return;
			}
			string[] files = directories;
			for (int i = 0; i < files.Length; i++)
			{
				Collect(files[i], names, depth + 1);
			}
		}
	}

	private static void Modded()
	{
		try
		{
			Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
			foreach (Assembly assembly in assemblies)
			{
				if (!(assembly.GetName().Name != "assembly_valheim"))
				{
					Type type = assembly.GetType("Game");
					FieldInfo fieldInfo = ((type == null) ? null : type.GetField("isModded", BindingFlags.Static | BindingFlags.Public));
					if (fieldInfo == null || fieldInfo.FieldType != typeof(bool))
					{
						Note.Line("The game has no isModded flag, so its menu won't say it's modded.");
						return;
					}
					fieldInfo.SetValue(null, true);
					Note.Line("Told the game that it's modded.");
					return;
				}
			}
			Note.Line("The game's code wasn't loaded, so Keel couldn't tell it that it's modded.");
		}
		catch (Exception ex)
		{
			Note.Line("Keel couldn't tell the game that it's modded: " + ex.Message);
		}
	}

	private static void LoadShared()
	{
		if (_sharedLoaded)
		{
			return;
		}
		_sharedLoaded = true;
		HashSet<string> hashSet = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
		foreach (string mod in _mods)
		{
			hashSet.Add(Path.GetFileName(mod) + ".dll");
		}
		SortedDictionary<string, List<string>> sortedDictionary = new SortedDictionary<string, List<string>>(StringComparer.OrdinalIgnoreCase);
		foreach (string mod2 in _mods)
		{
			string[] files;
			try
			{
				files = Directory.GetFiles(mod2, "*.dll");
			}
			catch (Exception)
			{
				continue;
			}
			string[] array = files;
			foreach (string text in array)
			{
				string fileName = Path.GetFileName(text);
				if (!hashSet.Contains(fileName) && !string.Equals(fileName, "Keel.dll", StringComparison.OrdinalIgnoreCase) && !fileName.StartsWith("Keel.Core.", StringComparison.OrdinalIgnoreCase))
				{
					if (!sortedDictionary.TryGetValue(fileName, out var value))
					{
						value = (sortedDictionary[fileName] = new List<string>());
					}
					value.Add(text);
				}
			}
		}
		foreach (KeyValuePair<string, List<string>> item in sortedDictionary)
		{
			if (item.Value.Count < 2)
			{
				continue;
			}
			string text2 = null;
			Version version = null;
			foreach (string item2 in item.Value)
			{
				Version version2;
				try
				{
					version2 = AssemblyName.GetAssemblyName(item2).Version;
				}
				catch (Exception)
				{
					continue;
				}
				if (text2 == null || (version2 != null && (version == null || version2.CompareTo(version) > 0)))
				{
					text2 = item2;
					version = version2;
				}
			}
			if (text2 != null)
			{
				try
				{
					Assembly.LoadFrom(text2);
					Note.Line(item.Key + " is in more than one mod's folder, so Keel loads its highest version, " + ((version == null) ? "which has none" : version.ToString()) + ", from " + Path.GetDirectoryName(text2) + ", for all of them.");
				}
				catch (Exception e)
				{
					Note.Line("Keel couldn't load " + text2 + ", which more than one mod keeps: " + Inner(e).Message);
				}
			}
		}
	}

	private static Assembly FromModFolders(object sender, ResolveEventArgs args)
	{
		try
		{
			string name = new AssemblyName(args.Name).Name;
			string text = null;
			Version version = null;
			foreach (string mod in _mods)
			{
				string text2 = Path.Combine(mod, name + ".dll");
				if (File.Exists(text2))
				{
					Version version2;
					try
					{
						version2 = AssemblyName.GetAssemblyName(text2).Version;
					}
					catch (Exception)
					{
						continue;
					}
					if (text == null || (version2 != null && (version == null || version2.CompareTo(version) > 0)))
					{
						text = text2;
						version = version2;
					}
				}
			}
			if (text != null)
			{
				return Assembly.LoadFrom(text);
			}
		}
		catch (Exception)
		{
		}
		return null;
	}

	private static Exception Inner(Exception e)
	{
		if (!(e is TargetInvocationException) || e.InnerException == null)
		{
			return e;
		}
		return e.InnerException;
	}
}
internal sealed class ModState
{
	private static readonly MethodInfo BindAsT = typeof(ModState).GetMethod("BindAs", BindingFlags.Instance | BindingFlags.NonPublic);

	private readonly string _name;

	private readonly string _seed;

	private readonly SettingsFile _settings;

	internal ModState(string id, string name, string version, string folder)
	{
		_name = name;
		string path = Path.Combine(folder, Safe(name) + ".cfg");
		if (!File.Exists(path))
		{
			string text = Path.Combine(Path.Combine(Path.Combine(GameFolder(folder), "BepInEx"), "config"), id + ".cfg");
			if (File.Exists(text))
			{
				_seed = text;
			}
		}
		_settings = new SettingsFile(path, new string[2]
		{
			"Settings for " + name + " " + version,
			"Mod ID: " + id
		}, delegate(string message)
		{
			Debug.LogWarning((object)(name + ": " + message));
		}, _seed);
	}

	internal void Begun()
	{
		if (_seed != null)
		{
			Info(_name + " starts from the settings BepInEx kept in " + _seed + ", and keeps its own from now on, in " + _settings.FilePath + ".");
		}
	}

	internal void Info(string message)
	{
		Debug.Log((object)message);
	}

	internal void Warn(string message)
	{
		Debug.LogWarning((object)message);
	}

	internal bool GetSaving()
	{
		return _settings.Saving;
	}

	internal void SetSaving(bool on)
	{
		_settings.Saving = on;
	}

	internal void Done()
	{
		_settings.Save();
	}

	internal Delegate[] Bind(string section, string key, Type type, object fallback, string about, object limits)
	{
		if (type == null)
		{
			throw new ArgumentNullException("type");
		}
		try
		{
			return (Delegate[])BindAsT.MakeGenericMethod(type).Invoke(this, new object[5] { section, key, fallback, about, limits });
		}
		catch (TargetInvocationException ex)
		{
			if (ex.InnerException == null)
			{
				throw;
			}
			ExceptionDispatchInfo.Capture(ex.InnerException).Throw();
			throw;
		}
	}

	private Delegate[] BindAs<T>(string section, string key, object fallback, string about, object limits)
	{
		Func<T, T> clamp = null;
		string limits2 = null;
		if (limits is string[] array)
		{
			if (typeof(T) != typeof(string))
			{
				throw new ArgumentException("[" + section + "] " + key + " can only have allowed values if it's text.");
			}
			if (array.Length == 0)
			{
				throw new ArgumentException("[" + section + "] " + key + " needs at least one allowed value.");
			}
			string[] list = (string[])array.Clone();
			clamp = (Func<T, T>)(object)(Func<string, string>)((string v) => (Array.IndexOf(list, v) < 0) ? list[0] : v);
			limits2 = SettingsFile.ListLimits(list);
		}
		else if (limits is float[] array2)
		{
			if (typeof(T) != typeof(float) || array2.Length != 2)
			{
				throw new ArgumentException("[" + section + "] " + key + " can only have a range if it's a number, from a low end to a high end.");
			}
			float min = array2[0];
			float max = array2[1];
			if (min.CompareTo(max) >= 0)
			{
				throw new ArgumentException("[" + section + "] " + key + "'s low end has to be lower than its high end.");
			}
			clamp = (Func<T, T>)(object)(Func<float, float>)delegate(float v)
			{
				if (min.CompareTo(v) > 0)
				{
					return min;
				}
				return (max.CompareTo(v) < 0) ? max : v;
			};
			limits2 = SettingsFile.RangeLimits(min, max);
		}
		else if (limits != null)
		{
			throw new ArgumentException("[" + section + "] " + key + " has limits of a kind Keel doesn't know.");
		}
		return _settings.Add(section, key, (T)fallback, about, clamp, limits2);
	}

	private static string Safe(string name)
	{
		char[] invalidFileNameChars = Path.GetInvalidFileNameChars();
		StringBuilder stringBuilder = new StringBuilder(name.Length);
		foreach (char c in name)
		{
			stringBuilder.Append((Array.IndexOf(invalidFileNameChars, c) >= 0) ? '_' : c);
		}
		return stringBuilder.ToString();
	}

	private static string GameFolder(string folder)
	{
		return Path.GetDirectoryName(Path.GetDirectoryName(Path.GetFullPath(folder).TrimEnd(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar)) ?? string.Empty) ?? string.Empty;
	}
}
internal static class Note
{
	private static string _path;

	internal static void Open(string path)
	{
		_path = path;
	}

	internal static void Line(string text)
	{
		if (_path == null)
		{
			return;
		}
		try
		{
			File.AppendAllText(_path, DateTime.Now.ToString("HH:mm:ss", CultureInfo.InvariantCulture) + "  " + text + Environment.NewLine);
		}
		catch (Exception)
		{
		}
	}
}
internal static class Once
{
	private const string Prefix = "Keel.Started.";

	internal static bool Claim(string id, string name, string version, string starter)
	{
		AppDomain currentDomain = AppDomain.CurrentDomain;
		string name2 = "Keel.Started." + id;
		lock (typeof(AppDomain))
		{
			if (currentDomain.GetData(name2) != null)
			{
				return false;
			}
			currentDomain.SetData(name2, starter + " already started " + name + " " + version);
			return true;
		}
	}

	internal static string StaysOff(string id, string name, string version)
	{
		string text = AppDomain.CurrentDomain.GetData("Keel.Started." + id) as string;
		return name + " " + version + " stays off, because " + (text ?? "another copy is already running") + ".";
	}
}
internal static class Scenes
{
	[MethodImpl(MethodImplOptions.NoInlining)]
	internal static void Listen()
	{
		SceneManager.sceneLoaded += First;
	}

	private static void First(Scene scene, LoadSceneMode mode)
	{
		try
		{
			SceneManager.sceneLoaded -= First;
			Loader.StartMods(((Scene)(ref scene)).name);
		}
		catch (Exception ex)
		{
			Note.Line("Starting the mods failed: " + ex);
		}
	}
}
internal static class Services
{
	internal const string Key = "Keel.Core";

	internal const int Contract = 1;

	internal static IDictionary<string, object> Publish()
	{
		AppDomain currentDomain = AppDomain.CurrentDomain;
		lock (typeof(AppDomain))
		{
			if (currentDomain.GetData("Keel.Core") is IDictionary<string, object> result)
			{
				return result;
			}
			IDictionary<string, object> dictionary = new ReadOnlyDictionary<string, object>(new Dictionary<string, object>(StringComparer.Ordinal)
			{
				["version"] = Loader.Version,
				["contract"] = 1,
				["start"] = new Func<string, string, string, string, IDictionary<string, object>, IDictionary<string, object>>(Start)
			});
			currentDomain.SetData("Keel.Core", dictionary);
			return dictionary;
		}
	}

	private static IDictionary<string, object> Start(string id, string name, string version, string folder, IDictionary<string, object> about)
	{
		ModState modState = new ModState(id, name, version, folder);
		Dictionary<string, object> dictionary = new Dictionary<string, object>(StringComparer.Ordinal);
		if (!Once.Claim(id, name, version, "Keel"))
		{
			dictionary["run"] = false;
			dictionary["reason"] = Once.StaysOff(id, name, version);
			return new ReadOnlyDictionary<string, object>(dictionary);
		}
		dictionary["run"] = true;
		dictionary["folder"] = folder;
		dictionary["starter"] = "Keel";
		dictionary["info"] = new Action<string>(modState.Info);
		dictionary["warn"] = new Action<string>(modState.Warn);
		dictionary["bind"] = new Func<string, string, Type, object, string, object, Delegate[]>(modState.Bind);
		dictionary["getSaving"] = new Func<bool>(modState.GetSaving);
		dictionary["setSaving"] = new Action<bool>(modState.SetSaving);
		dictionary["done"] = new Action(modState.Done);
		modState.Begun();
		return new ReadOnlyDictionary<string, object>(dictionary);
	}
}
internal sealed class SettingsFile
{
	private abstract class Row
	{
		internal string Section;

		internal string Key;

		internal string About;

		internal Type Type;

		internal string Limits;

		internal Delegate[] Made;

		internal abstract string Text();

		internal abstract string FallbackText();
	}

	private sealed class Row<T> : Row
	{
		internal T Fallback;

		internal T Value;

		internal Func<T, T> Clamp;

		internal override string Text()
		{
			return Toml.Write(Value, Type);
		}

		internal override string FallbackText()
		{
			return Toml.Write(Fallback, Type);
		}
	}

	private readonly string _path;

	private readonly string[] _header;

	private readonly Action<string> _warn;

	private readonly List<Row> _rows = new List<Row>();

	private readonly List<KeyValuePair<string, string>> _readOrder = new List<KeyValuePair<string, string>>();

	private readonly Dictionary<string, string> _read = new Dictionary<string, string>(StringComparer.Ordinal);

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

	private bool _unreadable;

	private bool _saving = true;

	private bool _toldWrite;

	private static readonly char[] Refused = new char[8] { '=', '\n', '\t', '\\', '"', '\'', '[', ']' };

	internal string FilePath => _path;

	internal bool Saving
	{
		get
		{
			return _saving;
		}
		set
		{
			if (_saving != value)
			{
				_saving = value;
				if (value)
				{
					Save();
				}
			}
		}
	}

	internal SettingsFile(string path, string[] header, Action<string> warn, string seed)
	{
		_path = path;
		_header = header;
		_warn = warn;
		Read(seed ?? path, seed == null);
	}

	internal Delegate[] Add<T>(string section, string key, T fallback, string about, Func<T, T> clamp, string limits)
	{
		Name(section, "section");
		Name(key, "key");
		Type typeFromHandle = typeof(T);
		if (!Toml.Supports(typeFromHandle))
		{
			throw new NotSupportedException("Keel can't keep a setting of type " + typeFromHandle.Name + ".");
		}
		string text = Id(section, key);
		foreach (Row row2 in _rows)
		{
			if (!(Id(row2.Section, row2.Key) != text))
			{
				if (row2.Type != typeFromHandle)
				{
					throw new InvalidCastException("[" + section + "] " + key + " is already a setting of type " + row2.Type.Name + ", not " + typeFromHandle.Name + ".");
				}
				return row2.Made;
			}
		}
		Row<T> row = new Row<T>();
		row.Section = section;
		row.Key = key;
		row.About = about;
		row.Type = typeFromHandle;
		row.Limits = limits;
		row.Clamp = clamp;
		row.Fallback = ((clamp == null) ? fallback : clamp(fallback));
		row.Value = row.Fallback;
		if (_read.TryGetValue(text, out var value))
		{
			_claimed.Add(text);
			if (Toml.TryRead(value, typeFromHandle, out var value2))
			{
				row.Value = ((clamp == null) ? ((T)value2) : clamp((T)value2));
			}
			else if (_warn != null)
			{
				_warn("[" + section + "] " + key + " = " + value + " can't be read, so it's back to its default, " + row.FallbackText() + ".");
			}
		}
		_rows.Add(row);
		Func<T> func = () => row.Value;
		Action<T> action = delegate(T v)
		{
			Set(row, v);
		};
		row.Made = new Delegate[2] { func, action };
		return row.Made;
	}

	private static void Name(string name, string what)
	{
		if (name == null)
		{
			throw new ArgumentNullException(what);
		}
		if (name != name.Trim())
		{
			throw new ArgumentException("A setting's " + what + " can't start or end with a space: \"" + name + "\".", what);
		}
		if (name.IndexOfAny(Refused) >= 0)
		{
			throw new ArgumentException("A setting's " + what + " can't hold = \\ \" ' [ ], a tab or a line break: \"" + name + "\".", what);
		}
	}

	private void Set<T>(Row<T> row, T value)
	{
		if (row.Clamp != null)
		{
			value = row.Clamp(value);
		}
		if (!EqualityComparer<T>.Default.Equals(row.Value, value))
		{
			row.Value = value;
			if (_saving)
			{
				Save();
			}
		}
	}

	private static string Id(string section, string key)
	{
		return section + "\n" + key;
	}

	private void Read(string from, bool own)
	{
		if (!File.Exists(from))
		{
			return;
		}
		string[] array;
		try
		{
			array = File.ReadAllLines(from);
		}
		catch (Exception ex)
		{
			_unreadable = own;
			if (_warn != null)
			{
				_warn("Couldn't read " + from + " (" + ex.Message + "), so the settings are at their defaults for now" + (own ? ", and that file is left as it is." : "."));
			}
			return;
		}
		string text = string.Empty;
		string[] array2 = array;
		for (int i = 0; i < array2.Length; i++)
		{
			string text2 = array2[i].Trim();
			if (text2.StartsWith("#", StringComparison.Ordinal))
			{
				continue;
			}
			if (text2.StartsWith("[", StringComparison.Ordinal) && text2.EndsWith("]", StringComparison.Ordinal))
			{
				text = text2.Substring(1, text2.Length - 2);
				continue;
			}
			string[] array3 = text2.Split(new char[1] { '=' }, 2);
			if (array3.Length == 2)
			{
				string text3 = array3[0].Trim();
				string key = Id(text, text3);
				if (!_read.ContainsKey(key))
				{
					_readOrder.Add(new KeyValuePair<string, string>(text, text3));
				}
				_read[key] = array3[1].Trim();
			}
		}
	}

	internal void Save()
	{
		if (_unreadable)
		{
			return;
		}
		string newLine = Environment.NewLine;
		StringBuilder stringBuilder = new StringBuilder(2048);
		string[] header = _header;
		foreach (string value in header)
		{
			stringBuilder.Append("## ").Append(value).Append(newLine);
		}
		stringBuilder.Append(newLine);
		SortedDictionary<string, List<KeyValuePair<Row, string>>> sortedDictionary = new SortedDictionary<string, List<KeyValuePair<Row, string>>>(StringComparer.Ordinal);
		foreach (Row row in _rows)
		{
			Into(sortedDictionary, row.Section).Add(new KeyValuePair<Row, string>(row, row.Key + " = " + row.Text()));
		}
		foreach (KeyValuePair<string, string> item in _readOrder)
		{
			string text = Id(item.Key, item.Value);
			if (!_claimed.Contains(text))
			{
				Into(sortedDictionary, item.Key).Add(new KeyValuePair<Row, string>(null, item.Value + " = " + _read[text]));
			}
		}
		foreach (KeyValuePair<string, List<KeyValuePair<Row, string>>> item2 in sortedDictionary)
		{
			stringBuilder.Append('[').Append(item2.Key).Append(']')
				.Append(newLine);
			foreach (KeyValuePair<Row, string> item3 in item2.Value)
			{
				stringBuilder.Append(newLine);
				if (item3.Key != null)
				{
					Describe(stringBuilder, item3.Key, newLine);
				}
				stringBuilder.Append(item3.Value).Append(newLine);
			}
			stringBuilder.Append(newLine);
		}
		try
		{
			string directoryName = Path.GetDirectoryName(_path);
			if (!string.IsNullOrEmpty(directoryName))
			{
				Directory.CreateDirectory(directoryName);
			}
			string text2 = _path + ".tmp";
			File.WriteAllText(text2, stringBuilder.ToString(), new UTF8Encoding(encoderShouldEmitUTF8Identifier: false));
			if (File.Exists(_path))
			{
				try
				{
					File.Replace(text2, _path, null);
					return;
				}
				catch (Exception)
				{
					File.Copy(text2, _path, overwrite: true);
					File.Delete(text2);
					return;
				}
			}
			File.Move(text2, _path);
		}
		catch (Exception ex2)
		{
			if (!_toldWrite && _warn != null)
			{
				_toldWrite = true;
				_warn("Couldn't save " + _path + ": " + ex2.Message);
			}
		}
	}

	private static List<KeyValuePair<Row, string>> Into(SortedDictionary<string, List<KeyValuePair<Row, string>>> sections, string name)
	{
		if (!sections.TryGetValue(name, out var value))
		{
			value = (sections[name] = new List<KeyValuePair<Row, string>>());
		}
		return value;
	}

	private static void Describe(StringBuilder b, Row row, string nl)
	{
		if (!string.IsNullOrEmpty(row.About))
		{
			string[] array = row.About.Split('\n');
			foreach (string text in array)
			{
				b.Append("## ").Append(text.TrimEnd('\r')).Append(nl);
			}
		}
		b.Append("# Setting type: ").Append(row.Type.Name).Append(nl);
		b.Append("# Default value: ").Append(row.FallbackText()).Append(nl);
		if (row.Limits != null)
		{
			b.Append(row.Limits).Append(nl);
		}
		else if (row.Type.IsEnum)
		{
			b.Append("# Acceptable values: ").Append(string.Join(", ", Enum.GetNames(row.Type))).Append(nl);
			if (row.Type.GetCustomAttributes(typeof(FlagsAttribute), inherit: true).Length != 0)
			{
				b.Append("# More than one can be set at once, with commas between them.").Append(nl);
			}
		}
	}

	internal static string ListLimits(string[] allowed)
	{
		return "# Acceptable values: " + string.Join(", ", allowed);
	}

	internal static string RangeLimits(float min, float max)
	{
		return "# Acceptable value range: From " + min.ToString(NumberFormatInfo.InvariantInfo) + " to " + max.ToString(NumberFormatInfo.InvariantInfo);
	}
}
internal static class Toml
{
	private const string Escaped = "\\\"\n\r\t\0\a\b\v\f'";

	private const string Letters = "\\\"nrt0abvf'";

	private const int Written = 6;

	internal static bool Supports(Type type)
	{
		if (!(type == typeof(bool)) && !(type == typeof(int)) && !(type == typeof(float)) && !(type == typeof(string)) && !(type == typeof(Color)))
		{
			return type.IsEnum;
		}
		return true;
	}

	internal static string Write(object value, Type type)
	{
		//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
		if (type == typeof(bool))
		{
			if (!(bool)value)
			{
				return "false";
			}
			return "true";
		}
		if (type == typeof(int))
		{
			return ((int)value).ToString(NumberFormatInfo.InvariantInfo);
		}
		if (type == typeof(float))
		{
			return ((float)value).ToString(NumberFormatInfo.InvariantInfo);
		}
		if (type == typeof(string))
		{
			return Escape((string)value);
		}
		if (type == typeof(Color))
		{
			return Hex((Color)value);
		}
		if (type.IsEnum)
		{
			return value.ToString();
		}
		throw new NotSupportedException("Keel can't keep a setting of type " + type.Name + ".");
	}

	internal static bool TryRead(string text, Type type, out object value)
	{
		//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
		value = null;
		if (text == null)
		{
			return false;
		}
		try
		{
			if (type == typeof(bool))
			{
				value = bool.Parse(text);
			}
			else if (type == typeof(int))
			{
				value = int.Parse(text, NumberStyles.Integer, NumberFormatInfo.InvariantInfo);
			}
			else if (type == typeof(float))
			{
				value = float.Parse(text, NumberStyles.Float | NumberStyles.AllowThousands, NumberFormatInfo.InvariantInfo);
			}
			else if (type == typeof(string))
			{
				value = (LooksLikePath(text) ? text : Unescape(text));
			}
			else if (type == typeof(Color))
			{
				if (!TryHex(text, out var colour))
				{
					return false;
				}
				value = colour;
			}
			else
			{
				if (!type.IsEnum)
				{
					return false;
				}
				value = Enum.Parse(type, text, ignoreCase: true);
			}
			return true;
		}
		catch (FormatException)
		{
		}
		catch (OverflowException)
		{
		}
		catch (ArgumentException)
		{
		}
		return false;
	}

	private static bool LooksLikePath(string text)
	{
		int num = (text.StartsWith("\"", StringComparison.Ordinal) ? 1 : 0);
		if (text.Length < num + 3)
		{
			return false;
		}
		char c = text[num];
		if (!char.IsLetterOrDigit(c) && c != '_')
		{
			return false;
		}
		if (text[num + 1] != ':' || text[num + 2] != '\\')
		{
			return false;
		}
		return text.IndexOf("\\\\", num + 2, StringComparison.Ordinal) < 0;
	}

	private static string Hex(Color c)
	{
		//IL_0000: Unknown result type (might be due to invalid IL or missing references)
		//IL_001d: Unknown result type (might be due to invalid IL or missing references)
		//IL_003a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0057: Unknown result type (might be due to invalid IL or missing references)
		return Byte(c.r).ToString("X2", CultureInfo.InvariantCulture) + Byte(c.g).ToString("X2", CultureInfo.InvariantCulture) + Byte(c.b).ToString("X2", CultureInfo.InvariantCulture) + Byte(c.a).ToString("X2", CultureInfo.InvariantCulture);
	}

	private static int Byte(float channel)
	{
		int num = (int)Math.Round(channel * 255f);
		if (num >= 0)
		{
			if (num <= 255)
			{
				return num;
			}
			return 255;
		}
		return 0;
	}

	private static bool TryHex(string text, out Color colour)
	{
		//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
		colour = default(Color);
		string text2 = text.Trim().Trim('#', ' ');
		if (text2.Length == 3 || text2.Length == 4)
		{
			StringBuilder stringBuilder = new StringBuilder(8);
			string text3 = text2;
			foreach (char value in text3)
			{
				stringBuilder.Append(value).Append(value);
			}
			text2 = stringBuilder.ToString();
		}
		if (text2.Length == 6)
		{
			text2 += "FF";
		}
		if (text2.Length != 8)
		{
			return false;
		}
		if (!uint.TryParse(text2, NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture, out var result))
		{
			return false;
		}
		colour = Color32.op_Implicit(new Color32((byte)(result >> 24), (byte)(result >> 16), (byte)(result >> 8), (byte)result));
		return true;
	}

	private static string Escape(string text)
	{
		if (string.IsNullOrEmpty(text))
		{
			return string.Empty;
		}
		StringBuilder stringBuilder = new StringBuilder(text.Length + 8);
		foreach (char value in text)
		{
			int num = "\\\"\n\r\t\0\a\b\v\f'".IndexOf(value);
			if (num >= 0 && num < 6)
			{
				stringBuilder.Append('\\').Append("\\\"nrt0abvf'"[num]);
			}
			else
			{
				stringBuilder.Append(value);
			}
		}
		return stringBuilder.ToString();
	}

	private static string Unescape(string text)
	{
		if (string.IsNullOrEmpty(text))
		{
			return text;
		}
		StringBuilder stringBuilder = new StringBuilder(text.Length);
		for (int i = 0; i < text.Length; i++)
		{
			char c = text[i];
			if (c != '\\' || i + 1 == text.Length)
			{
				stringBuilder.Append(c);
				continue;
			}
			char value = text[++i];
			int num = "\\\"nrt0abvf'".IndexOf(value);
			if (num >= 0)
			{
				stringBuilder.Append("\\\"\n\r\t\0\a\b\v\f'"[num]);
			}
			else
			{
				stringBuilder.Append('\\').Append(value);
			}
		}
		return stringBuilder.ToString();
	}
}