using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.IO.Compression;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Text;
using System.Text.Json;
using System.Threading;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Core.Logging.Interpolation;
using BepInEx.Logging;
using BepInEx.Unity.IL2CPP;
using HarmonyLib;
using Il2CppInterop.Runtime;
using Il2CppInterop.Runtime.InteropTypes;
using Il2CppInterop.Runtime.InteropTypes.Arrays;
using Il2CppSystem.Collections.Generic;
using Managers;
using Microsoft.CodeAnalysis;
using SCTCommon;
using UnityEngine;
using UnityEngine.InputSystem;
using UnityEngine.InputSystem.Controls;
using UnityEngine.InputSystem.Utilities;
using UnityEngine.Localization;
using UnityEngine.Localization.Settings;
using UnityEngine.SceneManagement;

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

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

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

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace SCTCommon
{
	internal static class CraftCosts
	{
		private const string OwnerKey = "sct.craft.owner";

		private const string ProvidersKey = "sct.craft.providers";

		private const float MinFactor = 0.25f;

		private const int MaxBuildId = 512;

		private static readonly Dictionary<int, int[]> Originals = new Dictionary<int, int[]>();

		private static float _appliedFactor = 1f;

		private static bool _isOwner;

		public static float Factor
		{
			get
			{
				float num = 1f;
				if (AppDomain.CurrentDomain.GetData("sct.craft.providers") is Dictionary<string, Func<float>> dictionary)
				{
					foreach (Func<float> value in dictionary.Values)
					{
						try
						{
							num *= 1f - Mathf.Clamp(value(), 0f, 0.9f);
						}
						catch (Exception)
						{
						}
					}
				}
				return Mathf.Max(0.25f, num);
			}
		}

		public static void RegisterDiscount(string id, Func<float> discount)
		{
			lock (AppDomain.CurrentDomain)
			{
				Dictionary<string, Func<float>> dictionary = (AppDomain.CurrentDomain.GetData("sct.craft.providers") as Dictionary<string, Func<float>>) ?? new Dictionary<string, Func<float>>();
				dictionary[id] = discount;
				AppDomain.CurrentDomain.SetData("sct.craft.providers", dictionary);
			}
		}

		public static void Install(Harmony harmony, string owner)
		{
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Expected O, but got Unknown
			lock (AppDomain.CurrentDomain)
			{
				if (AppDomain.CurrentDomain.GetData("sct.craft.owner") != null)
				{
					return;
				}
				AppDomain.CurrentDomain.SetData("sct.craft.owner", owner);
				_isOwner = true;
			}
			HarmonyMethod val = new HarmonyMethod(typeof(CraftCosts), "SyncPrefix", (Type[])null);
			string[] array = new string[3] { "Open", "RefreshCostItems", "TryPurchase" };
			foreach (string text in array)
			{
				MethodInfo methodInfo = AccessTools.Method(typeof(CraftMenu), text, (Type[])null, (Type[])null);
				if (methodInfo != null)
				{
					harmony.Patch((MethodBase)methodInfo, val, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				}
			}
		}

		private static void SyncPrefix()
		{
			Safe.Run("Coûts de craft", Sync);
		}

		public static void Sync()
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			if (!_isOwner)
			{
				return;
			}
			Dictionary<BuildType, List<ResourceTypeQuantity>> craftingCosts = CraftMenu._craftingCosts;
			if (craftingCosts == null)
			{
				return;
			}
			float factor = Factor;
			bool flag = !Mathf.Approximately(factor, _appliedFactor);
			for (int i = 0; i < 512; i++)
			{
				BuildType val = (BuildType)i;
				if (!craftingCosts.ContainsKey(val))
				{
					continue;
				}
				List<ResourceTypeQuantity> val2 = craftingCosts[val];
				if (!Originals.TryGetValue(i, out var value) || value.Length != val2.Count)
				{
					value = new int[val2.Count];
					for (int j = 0; j < val2.Count; j++)
					{
						value[j] = val2[j].quantity;
					}
					Originals[i] = value;
					flag = true;
				}
				if (flag)
				{
					for (int k = 0; k < val2.Count; k++)
					{
						ResourceTypeQuantity val3 = val2[k];
						val3.quantity = ((factor >= 1f) ? value[k] : Mathf.Max(1, Mathf.CeilToInt((float)value[k] * factor)));
						val2[k] = val3;
					}
				}
			}
			_appliedFactor = factor;
		}

		public static void AddRecipe(BuildType type, params (ResourceType Resource, int Quantity)[] ingredients)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			Dictionary<BuildType, List<ResourceTypeQuantity>> craftingCosts = CraftMenu._craftingCosts;
			List<ResourceTypeQuantity> val = new List<ResourceTypeQuantity>();
			for (int i = 0; i < ingredients.Length; i++)
			{
				var (resourceType, quantity) = ingredients[i];
				val.Add(new ResourceTypeQuantity
				{
					resourceType = resourceType,
					quantity = quantity
				});
			}
			craftingCosts[type] = val;
		}
	}
	internal static class DifficultyApi
	{
		private const string NameKey = "sct.difficulty.name";

		private const string OresKey = "sct.difficulty.ores";

		private const string LevelsKey = "sct.difficulty.levels";

		private const string SetterKey = "sct.difficulty.set";

		public const string Normal = "Normal";

		public static bool Installed => AppDomain.CurrentDomain.GetData("sct.difficulty.levels") is string[];

		public static string Name
		{
			get
			{
				if (!(AppDomain.CurrentDomain.GetData("sct.difficulty.name") is Func<string> func))
				{
					return "Normal";
				}
				return func() ?? "Normal";
			}
		}

		public static float OreFactor
		{
			get
			{
				if (!(AppDomain.CurrentDomain.GetData("sct.difficulty.ores") is Func<float> func))
				{
					return 1f;
				}
				return func();
			}
		}

		public static string[] Levels => (AppDomain.CurrentDomain.GetData("sct.difficulty.levels") as string[]) ?? Array.Empty<string>();

		public static void Set(string level)
		{
			if (AppDomain.CurrentDomain.GetData("sct.difficulty.set") is Action<string> action)
			{
				action(level);
			}
		}

		public static void Publish(Func<string> name, Func<float> ores, string[] levels, Action<string> setter)
		{
			AppDomain.CurrentDomain.SetData("sct.difficulty.name", name);
			AppDomain.CurrentDomain.SetData("sct.difficulty.ores", ores);
			AppDomain.CurrentDomain.SetData("sct.difficulty.levels", levels);
			AppDomain.CurrentDomain.SetData("sct.difficulty.set", setter);
		}

		public static int ScaleCount(int count, float factor)
		{
			if (count > 0)
			{
				return Mathf.Max(1, Mathf.RoundToInt((float)count * factor));
			}
			return count;
		}
	}
	internal static class EndlessApi
	{
		private const string TierKey = "sct.endless.tier";

		public static int Tier
		{
			get
			{
				if (!(AppDomain.CurrentDomain.GetData("sct.endless.tier") is Func<int> func))
				{
					return 0;
				}
				return func();
			}
		}

		public static int EffectiveTier(int saveTier)
		{
			return Math.Max(saveTier, Tier);
		}

		public static void Publish(Func<int> tier)
		{
			AppDomain.CurrentDomain.SetData("sct.endless.tier", tier);
		}
	}
	internal static class GameInstance
	{
		private const string IndexKey = "sct.instance.index";

		private const string MutexKey = "sct.instance.mutex";

		private const string ErrorKey = "sct.instance.error";

		private const string MutexName = "SCT_SpaceCatDigger_Instance_";

		public const int Max = 4;

		public static int Index
		{
			get
			{
				object data = AppDomain.CurrentDomain.GetData("sct.instance.index");
				if (data is int)
				{
					return (int)data;
				}
				int i = 0;
				Mutex data2 = null;
				for (; i < 4; i++)
				{
					bool createdNew;
					Mutex mutex = new Mutex(initiallyOwned: false, "SCT_SpaceCatDigger_Instance_" + i, out createdNew);
					if (createdNew)
					{
						data2 = mutex;
						break;
					}
					mutex.Dispose();
				}
				AppDomain.CurrentDomain.SetData("sct.instance.mutex", data2);
				AppDomain.CurrentDomain.SetData("sct.instance.index", i);
				if (i > 0)
				{
					PrepareTestSaves(i);
				}
				return i;
			}
		}

		public static bool IsTest => Index > 0;

		public static string Suffix
		{
			get
			{
				if (!IsTest)
				{
					return "";
				}
				return "_test" + (Index + 1);
			}
		}

		public static string SaveDirectory => DirectoryOf(Index);

		public static string Error => AppDomain.CurrentDomain.GetData("sct.instance.error") as string;

		private static string DirectoryOf(int index)
		{
			if (index <= 0)
			{
				return Application.persistentDataPath;
			}
			return Path.Combine(Application.persistentDataPath, "coop_test_" + (index + 1));
		}

		public static int OthersRunning()
		{
			int index = Index;
			int num = 0;
			for (int i = 0; i < 4; i++)
			{
				if (i != index && Mutex.TryOpenExisting("SCT_SpaceCatDigger_Instance_" + i, out Mutex result))
				{
					result.Dispose();
					num++;
				}
			}
			return num;
		}

		private static void PrepareTestSaves(int index)
		{
			//IL_014a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0151: Expected O, but got Unknown
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Expected O, but got Unknown
			ManualLogSource val = Logger.CreateLogSource("SCT Instance");
			bool flag = default(bool);
			try
			{
				string persistentDataPath = Application.persistentDataPath;
				string text = DirectoryOf(index);
				Directory.CreateDirectory(text);
				string[] files = Directory.GetFiles(text);
				for (int i = 0; i < files.Length; i++)
				{
					File.Delete(files[i]);
				}
				files = Directory.GetFiles(persistentDataPath);
				foreach (string text2 in files)
				{
					string fileName = Path.GetFileName(text2);
					if (fileName == "persistent.save" || fileName.StartsWith("sct_", StringComparison.Ordinal))
					{
						File.Copy(text2, Path.Combine(text, fileName), overwrite: true);
					}
				}
				string text3 = text + "/game.save";
				string text4 = text + "/persistent.save";
				SaveSystem.GameFileName = text3;
				SaveSystem.PersistentFileName = text4;
				if (SaveSystem.GameFileName != text3 || SaveSystem.PersistentFileName != text4)
				{
					throw new InvalidOperationException("chemins de sauvegarde du jeu non modifiables");
				}
				BepInExInfoLogInterpolatedStringHandler val2 = new BepInExInfoLogInterpolatedStringHandler(58, 2, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("Exemplaire n° ");
					((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<int>(index + 1);
					((BepInExLogInterpolatedStringHandler)val2).AppendLiteral(" du jeu sur ce PC : sauvegarde de test dans ");
					((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>(text);
				}
				val.LogInfo(val2);
			}
			catch (Exception ex)
			{
				AppDomain.CurrentDomain.SetData("sct.instance.error", ex.Message);
				BepInExErrorLogInterpolatedStringHandler val3 = new BepInExErrorLogInterpolatedStringHandler(97, 2, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val3).AppendLiteral("Exemplaire n° ");
					((BepInExLogInterpolatedStringHandler)val3).AppendFormatted<int>(index + 1);
					((BepInExLogInterpolatedStringHandler)val3).AppendLiteral(" : sauvegarde de test impossible (");
					((BepInExLogInterpolatedStringHandler)val3).AppendFormatted<string>(ex.Message);
					((BepInExLogInterpolatedStringHandler)val3).AppendLiteral("). CET EXEMPLAIRE ÉCRIT DANS LA VRAIE SAUVEGARDE.");
				}
				val.LogError(val3);
			}
		}
	}
	internal static class Il2CppUpgradeList
	{
		private static bool _layoutReady;

		private static bool _layoutValid;

		private static int _elementSize;

		private static int _offType;

		private static int _offValues;

		private static int _offCosts;

		private static int _offTiers;

		private static readonly int ArrayHeader = 4 * IntPtr.Size;

		public static bool LayoutValid
		{
			get
			{
				EnsureLayout();
				return _layoutValid;
			}
		}

		public static string Layout
		{
			get
			{
				EnsureLayout();
				return $"élément {_elementSize} octets, type +{_offType}, values +{_offValues}, costs +{_offCosts}, availableTiers +{_offTiers}, contrôle {(_layoutValid ? "OK" : "ÉCHEC")}";
			}
		}

		public static int Count => UpgradeManager.Upgrades._size;

		private static void EnsureLayout()
		{
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Invalid comparison between Unknown and I4
			if (_layoutReady)
			{
				return;
			}
			IntPtr nativeClassPtr = Il2CppClassPointerStore<UpgradeData>.NativeClassPtr;
			_elementSize = IL2CPP.il2cpp_class_array_element_size(nativeClassPtr);
			int num = 2 * IntPtr.Size;
			_offType = FieldOffset(nativeClassPtr, "upgradeType") - num;
			_offValues = FieldOffset(nativeClassPtr, "values") - num;
			_offCosts = FieldOffset(nativeClassPtr, "costs") - num;
			_offTiers = FieldOffset(nativeClassPtr, "availableTiers") - num;
			_layoutReady = true;
			_layoutValid = false;
			try
			{
				if (_elementSize >= 4 + 3 * IntPtr.Size && _offType >= 0 && _offValues >= 0 && _offCosts >= 0 && _offTiers >= 0 && Math.Max(Math.Max(_offValues, _offCosts), _offTiers) + IntPtr.Size <= _elementSize && Count > 0 && (int)TypeAt(0) == 1)
				{
					IntPtr intPtr = Marshal.ReadIntPtr(Element(0) + _offValues);
					IntPtr intPtr2 = Marshal.ReadIntPtr(Element(0) + _offCosts);
					_layoutValid = intPtr != IntPtr.Zero && intPtr2 != IntPtr.Zero && IL2CPP.il2cpp_array_length(intPtr) == IL2CPP.il2cpp_array_length(intPtr2) && IL2CPP.il2cpp_array_length(intPtr) > 1;
				}
			}
			catch (Exception)
			{
				_layoutValid = false;
			}
		}

		private static int FieldOffset(IntPtr cls, string name)
		{
			IntPtr intPtr = IL2CPP.il2cpp_class_get_field_from_name(cls, name);
			if (intPtr == IntPtr.Zero)
			{
				throw new MissingFieldException("UpgradeManager.UpgradeData", name);
			}
			return (int)IL2CPP.il2cpp_field_get_offset(intPtr);
		}

		private static IntPtr Element(int index)
		{
			EnsureLayout();
			return ((Il2CppObjectBase)UpgradeManager.Upgrades._items).Pointer + ArrayHeader + index * _elementSize;
		}

		public static UpgradeType TypeAt(int index)
		{
			return (UpgradeType)Marshal.ReadInt32(Element(index) + _offType);
		}

		public static Il2CppStructArray<int> CostsAt(int index)
		{
			IntPtr intPtr = Marshal.ReadIntPtr(Element(index) + _offCosts);
			if (!(intPtr == IntPtr.Zero))
			{
				return new Il2CppStructArray<int>(intPtr);
			}
			return null;
		}

		public static Il2CppStructArray<int> TiersAt(int index)
		{
			IntPtr intPtr = Marshal.ReadIntPtr(Element(index) + _offTiers);
			if (!(intPtr == IntPtr.Zero))
			{
				return new Il2CppStructArray<int>(intPtr);
			}
			return null;
		}

		public static int IndexOf(UpgradeType type)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			int count = Count;
			for (int i = 0; i < count; i++)
			{
				if (TypeAt(i) == type)
				{
					return i;
				}
			}
			return -1;
		}

		public static bool Append(UpgradeType type, float[] values, int[] costs, int[] availableTiers)
		{
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Expected I4, but got Unknown
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Invalid comparison between I4 and Unknown
			if (!LayoutValid)
			{
				return false;
			}
			List<UpgradeData> upgrades = UpgradeManager.Upgrades;
			int size = upgrades._size;
			if (size >= (int)IL2CPP.il2cpp_array_length(((Il2CppObjectBase)upgrades._items).Pointer))
			{
				upgrades.Capacity = Math.Max(4, size * 2);
			}
			IntPtr pointer = ((Il2CppObjectBase)upgrades._items).Pointer;
			IntPtr intPtr = pointer + ArrayHeader + size * _elementSize;
			for (int i = 0; i < _elementSize; i++)
			{
				Marshal.WriteByte(intPtr, i, 0);
			}
			Il2CppStructArray<float> val = new Il2CppStructArray<float>(values);
			Il2CppStructArray<int> val2 = new Il2CppStructArray<int>(costs);
			Il2CppStructArray<int> val3 = new Il2CppStructArray<int>(availableTiers);
			Marshal.WriteInt32(intPtr + _offType, (int)type);
			IL2CPP.il2cpp_gc_wbarrier_set_field(pointer, intPtr + _offValues, ((Il2CppObjectBase)val).Pointer);
			IL2CPP.il2cpp_gc_wbarrier_set_field(pointer, intPtr + _offCosts, ((Il2CppObjectBase)val2).Pointer);
			IL2CPP.il2cpp_gc_wbarrier_set_field(pointer, intPtr + _offTiers, ((Il2CppObjectBase)val3).Pointer);
			if (Marshal.ReadInt32(intPtr + _offType) != (int)type || !(Marshal.ReadIntPtr(intPtr + _offValues) == ((Il2CppObjectBase)val).Pointer) || !(Marshal.ReadIntPtr(intPtr + _offCosts) == ((Il2CppObjectBase)val2).Pointer) || !(Marshal.ReadIntPtr(intPtr + _offTiers) == ((Il2CppObjectBase)val3).Pointer))
			{
				for (int j = 0; j < _elementSize; j++)
				{
					Marshal.WriteByte(intPtr, j, 0);
				}
				return false;
			}
			upgrades._size = size + 1;
			int version = upgrades._version;
			upgrades._version = version + 1;
			GC.KeepAlive(val);
			GC.KeepAlive(val2);
			GC.KeepAlive(val3);
			return true;
		}

		public static string InteropView(int index)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Expected I4, but got Unknown
			try
			{
				UpgradeData val = UpgradeManager.Upgrades[index];
				return $"interop lit type={(int)val.upgradeType}, values={((Il2CppArrayBase<float>)(object)val.values)?.Length}, costs={((Il2CppArrayBase<int>)(object)val.costs)?.Length}";
			}
			catch (Exception ex)
			{
				return "interop : " + ex.GetType().Name;
			}
		}
	}
	internal static class Il2CppUtil
	{
		public static bool IsPlayer(Driller driller)
		{
			if (driller != null)
			{
				return (Object)(object)((Il2CppObjectBase)driller).TryCast<Player>() != (Object)null;
			}
			return false;
		}

		public static string Guid(BasePlugin plugin)
		{
			return MetadataHelper.GetMetadata((object)plugin).GUID;
		}

		public static IEnumerable<PluginInfo> Plugins()
		{
			if (IL2CPPChainloader.Instance == null)
			{
				yield break;
			}
			foreach (PluginInfo value in ((BaseChainloader<BasePlugin>)(object)IL2CPPChainloader.Instance).Plugins.Values)
			{
				yield return value;
			}
		}
	}
	internal static class Safe
	{
		private static readonly ManualLogSource Log = Logger.CreateLogSource("SCT Safe");

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

		public static void Run(string where, Action action)
		{
			try
			{
				action();
			}
			catch (Exception e)
			{
				Report(where, e);
			}
		}

		public static bool Prefix(string where, Func<bool> prefix)
		{
			try
			{
				return prefix();
			}
			catch (Exception e)
			{
				Report(where, e);
				return true;
			}
		}

		private static void Report(string where, Exception e)
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Expected O, but got Unknown
			if (Reported.Add(where + e.GetType().Name + e.Message))
			{
				bool flag = default(bool);
				BepInExErrorLogInterpolatedStringHandler val = new BepInExErrorLogInterpolatedStringHandler(33, 4, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(where);
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" : ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(e.GetType().Name);
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" : ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(e.Message);
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" (ignoré, le jeu continue)\n");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(e.StackTrace);
				}
				Log.LogError(val);
			}
		}
	}
	internal static class Vanilla
	{
		private const string Key = "sct.vanilla";

		public static bool Active
		{
			get
			{
				object data = AppDomain.CurrentDomain.GetData("sct.vanilla");
				bool flag = default(bool);
				int num;
				if (data is bool)
				{
					flag = (bool)data;
					num = 1;
				}
				else
				{
					num = 0;
				}
				return (byte)((uint)num & (flag ? 1u : 0u)) != 0;
			}
		}

		public static void Set(bool active)
		{
			AppDomain.CurrentDomain.SetData("sct.vanilla", active);
		}
	}
	internal static class Lang
	{
		public static bool IsFrench
		{
			get
			{
				try
				{
					Locale selectedLocale = LocalizationSettings.SelectedLocale;
					return ((selectedLocale != null) ? selectedLocale.Identifier.Code : null)?.StartsWith("fr", StringComparison.OrdinalIgnoreCase) ?? false;
				}
				catch (Exception)
				{
					return false;
				}
			}
		}

		public static string Pick(string fr, string en)
		{
			if (!IsFrench)
			{
				return en;
			}
			return fr;
		}
	}
	internal enum ColorVision
	{
		Normal,
		Protanopia,
		Deuteranopia,
		Tritanopia
	}
	internal static class Palette
	{
		public const string VisionKey = "sct.colorblind.vision";

		public const string RedundantKey = "sct.colorblind.redundant";

		private static readonly Color Black = C(0);

		private static readonly Color Orange = C(15113984);

		private static readonly Color SkyBlue = C(5682409);

		private static readonly Color Green = C(40563);

		private static readonly Color Yellow = C(15787074);

		private static readonly Color Blue = C(29362);

		private static readonly Color Vermillion = C(13983232);

		private static readonly Color Purple = C(13400487);

		private static readonly Color White = C(16777215);

		private static readonly Color Grey = C(7237230);

		public static ColorVision Vision
		{
			get
			{
				object data = AppDomain.CurrentDomain.GetData("sct.colorblind.vision");
				if (data is int)
				{
					return (ColorVision)(int)data;
				}
				return ColorVision.Normal;
			}
		}

		public static bool Adapted => Vision != ColorVision.Normal;

		public static bool Redundant
		{
			get
			{
				if (Adapted)
				{
					object data = AppDomain.CurrentDomain.GetData("sct.colorblind.redundant");
					bool flag = default(bool);
					int num;
					if (data is bool)
					{
						flag = (bool)data;
						num = 1;
					}
					else
					{
						num = 0;
					}
					return num == 0 || flag;
				}
				return false;
			}
		}

		private static bool RedGreen
		{
			get
			{
				if (Vision != ColorVision.Protanopia)
				{
					return Vision == ColorVision.Deuteranopia;
				}
				return true;
			}
		}

		public static Color Good(Color usual)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			if (Adapted)
			{
				if (!RedGreen)
				{
					return Green;
				}
				return SkyBlue;
			}
			return usual;
		}

		public static Color Bad(Color usual)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			if (Adapted)
			{
				return Vermillion;
			}
			return usual;
		}

		public static Color Warning(Color usual)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			if (Adapted)
			{
				if (!RedGreen)
				{
					return Orange;
				}
				return Yellow;
			}
			return usual;
		}

		public static Color Danger(Color usual)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			if (Adapted)
			{
				if (!RedGreen)
				{
					return C(16719904);
				}
				return Vermillion;
			}
			return usual;
		}

		public static Color Accent(Color usual)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			if (Adapted)
			{
				if (!RedGreen)
				{
					return Purple;
				}
				return SkyBlue;
			}
			return usual;
		}

		public static string GoodHex(string usual = "80ff80")
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			if (!Adapted)
			{
				return usual;
			}
			return Hex(Good(White));
		}

		public static string BadHex(string usual = "ff8080")
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			if (!Adapted)
			{
				return usual;
			}
			return Hex(Bad(White));
		}

		public static string WarningHex(string usual = "ffcc66")
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			if (!Adapted)
			{
				return usual;
			}
			return Hex(Warning(White));
		}

		public static Color Ore(ResourceType type, Color usual)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Expected I4, but got Unknown
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			if (!Adapted)
			{
				return usual;
			}
			bool flag = Vision == ColorVision.Tritanopia;
			switch (type - 2)
			{
			case 9:
				return Grey;
			case 0:
				if (!flag)
				{
					return Blue;
				}
				return Vermillion;
			case 2:
				return Orange;
			case 4:
				return White;
			case 6:
				if (!flag)
				{
					return Yellow;
				}
				return C(16756912);
			case 8:
				return SkyBlue;
			case 10:
				if (!flag)
				{
					return Purple;
				}
				return Blue;
			case 11:
				if (!flag)
				{
					return Green;
				}
				return C(8323072);
			case 12:
				if (!flag)
				{
					return Vermillion;
				}
				return Black;
			default:
				return usual;
			}
		}

		public static Color Tier(int level, Color usual)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: 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_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: 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_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			if (!Adapted || level <= 0)
			{
				return usual;
			}
			Color[] array = (Color[])(object)((Vision != ColorVision.Tritanopia) ? new Color[4] { Blue, Orange, White, Yellow } : new Color[4] { SkyBlue, Vermillion, White, Purple });
			return array[Mathf.Clamp(level, 1, array.Length) - 1];
		}

		public static Color Marker(int index, Color usual)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: 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_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			if (!Adapted)
			{
				return usual;
			}
			Color[] array = (Color[])(object)((Vision != ColorVision.Tritanopia) ? new Color[5] { Yellow, SkyBlue, Orange, White, Purple } : new Color[5]
			{
				Vermillion,
				White,
				SkyBlue,
				C(16756912),
				Green
			});
			return array[Math.Abs(index) % array.Length];
		}

		public static float Blink(float speed = 3f)
		{
			if (!Redundant)
			{
				return 1f;
			}
			return 0.45f + 0.55f * Mathf.Abs(Mathf.Sin(Time.unscaledTime * speed));
		}

		public static string Hex(Color c)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			return $"{Mathf.RoundToInt(Mathf.Clamp01(c.r) * 255f):X2}{Mathf.RoundToInt(Mathf.Clamp01(c.g) * 255f):X2}{Mathf.RoundToInt(Mathf.Clamp01(c.b) * 255f):X2}";
		}

		private static Color C(int rgb)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			return new Color((float)((rgb >> 16) & 0xFF) / 255f, (float)((rgb >> 8) & 0xFF) / 255f, (float)(rgb & 0xFF) / 255f);
		}
	}
	internal static class PlayerLight
	{
		private static readonly Dictionary<IntPtr, bool> IsPlayerEmitter = new Dictionary<IntPtr, bool>();

		private static readonly List<IntPtr> Scaled = new List<IntPtr>(8);

		public static void Scale(LightEmitter emitter, float multiplier)
		{
			if (!IsPlayerEmitter.TryGetValue(((Il2CppObjectBase)emitter).Pointer, out var value))
			{
				value = (Object)(object)((Component)emitter).GetComponentInParent<Build>() == (Object)null;
				IsPlayerEmitter[((Il2CppObjectBase)emitter).Pointer] = value;
			}
			if (value)
			{
				Scaled.Clear();
				Apply((Component)(object)emitter.lightRenderer, multiplier);
				Apply((Component)(object)emitter.smallLightRenderer, multiplier);
				Apply((Component)(object)emitter.smallMask, multiplier);
				Apply((Component)(object)emitter.bigMask, multiplier);
				Apply((Component)(object)emitter.shadowMask, multiplier);
				Apply((Component)(object)emitter.backgroundMask, multiplier);
			}
		}

		private static void Apply(Component component, float multiplier)
		{
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)component == (Object)null))
			{
				Transform transform = component.transform;
				if (!Scaled.Contains(((Il2CppObjectBase)transform).Pointer))
				{
					Scaled.Add(((Il2CppObjectBase)transform).Pointer);
					transform.localScale *= multiplier;
				}
			}
		}
	}
	internal static class PngLoader
	{
		public static Texture2D LoadTexture(byte[] png)
		{
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Expected O, but got Unknown
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			int width;
			int height;
			byte[] array = Decode(png, out width, out height);
			Color[] array2 = (Color[])(object)new Color[width * height];
			for (int i = 0; i < height; i++)
			{
				int num = (height - 1 - i) * width * 4;
				int num2 = i * width;
				int num3 = 0;
				while (num3 < width)
				{
					array2[num2 + num3] = new Color((float)(int)array[num] / 255f, (float)(int)array[num + 1] / 255f, (float)(int)array[num + 2] / 255f, (float)(int)array[num + 3] / 255f);
					num3++;
					num += 4;
				}
			}
			Texture2D val = new Texture2D(width, height, (TextureFormat)4, false)
			{
				filterMode = (FilterMode)0,
				wrapMode = (TextureWrapMode)1
			};
			val.SetPixels(Il2CppStructArray<Color>.op_Implicit(array2));
			val.Apply(false);
			return val;
		}

		public static byte[] Decode(byte[] png, out int width, out int height)
		{
			if (png.Length < 8 || png[0] != 137 || png[1] != 80 || png[2] != 78 || png[3] != 71)
			{
				throw new InvalidDataException("pas un PNG");
			}
			width = (height = 0);
			int num = -1;
			byte[] array = null;
			byte[] array2 = null;
			using MemoryStream memoryStream = new MemoryStream();
			int num3;
			int num4;
			for (int num2 = 8; num2 + 8 <= png.Length; num2 = num4 + num3 + 4)
			{
				num3 = ReadInt(png, num2);
				string text = Encoding.ASCII.GetString(png, num2 + 4, 4);
				num4 = num2 + 8;
				if (num3 < 0 || num4 + num3 > png.Length)
				{
					throw new InvalidDataException("PNG tronqué");
				}
				switch (text)
				{
				case "IHDR":
					width = ReadInt(png, num4);
					height = ReadInt(png, num4 + 4);
					num = png[num4 + 9];
					if (png[num4 + 8] == 8 && png[num4 + 12] == 0)
					{
						continue;
					}
					throw new NotSupportedException("PNG 8 bits non entrelacé attendu");
				case "PLTE":
					array = png.AsSpan(num4, num3).ToArray();
					continue;
				case "tRNS":
					array2 = png.AsSpan(num4, num3).ToArray();
					continue;
				case "IDAT":
					memoryStream.Write(png, num4, num3);
					continue;
				default:
					continue;
				case "IEND":
					break;
				}
				break;
			}
			int num5 = num switch
			{
				0 => 1, 
				2 => 3, 
				3 => 1, 
				4 => 2, 
				6 => 4, 
				_ => throw new NotSupportedException($"type de couleur PNG {num}"), 
			};
			if (width <= 0 || height <= 0)
			{
				throw new InvalidDataException("PNG sans en-tête");
			}
			if (num == 3 && array == null)
			{
				throw new InvalidDataException("PNG sans palette");
			}
			int num6 = width * num5;
			byte[] array3 = new byte[(num6 + 1) * height];
			memoryStream.Position = 0L;
			using (ZLibStream zLibStream = new ZLibStream(memoryStream, CompressionMode.Decompress))
			{
				int num7;
				for (int i = 0; i < array3.Length; i += num7)
				{
					num7 = zLibStream.Read(array3, i, array3.Length - i);
					if (num7 <= 0)
					{
						throw new InvalidDataException("données PNG incomplètes");
					}
				}
			}
			byte[] array4 = new byte[num6 * height];
			for (int j = 0; j < height; j++)
			{
				int num8 = array3[j * (num6 + 1)];
				int num9 = j * (num6 + 1) + 1;
				int num10 = j * num6;
				int num11 = num10 - num6;
				for (int k = 0; k < num6; k++)
				{
					int num12 = ((k >= num5) ? array4[num10 + k - num5] : 0);
					int num13 = ((j > 0) ? array4[num11 + k] : 0);
					int upLeft = ((j > 0 && k >= num5) ? array4[num11 + k - num5] : 0);
					int num14 = num8 switch
					{
						0 => 0, 
						1 => num12, 
						2 => num13, 
						3 => (num12 + num13) / 2, 
						4 => Paeth(num12, num13, upLeft), 
						_ => throw new InvalidDataException($"filtre PNG {num8}"), 
					};
					array4[num10 + k] = (byte)(array3[num9 + k] + num14);
				}
			}
			if (num == 6)
			{
				return array4;
			}
			byte[] array5 = new byte[width * height * 4];
			int num15 = 0;
			int num16 = 0;
			int num17 = 0;
			while (num15 < width * height)
			{
				switch (num)
				{
				case 0:
					array5[num17] = (array5[num17 + 1] = (array5[num17 + 2] = array4[num16]));
					array5[num17 + 3] = byte.MaxValue;
					break;
				case 2:
					array5[num17] = array4[num16];
					array5[num17 + 1] = array4[num16 + 1];
					array5[num17 + 2] = array4[num16 + 2];
					array5[num17 + 3] = byte.MaxValue;
					break;
				case 3:
				{
					int num18 = array4[num16];
					if (num18 * 3 + 2 >= array.Length)
					{
						throw new InvalidDataException("couleur hors palette");
					}
					array5[num17] = array[num18 * 3];
					array5[num17 + 1] = array[num18 * 3 + 1];
					array5[num17 + 2] = array[num18 * 3 + 2];
					array5[num17 + 3] = ((array2 != null && num18 < array2.Length) ? array2[num18] : byte.MaxValue);
					break;
				}
				case 4:
					array5[num17] = (array5[num17 + 1] = (array5[num17 + 2] = array4[num16]));
					array5[num17 + 3] = array4[num16 + 1];
					break;
				}
				num15++;
				num16 += num5;
				num17 += 4;
			}
			return array5;
		}

		private static int ReadInt(byte[] bytes, int offset)
		{
			return (bytes[offset] << 24) | (bytes[offset + 1] << 16) | (bytes[offset + 2] << 8) | bytes[offset + 3];
		}

		private static int Paeth(int left, int up, int upLeft)
		{
			int num = left + up - upLeft;
			int num2 = Math.Abs(num - left);
			int num3 = Math.Abs(num - up);
			int num4 = Math.Abs(num - upLeft);
			if (num2 > num3 || num2 > num4)
			{
				if (num3 > num4)
				{
					return upLeft;
				}
				return up;
			}
			return left;
		}
	}
	internal static class RefundBonus
	{
		private const string ProvidersKey = "sct.refund.providers";

		private const string ActiveKey = "sct.refund.active";

		public static bool SalvageActive
		{
			get
			{
				if (!(AppDomain.CurrentDomain.GetData("sct.refund.active") is Dictionary<string, Func<bool>> dictionary))
				{
					return false;
				}
				foreach (Func<bool> value in dictionary.Values)
				{
					try
					{
						if (value())
						{
							return true;
						}
					}
					catch (Exception)
					{
					}
				}
				return false;
			}
		}

		public static float Total
		{
			get
			{
				float num = 0f;
				if (AppDomain.CurrentDomain.GetData("sct.refund.providers") is Dictionary<string, Func<float>> dictionary)
				{
					foreach (Func<float> value in dictionary.Values)
					{
						try
						{
							num += Mathf.Max(0f, value());
						}
						catch (Exception)
						{
						}
					}
				}
				return num;
			}
		}

		public static void Register(string id, Func<float> bonus, Func<bool> active)
		{
			lock (AppDomain.CurrentDomain)
			{
				Dictionary<string, Func<float>> dictionary = (AppDomain.CurrentDomain.GetData("sct.refund.providers") as Dictionary<string, Func<float>>) ?? new Dictionary<string, Func<float>>();
				dictionary[id] = bonus;
				AppDomain.CurrentDomain.SetData("sct.refund.providers", dictionary);
				Dictionary<string, Func<bool>> dictionary2 = (AppDomain.CurrentDomain.GetData("sct.refund.active") as Dictionary<string, Func<bool>>) ?? new Dictionary<string, Func<bool>>();
				dictionary2[id] = active;
				AppDomain.CurrentDomain.SetData("sct.refund.active", dictionary2);
			}
		}
	}
	internal static class RunEnd
	{
		public static bool WillEndThisFrame(Game game)
		{
			if ((Object)(object)game != (Object)null && !game._runEnded && !game.paused && game.started && game._runTimer <= 0f)
			{
				return game._runTimerTick + Time.deltaTime >= 1f;
			}
			return false;
		}
	}
	internal static class SaveSlotApi
	{
		private const string VersionKey = "sct.saveslot.version";

		public const string Prefix = "sct_";

		public static string Directory => GameInstance.SaveDirectory;

		public static int Version
		{
			get
			{
				object data = AppDomain.CurrentDomain.GetData("sct.saveslot.version");
				if (data is int)
				{
					return (int)data;
				}
				return 0;
			}
		}

		public static string PathOf(string name)
		{
			return Path.Combine(Directory, "sct_" + name);
		}

		public static void BumpVersion()
		{
			AppDomain.CurrentDomain.SetData("sct.saveslot.version", Version + 1);
		}

		public static void Migrate(string oldPath, string name)
		{
			try
			{
				string text = PathOf(name);
				if (File.Exists(oldPath) && !File.Exists(text))
				{
					File.Move(oldPath, text);
				}
			}
			catch (Exception)
			{
			}
		}
	}
	internal static class SctGui
	{
		public const float LineHeight = 22f;

		public const float Gap = 4f;

		public static bool Themed = true;

		public const string TextHex = "EEF1F6";

		public const string MutedHex = "AEB8C8";

		private static readonly Dictionary<string, GUIStyle> ThemeStyles = new Dictionary<string, GUIStyle>();

		private static readonly ManualLogSource Log = Logger.CreateLogSource("SctGui");

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

		private static bool _useBroken;

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

		private static GUIStyle _button;

		private static GUIStyle _buttonHover;

		private static GUIStyle _buttonOn;

		private static GUIStyle _check;

		private static GUIStyle _label;

		private static GUIStyle _richBox;

		private static GUIStyle _buttonToggle;

		public static float Row
		{
			get
			{
				if (!Themed)
				{
					return 22f;
				}
				return 26f;
			}
		}

		public static float TitleHeight
		{
			get
			{
				if (!Themed)
				{
					return 20f;
				}
				return 30f;
			}
		}

		public static float Chrome
		{
			get
			{
				if (!Themed)
				{
					return 36f;
				}
				return 44f;
			}
		}

		private static Color TextColor => C(15659510);

		private static Color AccentColor => C(3105992);

		private static GUIStyle Panel => Solid("panel", C(1448482, 0.97f), 14, (TextAnchor)0, 10);

		private static GUIStyle Border => Solid("border", C(3950432), 14, (TextAnchor)3);

		private static GUIStyle TitleBar => Solid("title", C(2304568), 15, (TextAnchor)3, 10);

		private static GUIStyle Section => Solid("section", C(2041137), 14, (TextAnchor)3);

		private static GUIStyle Field => Solid("field", C(856086), 14, (TextAnchor)3, 6);

		private static GUIStyle Accent => Solid("accent", AccentColor, 14, (TextAnchor)3);

		private static GUIStyle Mark => Solid("mark", TextColor, 14, (TextAnchor)3);

		public static GUIStyle ScrollThumb
		{
			get
			{
				//IL_0021: Unknown result type (might be due to invalid IL or missing references)
				if (!Themed)
				{
					return GUI.skin.box;
				}
				return Solid("thumb", C(5924480), 14, (TextAnchor)3);
			}
		}

		public static GUIStyle Label
		{
			get
			{
				//IL_0012: Unknown result type (might be due to invalid IL or missing references)
				//IL_0017: Unknown result type (might be due to invalid IL or missing references)
				//IL_001e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0025: Unknown result type (might be due to invalid IL or missing references)
				//IL_002c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				//IL_0054: Expected O, but got Unknown
				//IL_0072: Unknown result type (might be due to invalid IL or missing references)
				//IL_006b: Unknown result type (might be due to invalid IL or missing references)
				if (_label == null)
				{
					GUIStyle label = GUI.skin.label;
					_label = new GUIStyle
					{
						richText = true,
						wordWrap = false,
						alignment = (TextAnchor)3,
						fontSize = (Themed ? 14 : label.fontSize),
						padding = label.padding
					};
					_label.normal.textColor = (Themed ? TextColor : label.normal.textColor);
				}
				return _label;
			}
		}

		public static GUIStyle ButtonToggle => _buttonToggle ?? (_buttonToggle = GUI.skin.button);

		public static GUIStyle RichBox => _richBox ?? (_richBox = BoxStyle(13, (TextAnchor)0));

		private static Color C(int rgb, float a = 1f)
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			return new Color((float)((rgb >> 16) & 0xFF) / 255f, (float)((rgb >> 8) & 0xFF) / 255f, (float)(rgb & 0xFF) / 255f, a);
		}

		private static GUIStyle Solid(string key, Color background, int fontSize = 14, TextAnchor alignment = (TextAnchor)3, int padding = 0, int vertical = -1)
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Expected O, but got Unknown
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Expected O, but got Unknown
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: 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_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Expected O, but got Unknown
			//IL_00c7: Expected O, but got Unknown
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			if (ThemeStyles.TryGetValue(key, out var value) && (Object)(object)value.normal.background != (Object)null)
			{
				return value;
			}
			Texture2D val = new Texture2D(1, 1, (TextureFormat)4, false)
			{
				filterMode = (FilterMode)0,
				wrapMode = (TextureWrapMode)1
			};
			val.SetPixels(Il2CppStructArray<Color>.op_Implicit((Color[])(object)new Color[1] { background }));
			val.Apply(false);
			((Object)val).hideFlags = (HideFlags)61;
			if (vertical < 0)
			{
				vertical = padding;
			}
			RectOffset padding2 = new RectOffset
			{
				left = padding,
				right = padding,
				top = vertical,
				bottom = vertical
			};
			GUIStyle val2 = new GUIStyle
			{
				alignment = alignment,
				richText = true,
				fontSize = fontSize,
				wordWrap = false,
				padding = padding2,
				border = new RectOffset()
			};
			val2.normal.background = val;
			val2.normal.textColor = TextColor;
			ThemeStyles[key] = val2;
			return val2;
		}

		private static GUIStyle ButtonStyle(bool on, bool hover)
		{
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			if (!on)
			{
				if (!hover)
				{
					return Solid("btn", C(2896966), 14, (TextAnchor)4, 4);
				}
				return Solid("btn.hover", C(3818848), 14, (TextAnchor)4, 4);
			}
			return Solid("btn.on", AccentColor, 14, (TextAnchor)4, 4);
		}

		public static void DrawFrame(Rect r, bool accent = false)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: 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)
			GUIStyle val = (accent ? Accent : Border);
			GUI.Box(new Rect(((Rect)(ref r)).x, ((Rect)(ref r)).y, ((Rect)(ref r)).width, 1f), "", val);
			GUI.Box(new Rect(((Rect)(ref r)).x, ((Rect)(ref r)).y + ((Rect)(ref r)).height - 1f, ((Rect)(ref r)).width, 1f), "", val);
			GUI.Box(new Rect(((Rect)(ref r)).x, ((Rect)(ref r)).y, 1f, ((Rect)(ref r)).height), "", val);
			GUI.Box(new Rect(((Rect)(ref r)).x + ((Rect)(ref r)).width - 1f, ((Rect)(ref r)).y, 1f, ((Rect)(ref r)).height), "", val);
		}

		public static void DrawWindowChrome(Rect local, string title)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			GUI.Box(local, "", Panel);
			GUI.Box(new Rect(((Rect)(ref local)).x, ((Rect)(ref local)).y, ((Rect)(ref local)).width, TitleHeight), "<b>" + title + "</b>", TitleBar);
			GUI.Box(new Rect(((Rect)(ref local)).x, ((Rect)(ref local)).y + TitleHeight, ((Rect)(ref local)).width, 2f), "", Accent);
			DrawFrame(local);
		}

		public static void DrawSection(Rect r)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			GUI.Box(r, "", Section);
			DrawFrame(r);
		}

		public static void DrawField(Rect r, bool focused)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			GUI.Box(r, "", Field);
			DrawFrame(r, focused);
		}

		public static void DrawBar(Rect r, float t)
		{
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			t = Mathf.Clamp01(t);
			if (Themed)
			{
				DrawField(r, focused: false);
				if (t > 0f)
				{
					GUI.Box(new Rect(((Rect)(ref r)).x + 1f, ((Rect)(ref r)).y + 1f, (((Rect)(ref r)).width - 2f) * t, ((Rect)(ref r)).height - 2f), "", Accent);
				}
			}
			else
			{
				GUI.Box(r, "");
				if (t > 0f)
				{
					GUI.Box(new Rect(((Rect)(ref r)).x, ((Rect)(ref r)).y, ((Rect)(ref r)).width * t, ((Rect)(ref r)).height), "");
				}
			}
		}

		public static bool Contains(Rect r, Vector2 p)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			if (p.x >= ((Rect)(ref r)).x && p.x < ((Rect)(ref r)).x + ((Rect)(ref r)).width && p.y >= ((Rect)(ref r)).y)
			{
				return p.y < ((Rect)(ref r)).y + ((Rect)(ref r)).height;
			}
			return false;
		}

		public static void Use(Event e)
		{
			if (_useBroken)
			{
				return;
			}
			try
			{
				e.Use();
			}
			catch (Exception e2)
			{
				_useBroken = true;
				Report("Event.Use", e2);
			}
		}

		public static void NoteClick(int owner, Vector2 position)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Expected O, but got Unknown
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			if (ClickLogged.Add(owner))
			{
				bool flag = default(bool);
				BepInExInfoLogInterpolatedStringHandler val = new BepInExInfoLogInterpolatedStringHandler(36, 3, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Fenêtre ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<int>(owner);
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" : premier clic reçu en (");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<float>(position.x, "0");
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(", ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<float>(position.y, "0");
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(")");
				}
				Log.LogInfo(val);
			}
		}

		private static GUIStyle CopyState(GUIStyle source, GUIStyleState state, TextAnchor alignment)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Expected O, but got Unknown
			GUIStyle val = new GUIStyle
			{
				alignment = alignment,
				richText = true,
				fontSize = source.fontSize,
				border = source.border,
				padding = source.padding,
				wordWrap = false
			};
			val.normal.background = state.background;
			val.normal.textColor = state.textColor;
			return val;
		}

		public static void DrawButton(Rect rect, string text, bool on)
		{
			//IL_002c: 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_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0161: Unknown result type (might be due to invalid IL or missing references)
			//IL_0166: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0153: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_016a: Unknown result type (might be due to invalid IL or missing references)
			//IL_017f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0184: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0197: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_01db: Unknown result type (might be due to invalid IL or missing references)
			if (Themed)
			{
				bool flag = GUI.enabled && Event.current != null && Contains(rect, Event.current.mousePosition);
				Color color = GUI.color;
				if (!GUI.enabled)
				{
					GUI.color = color * new Color(1f, 1f, 1f, 0.4f);
				}
				GUI.Box(rect, text, ButtonStyle(on, flag));
				if (on)
				{
					GUI.Box(new Rect(((Rect)(ref rect)).x, ((Rect)(ref rect)).y, 4f, ((Rect)(ref rect)).height), "", Mark);
				}
				DrawFrame(rect, flag && !on);
				GUI.color = color;
				return;
			}
			if (_button == null)
			{
				GUIStyle button = GUI.skin.button;
				_button = CopyState(button, button.normal, (TextAnchor)4);
				_buttonHover = CopyState(button, ((Object)(object)button.hover.background != (Object)null) ? button.hover : button.normal, (TextAnchor)4);
				_buttonOn = CopyState(button, ((Object)(object)button.onNormal.background != (Object)null) ? button.onNormal : button.active, (TextAnchor)4);
			}
			bool flag2 = GUI.enabled && Event.current != null && Contains(rect, Event.current.mousePosition);
			Color color2 = GUI.color;
			if (on)
			{
				GUI.color = color2 * new Color(0.65f, 0.9f, 1f, 1f);
			}
			else if (!GUI.enabled)
			{
				GUI.color = color2 * new Color(1f, 1f, 1f, 0.5f);
			}
			GUI.Box(rect, text, on ? _buttonOn : (flag2 ? _buttonHover : _button));
			GUI.color = color2;
		}

		public static void DrawCheck(Rect rect, string text, bool on)
		{
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0177: 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_008d: Unknown result type (might be due to invalid IL or missing references)
			if (Themed)
			{
				bool focused = GUI.enabled && Event.current != null && Contains(rect, Event.current.mousePosition);
				Rect r = default(Rect);
				((Rect)(ref r))..ctor(((Rect)(ref rect)).x, ((Rect)(ref rect)).y + (((Rect)(ref rect)).height - 18f) / 2f, 18f, 18f);
				DrawField(r, focused);
				if (on)
				{
					GUI.Box(new Rect(((Rect)(ref r)).x + 4f, ((Rect)(ref r)).y + 4f, 10f, 10f), "", Mark);
				}
				GUI.Label(new Rect(((Rect)(ref rect)).x + 26f, ((Rect)(ref rect)).y, ((Rect)(ref rect)).width - 26f, ((Rect)(ref rect)).height), text, Label);
			}
			else
			{
				if (_check == null)
				{
					_check = CopyState(GUI.skin.button, GUI.skin.button.normal, (TextAnchor)4);
				}
				GUI.Box(new Rect(((Rect)(ref rect)).x, ((Rect)(ref rect)).y + (((Rect)(ref rect)).height - 16f) / 2f, 16f, 16f), on ? "x" : "", _check);
				GUI.Label(new Rect(((Rect)(ref rect)).x + 20f, ((Rect)(ref rect)).y, ((Rect)(ref rect)).width - 20f, ((Rect)(ref rect)).height), text, Label);
			}
		}

		public static void Report(string where, Exception e)
		{
			string text = where + ": " + e.GetType().Name + ": " + e.Message;
			if (Reported.Add(text))
			{
				Log.LogWarning((object)(text + "\n" + e.StackTrace));
			}
		}

		public static GUIStyle BoxStyle(int fontSize, TextAnchor alignment)
		{
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Expected O, but got Unknown
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			if (Themed)
			{
				return Solid($"box.{fontSize}.{alignment}", C(1448482, 0.92f), fontSize, alignment, 10, ((int)alignment == 0) ? 8 : 2);
			}
			GUIStyle box = GUI.skin.box;
			GUIStyle val = new GUIStyle
			{
				alignment = alignment,
				richText = true,
				fontSize = fontSize,
				border = box.border,
				padding = box.padding,
				margin = box.margin,
				wordWrap = box.wordWrap
			};
			val.normal.background = box.normal.background;
			val.normal.textColor = box.normal.textColor;
			return val;
		}

		public static GUIStyle TextureStyle(Texture2D texture)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Expected O, but got Unknown
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected O, but got Unknown
			//IL_001b: 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_0026: Expected O, but got Unknown
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Expected O, but got Unknown
			GUIStyle val = new GUIStyle
			{
				border = new RectOffset(),
				padding = new RectOffset(),
				margin = new RectOffset()
			};
			val.normal.background = texture;
			return val;
		}

		public static void DrawTexture(Rect rect, GUIStyle textureStyle)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			GUI.Box(rect, "", textureStyle);
		}

		public static float TextHeight(string text)
		{
			return (float)Math.Max(1, text.Split('\n').Length) * (Themed ? 20f : 18f) + (Themed ? 6f : 4f);
		}
	}
	internal class SctWindow
	{
		private readonly int _id;

		private readonly Func<string> _title;

		private readonly Action<SctLayout> _content;

		private readonly WindowFunction _function;

		private readonly SctLayout _layout = new SctLayout();

		private readonly bool _modal;

		public Rect Rect;

		private float _needed;

		public bool Draggable;

		public SctWindow(int id, Rect rect, Func<string> title, Action<SctLayout> content, bool modal = false)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			_id = id;
			Rect = rect;
			_title = title;
			_content = content;
			_modal = modal;
			_function = WindowFunction.op_Implicit((Action<int>)Draw);
		}

		public void OnGUI()
		{
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			if (_needed > ((Rect)(ref Rect)).height)
			{
				Rect = new Rect(((Rect)(ref Rect)).x, Math.Min(((Rect)(ref Rect)).y, Math.Max(0f, (float)Screen.height - _needed)), ((Rect)(ref Rect)).width, Math.Min(_needed, Screen.height));
			}
			Rect = (_modal ? GUI.ModalWindow(_id, Rect, _function, _title()) : GUI.Window(_id, Rect, _function, _title()));
		}

		private void Draw(int id)
		{
			//IL_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0159: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			float num = (SctGui.Themed ? (SctGui.TitleHeight + 10f) : 22f);
			float num2 = (SctGui.Themed ? 12 : 8);
			try
			{
				if (SctGui.Themed)
				{
					SctGui.DrawWindowChrome(new Rect(0f, 0f, ((Rect)(ref Rect)).width, ((Rect)(ref Rect)).height), _title());
				}
				_layout.Begin(new Rect(num2, num, ((Rect)(ref Rect)).width - 2f * num2, ((Rect)(ref Rect)).height - num - 6f), _id);
				_content(_layout);
				_layout.End();
				_needed = _layout.Bottom + 4f;
			}
			catch (Exception ex)
			{
				SctGui.Report("Fenêtre " + _id, ex);
				GUI.Label(new Rect(num2, num, ((Rect)(ref Rect)).width - 2f * num2, 60f), "Erreur : " + ex.Message, SctGui.Label);
			}
			if (!_modal || Draggable)
			{
				GUI.DragWindow(new Rect(0f, 0f, ((Rect)(ref Rect)).width, SctGui.TitleHeight));
			}
		}
	}
	internal class SctLayout
	{
		private struct Frame
		{
			public float X;

			public float Y;

			public float Width;

			public bool Horizontal;

			public float RowX;

			public float RowHeight;
		}

		private readonly Stack<Frame> _frames = new Stack<Frame>();

		private Frame _f;

		private int _owner;

		private int _counter;

		private static string _activeSlider;

		private static string _focusedField;

		private static readonly Dictionary<string, float> ScrollOffsets = new Dictionary<string, float>();

		private static readonly Dictionary<string, float> ContentHeights = new Dictionary<string, float>();

		private static readonly Dictionary<string, float> BoxHeights = new Dictionary<string, float>();

		private readonly Stack<float> _columnTops = new Stack<float>();

		private readonly Stack<(string Key, float Top)> _boxKeys = new Stack<(string, float)>();

		private readonly Stack<(string Key, float Height)> _scrollKeys = new Stack<(string, float)>();

		public float Bottom => _f.Y;

		public float Width
		{
			get
			{
				if (!_f.Horizontal)
				{
					return _f.Width;
				}
				return _f.Width - (_f.RowX - _f.X);
			}
		}

		public static bool IsTyping => _focusedField != null;

		public void Begin(Rect area, int owner = 0)
		{
			_frames.Clear();
			_owner = owner;
			_counter = 0;
			_f = new Frame
			{
				X = ((Rect)(ref area)).x,
				Y = ((Rect)(ref area)).y,
				Width = ((Rect)(ref area)).width
			};
		}

		public void End()
		{
			if (_f.Horizontal)
			{
				EndHorizontal();
			}
		}

		private string NextKey()
		{
			return _owner + ":" + _counter++;
		}

		private Rect Next(float width, float height)
		{
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			if (_f.Horizontal)
			{
				float num = ((width < 0f) ? (_f.Width - (_f.RowX - _f.X)) : width);
				Rect result = new Rect(_f.RowX, _f.Y, num, height);
				_f.RowX += num + 4f;
				_f.RowHeight = Math.Max(_f.RowHeight, height);
				return result;
			}
			Rect result2 = new Rect(_f.X, _f.Y, (width < 0f) ? _f.Width : width, height);
			_f.Y += height + 4f;
			return result2;
		}

		public void Space(float height = 8f)
		{
			if (_f.Horizontal)
			{
				_f.RowX += height;
			}
			else
			{
				_f.Y += height;
			}
		}

		public void BeginHorizontal()
		{
			_frames.Push(_f);
			_f.Horizontal = true;
			_f.RowX = _f.X;
			_f.RowHeight = 0f;
		}

		public void EndHorizontal()
		{
			float rowHeight = _f.RowHeight;
			_f = _frames.Pop();
			_f.Y += rowHeight + 4f;
		}

		public void BeginColumn(float width = -1f)
		{
			float width2 = ((width < 0f) ? (_f.Width - (_f.RowX - _f.X)) : width);
			_frames.Push(_f);
			_columnTops.Push(_f.Y);
			_f = new Frame
			{
				X = _f.RowX,
				Y = _f.Y,
				Width = width2
			};
		}

		public void EndColumn()
		{
			float val = _f.Y - _columnTops.Pop();
			float width = _f.Width;
			_f = _frames.Pop();
			_f.RowX += width + 4f;
			_f.RowHeight = Math.Max(_f.RowHeight, val);
		}

		public void BeginBox()
		{
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			string text = NextKey();
			BoxHeights.TryGetValue(text, out var value);
			float num = (SctGui.Themed ? 10 : 6);
			float num2 = (SctGui.Themed ? 8 : 4);
			if (value > 0f)
			{
				if (SctGui.Themed)
				{
					SctGui.DrawSection(new Rect(_f.X, _f.Y, _f.Width, value));
				}
				else
				{
					GUI.Box(new Rect(_f.X, _f.Y, _f.Width, value), "");
				}
			}
			_frames.Push(_f);
			_f.X += num;
			_f.Width -= 2f * num;
			_f.Y += num2;
			_boxKeys.Push((text, _f.Y - num2));
		}

		public void EndBox()
		{
			(string Key, float Top) tuple = _boxKeys.Pop();
			string item = tuple.Key;
			float item2 = tuple.Top;
			float num = _f.Y + (float)(SctGui.Themed ? 4 : 0);
			_f = _frames.Pop();
			BoxHeights[item] = num - item2 + 2f;
			_f.Y = num + 2f + 4f;
		}

		public void Label(string text, float width = -1f)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			GUI.Label(Next(width, text.Contains("\n") ? SctGui.TextHeight(text) : SctGui.Row), text, SctGui.Label);
		}

		public void Header(string text, string hint = null)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			GUI.Label(Next(-1f, 28f), "<size=17><b>" + text + "</b></size>", SctGui.Label);
			if (hint != null)
			{
				Label($"<color=#{(SctGui.Themed ? "AEB8C8" : "999999")}>{hint}</color>");
			}
		}

		private bool Clicked(Rect rect)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: 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_0031: Unknown result type (might be due to invalid IL or missing references)
			if (!GUI.enabled)
			{
				return false;
			}
			Event current = Event.current;
			if (current == null || (int)current.type != 0 || !SctGui.Contains(rect, current.mousePosition))
			{
				return false;
			}
			SctGui.NoteClick(_owner, current.mousePosition);
			SctGui.Use(current);
			return true;
		}

		public Rect Area(float width, float height)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			return Next(width, height);
		}

		public bool AreaClick(Rect rect, out Vector2 local, out int button)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			local = Vector2.zero;
			button = -1;
			Event current = Event.current;
			if (!GUI.enabled || current == null || (int)current.type != 0 || !SctGui.Contains(rect, current.mousePosition))
			{
				return false;
			}
			local = new Vector2(current.mousePosition.x - ((Rect)(ref rect)).x, current.mousePosition.y - ((Rect)(ref rect)).y);
			try
			{
				button = current.button;
			}
			catch (Exception)
			{
				button = 0;
			}
			SctGui.NoteClick(_owner, current.mousePosition);
			SctGui.Use(current);
			return true;
		}

		public bool Button(string text, float width = -1f, float height = 0f)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			if (height <= 0f)
			{
				height = SctGui.Row;
			}
			Rect rect = Next(width, height);
			bool result = Clicked(rect);
			SctGui.DrawButton(rect, text, on: false);
			return result;
		}

		public bool Toggle(bool value, string text, float width = -1f)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: 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)
			Rect rect = Next(width, SctGui.Row);
			if (Clicked(rect))
			{
				value = !value;
			}
			SctGui.DrawCheck(rect, text, value);
			return value;
		}

		public bool ToggleButton(bool value, string text, float width = -1f, float height = 0f)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			if (height <= 0f)
			{
				height = SctGui.Row;
			}
			Rect rect = Next(width, height);
			if (Clicked(rect))
			{
				value = !value;
			}
			SctGui.DrawButton(rect, text, value);
			return value;
		}

		public int Toolbar(int selected, string[] labels, float width = -1f, float height = 0f)
		{
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			if (height <= 0f)
			{
				height = SctGui.Row;
			}
			float width2 = (((width < 0f) ? Width : width) - 4f * (float)(labels.Length - 1)) / (float)labels.Length;
			bool horizontal = _f.Horizontal;
			if (!horizontal)
			{
				BeginHorizontal();
			}
			int num = selected;
			for (int i = 0; i < labels.Length; i++)
			{
				Rect rect = Next(width2, height);
				if (Clicked(rect))
				{
					num = i;
				}
				SctGui.DrawButton(rect, labels[i], i == num);
			}
			if (!horizontal)
			{
				EndHorizontal();
			}
			return num;
		}

		public float Slider(float value, float min, float max, float width = -1f)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Invalid comparison between Unknown and I4
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0144: Invalid comparison between Unknown and I4
			//IL_015c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: Unknown result type (might be due to invalid IL or missing references)
			//IL_0151: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: Invalid comparison between Unknown and I4
			string text = NextKey();
			Rect r = Next(width, SctGui.Row);
			Rect val = default(Rect);
			((Rect)(ref val))..ctor(((Rect)(ref r)).x, ((Rect)(ref r)).y + ((Rect)(ref r)).height / 2f - 3f, ((Rect)(ref r)).width, 6f);
			float num = ((max > min) ? Mathf.Clamp01((value - min) / (max - min)) : 0f);
			Rect val2 = default(Rect);
			((Rect)(ref val2))..ctor(((Rect)(ref val)).x + num * (((Rect)(ref val)).width - 12f), ((Rect)(ref r)).y + 2f, 12f, ((Rect)(ref r)).height - 4f);
			if (SctGui.Themed)
			{
				SctGui.DrawField(val, focused: false);
				SctGui.DrawButton(val2, "", _activeSlider == text);
			}
			else
			{
				GUI.Box(val, "");
				GUI.Box(val2, "");
			}
			Event current = Event.current;
			if ((int)current.type == 0 && SctGui.Contains(r, current.mousePosition))
			{
				_activeSlider = text;
				SctGui.Use(current);
			}
			else if ((int)current.type == 1 && _activeSlider == text)
			{
				_activeSlider = null;
				SctGui.Use(current);
			}
			if (_activeSlider == text && ((int)current.type == 3 || (int)current.type == 0 || (int)current.type == 12))
			{
				float num2 = Mathf.Clamp01((current.mousePosition.x - ((Rect)(ref val)).x) / Math.Max(1f, ((Rect)(ref val)).width));
				value = min + num2 * (max - min);
			}
			return value;
		}

		public string TextField(string value, int maxLength, float width = -1f)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Invalid comparison between Unknown and I4
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Invalid comparison between Unknown and I4
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Invalid comparison between Unknown and I4
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Invalid comparison between Unknown and I4
			//IL_0167: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Invalid comparison between Unknown and I4
			string text = NextKey();
			Rect val = Next(width, SctGui.Row);
			bool flag = _focusedField == text;
			Event current = Event.current;
			if ((int)current.type == 0)
			{
				if (SctGui.Contains(val, current.mousePosition))
				{
					_focusedField = text;
					flag = true;
					SctGui.Use(current);
				}
				else if (flag)
				{
					_focusedField = null;
					flag = false;
				}
			}
			value = value ?? "";
			if (flag && (int)current.type == 4)
			{
				if ((int)current.keyCode == 8)
				{
					if (value.Length > 0)
					{
						value = value.Substring(0, value.Length - 1);
					}
					SctGui.Use(current);
				}
				else if ((int)current.keyCode == 13 || (int)current.keyCode == 271 || (int)current.keyCode == 27)
				{
					_focusedField = null;
					SctGui.Use(current);
				}
				else if (current.character != 0 && !char.IsControl(current.character))
				{
					if (value.Length < maxLength)
					{
						value += current.character;
					}
					SctGui.Use(current);
				}
			}
			bool flag2 = flag && Time.realtimeSinceStartup % 1f < 0.5f;
			if (SctGui.Themed)
			{
				SctGui.DrawField(val, flag);
			}
			else
			{
				GUI.Box(val, "");
			}
			GUI.Label(new Rect(((Rect)(ref val)).x + 6f, ((Rect)(ref val)).y, ((Rect)(ref val)).width - 12f, ((Rect)(ref val)).height), value + (flag2 ? "|" : ""), SctGui.Label);
			return value;
		}

		public void BeginScroll(float height, string id = null)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Invalid comparison between Unknown and I4
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			string text = id ?? NextKey();
			Rect r = Next(-1f, height);
			ScrollOffsets.TryGetValue(text, out var value);
			ContentHeights.TryGetValue(text, out var value2);
			Event current = Event.current;
			if ((int)current.type == 6 && SctGui.Contains(r, current.mousePosition))
			{
				value += current.delta.y * 20f;
				SctGui.Use(current);
			}
			value = Mathf.Clamp(value, 0f, Math.Max(0f, value2 - height));
			ScrollOffsets[text] = value;
			if (value2 > height)
			{
				float num = Math.Max(20f, height * height / value2);
				float num2 = ((Rect)(ref r)).y + (height - num) * (value / (value2 - height));
				GUI.Box(new Rect(((Rect)(ref r)).x + ((Rect)(ref r)).width - 6f, num2, 6f, num), "", SctGui.ScrollThumb);
			}
			GUI.BeginGroup(new Rect(((Rect)(ref r)).x, ((Rect)(ref r)).y, ((Rect)(ref r)).width - 8f, height));
			_frames.Push(_f);
			_scrollKeys.Push((text, height));
			_f = new Frame
			{
				X = 0f,
				Y = 0f - value,
				Width = ((Rect)(ref r)).width - 8f
			};
		}

		public void EndScroll()
		{
			string item = _scrollKeys.Pop().Key;
			ScrollOffsets.TryGetValue(item, out var value);
			ContentHeights[item] = _f.Y + value;
			GUI.EndGroup();
			_f = _frames.Pop();
		}
	}
}
namespace SCTAchievements
{
	public enum Domain
	{
		Success,
		Challenge,
		Mod,
		Stats
	}
	internal class Achievement
	{
		public string Id;

		public Domain Domain;

		public string SectionFr;

		public string SectionEn;

		public string NameFr;

		public string NameEn;

		public string DescFr;

		public string DescEn;

		public bool Hidden;

		public Func<bool> Available = () => true;

		public Func<Profile, bool> Condition;

		public Func<Profile, (long Current, long Target)> Progress;

		public Func<Profile, long> Counter;

		public long[] Thresholds;

		public Func<long, string> Show;

		public bool IsChallenge => Thresholds != null;

		public string Name => Lang.Pick(NameFr, NameEn);

		public string Section => Lang.Pick(SectionFr, SectionEn);

		public bool Unlocked
		{
			get
			{
				if (!IsChallenge)
				{
					return Store.Profile.unlocked.ContainsKey(Id);
				}
				return Level > 0;
			}
		}

		public int Level
		{
			get
			{
				if (!Store.Profile.levels.TryGetValue(Id, out var value))
				{
					return 0;
				}
				return value;
			}
		}

		public int MaxLevel
		{
			get
			{
				long[] thresholds = Thresholds;
				if (thresholds == null)
				{
					return 1;
				}
				return thresholds.Length;
			}
		}

		public bool Complete
		{
			get
			{
				if (!IsChallenge)
				{
					return Unlocked;
				}
				return Level >= MaxLevel;
			}
		}

		public long Value
		{
			get
			{
				if (Counter == null)
				{
					return 0L;
				}
				return Counter(Store.Profile);
			}
		}

		public string Description => string.Format(Lang.Pick(DescFr, DescEn), IsChallenge ? Display(Threshold(Level)) : "");

		public long Threshold(int level)
		{
			return Thresholds[Math.Min(level, Thresholds.Length - 1)];
		}

		public string Display(long value)
		{
			if (Show == null)
			{
				return Format(value);
			}
			return Show(value);
		}

		public string DescriptionAt(int level)
		{
			return string.Format(Lang.Pick(DescFr, DescEn), Display(Threshold(level - 1)));
		}

		public static string Format(long n)
		{
			if (!Lang.IsFrench)
			{
				return n.ToString("N0", CultureInfo.InvariantCulture);
			}
			return n.ToString("N0", CultureInfo.InvariantCulture).Replace(',', ' ');
		}

		public static string Duration(long seconds)
		{
			long num = seconds / 60;
			long num2 = num / 60;
			if (num2 != 0L)
			{
				if (num % 60 == 0L)
				{
					return $"{num2} h";
				}
				return $"{num2} h {num % 60:00}";
			}
			return $"{num} min";
		}

		public static string Clock(double seconds)
		{
			if (!(seconds <= 0.0))
			{
				return $"{(int)(seconds / 60.0):00}:{(int)(seconds % 60.0):00}";
			}
			return "--:--";
		}
	}
	internal static class Catalog
	{
		public static readonly List<Achievement> All;

		public static readonly UpgradeType[] GamePerks;

		public static readonly (ResourceType Type, string Fr, string En, long[] Steps)[] Ores;

		public static readonly (ResourceType Type, string Fr, string En)[] Ingots;

		public static readonly (BuildType Type, string Name, string NameEn, string Fr, string En)[] Buildings;

		public static readonly (string Id, string Fr, string En)[] Mutators;

		private static string _sectionFr;

		private static string _sectionEn;

		private static Domain _domain;

		private static Func<bool> _available;

		public static IEnumerable<Achievement> Visible => All.Where((Achievement a) => a.Unlocked || a.Available());

		private static long[] Steps(params long[] steps)
		{
			return steps;
		}

		private static void Section(Domain domain, string fr, string en, Func<bool> available = null)
		{
			_domain = domain;
			_sectionFr = fr;
			_sectionEn = en;
			_available = available ?? ((Func<bool>)(() => true));
		}

		private static void Success(string id, string nameFr, string nameEn, string descFr, string descEn, Func<Profile, bool> condition = null, Func<Profile, (long, long)> progress = null, bool hidden = false)
		{
			All.Add(new Achievement
			{
				Id = id,
				Domain = _domain,
				SectionFr = _sectionFr,
				SectionEn = _sectionEn,
				NameFr = nameFr,
				NameEn = nameEn,
				DescFr = descFr,
				DescEn = descEn,
				Condition = condition,
				Progress = progress,
				Hidden = hidden,
				Available = _available
			});
		}

		private static void Challenge(string id, string nameFr, string nameEn, string descFr, string descEn, Func<Profile, long> counter, long[] thresholds, Func<long, string> show = null)
		{
			All.Add(new Achievement
			{
				Id = id,
				Domain = _domain,
				SectionFr = _sectionFr,
				SectionEn = _sectionEn,
				NameFr = nameFr,
				NameEn = nameEn,
				DescFr = descFr,
				DescEn = descEn,
				Counter = counter,
				Thresholds = thresholds,
				Show = show,
				Available = _available
			});
		}

		private static (long, long) Count(long current, long target)
		{
			return (current, target);
		}

		unsafe static Catalog()
		{
			//IL_0dca: Unknown result type (might be due to invalid IL or missing references)
			//IL_0dcf: Unknown result type (might be due to invalid IL or missing references)
			//IL_0dee: Unknown result type (might be due to invalid IL or missing references)
			//IL_0df3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0eea: Unknown result type (might be due to invalid IL or missing references)
			//IL_0eef: Unknown result type (might be due to invalid IL or missing references)
			//IL_0f0f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0f14: Unknown result type (might be due to invalid IL or missing references)
			//IL_0fdc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0fe1: Unknown result type (might be due to invalid IL or missing references)
			//IL_1001: Unknown result type (might be due to invalid IL or missing references)
			//IL_1006: Unknown result type (might be due to invalid IL or missing references)
			//IL_169c: Unknown result type (might be due to invalid IL or missing references)
			//IL_16a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_16c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_16c6: Unknown result type (might be due to invalid IL or missing references)
			All = new List<Achievement>();
			UpgradeType[] array = new UpgradeType[11];
			RuntimeHelpers.InitializeArray(array, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
			GamePerks = (UpgradeType[])(object)array;
			Ores = new(ResourceType, string, string, long[])[9]
			{
				((ResourceType)2, "fer", "iron ore", Steps(1L, 10L, 100L, 1000L, 10000L)),
				((ResourceType)4, "cuivre", "copper ore", Steps(1L, 10L, 100L, 1000L, 10000L)),
				((ResourceType)11, "charbon", "coal", Steps(1L, 10L, 100L, 1000L, 10000L)),
				((ResourceType)6, "quartz", "quartz", Steps(1L, 10L, 100L, 1000L, 5000L)),
				((ResourceType)8, "or", "gold ore", Steps(1L, 10L, 100L, 1000L, 5000L)),
				((ResourceType)12, "cristal", "crystal", Steps(1L, 10L, 100L, 500L, 2500L)),
				((ResourceType)13, "super cristal", "super crystal", Steps(1L, 10L, 50L, 250L, 1000L)),
				((ResourceType)14, "hypercristal", "hyper crystal", Steps(1L, 5L, 25L, 100L, 500L)),
				((ResourceType)10, "diamant", "diamond", Steps(1L, 5L, 25L, 100L, 250L))
			};
			Ingots = new(ResourceType, string, string)[4]
			{
				((ResourceType)3, "lingots de fer", "iron ingots"),
				((ResourceType)5, "lingots de cuivre", "copper ingots"),
				((ResourceType)7, "quartz raffinés", "refined quartz"),
				((ResourceType)9, "lingots d'or", "gold ingots")
			};
			Buildings = new(BuildType, string, string, string, string)[4]
			{
				((BuildType)1, "Entrepositaire", "Warehouser", "coffres", "chests"),
				((BuildType)2, "Fondeur", "Smelter", "fours", "furnaces"),
				((BuildType)3, "Foreur", "Driller", "foreuses", "drills"),
				((BuildType)4, "Radariste", "Radar operator", "scanners", "scanners")
			};
			Mutators = new(string, string, string)[8]
			{
				("RichOres", "Filons riches", "Rich veins"),
				("Darkness", "Obscurité", "Darkness"),
				("HardRock", "Roche dure", "Hard rock"),
				("Featherweight", "Poids plume", "Featherweight"),
				("AgainstClock", "Contre-la-montre", "Against the clock"),
				("OneTrip", "Un seul aller-retour", "One trip"),
				("NoBuild", "Pas de construction", "No building"),
				("ReverseClock", "Chrono inversé", "Reverse clock")
			};
			_available = () => true;
			Section(Domain.Success, "Premiers pas", "First steps");
			Success("first.block", "Premier coup de pioche", "First swing", "Casser un bloc.", "Break a block.", (Profile p) => p.Get("blocks") > 0);
			Success("first.ore", "Ça brille !", "Shiny!", "Miner un minerai.", "Mine an ore.", (Profile p) => Ores.Any(((ResourceType Type, string Fr, string En, long[] Steps) o) => p.Get("mined." + ((object)(*(ResourceType*)(&o.Type))/*cast due to .constrained prefix*/).ToString()) > 0));
			Success("first.run", "Baptême", "First shift", "Terminer une run.", "Finish a run.", (Profile p) => p.Get("runs") > 0);
			Success("first.build", "Premier chantier", "Groundbreaking", "Poser un bâtiment.", "Place a building.", (Profile p) => Buildings.Any(((BuildType Type, string Name, string NameEn, string Fr, string En) b) => p.Get("built." + ((object)(*(BuildType*)(&b.Type))/*cast due to .constrained prefix*/).ToString()) > 0));
			Success("first.perk", "Premier pouvoir", "First power", "Choisir une perk.", "Pick a perk.", (Profile p) => p.Get("perks") > 0);
			Success("first.upgrade", "Mise à jour", "Patch notes", "Acheter une amélioration au Computer.", "Buy a Computer upgrade.", (Profile p) => p.Get("upgrades") > 0);
			Success("first.ingot", "Livraison spéciale", "Special delivery", "Livrer un lingot au conteneur principal.", "Deliver an ingot to the main container.", (Profile p) => Ingots.Any(((ResourceType Type, string Fr, string En) i) => p.Get("delivered." + ((object)(*(ResourceType*)(&i.Type))/*cast due to .constrained prefix*/).ToString()) > 0));
			Success("first.level5", "Ça monte", "Leveling up", "Atteindre le niveau 5 en une run.", "Reach level 5 in a run.", (Profile p) => p.Get("best.level") >= 5);
			Section(Domain.Success, "Paliers", "Tiers");
			Success("tier1", "Quota rempli", "Quota met", "Valider le palier 1.", "Clear tier 1.");
			Success("tier2", "Mission accomplie", "Mission accomplished", "Valider le palier 2 et terminer la démo.", "Clear tier 2 and finish the demo.");
			Success("tier1.first", "Du premier coup", "First try", "Valider le palier 1 en une seule run.", "Clear tier 1 in a single run.");
			Success("tier2.first", "Sans trembler", "Steady hands", "Valider le palier 2 en une seule run.", "Clear tier 2 in a single run.");
			Success("demo.flawless", "Sans faute", "Flawless", "Terminer la démo en 2 runs (une par palier).", "Finish the demo in 2 runs (one per tier).");
			Success("tier1.fast", "Pressé", "In a hurry", "Valider le palier 1 en moins de 6 minutes de jeu.", "Clear tier 1 in under 6 minutes of play.");
			Success("demo.25", "Rapide", "Quick", "Terminer la démo en moins de 25 minutes de jeu.", "Finish the demo in under 25 minutes of play.");
			Success("demo.15", "Éclair", "Lightning", "Terminer la démo en moins de 15 minutes de jeu.", "Finish the demo in under 15 minutes of play.");
			Section(Domain.Success, "Façons de jouer", "Play styles");
			Success("demo.furnaceless", "FurnaceLess", "FurnaceLess", "Terminer le palier 2 sans aucun four.", "Finish tier 2 without any furnace.");
			Success("demo.perkless", "PerkLess", "PerkLess", "Terminer le palier 2 sans aucune perk.", "Finish tier 2 without any perk.");
			Success("demo.lessless", "Double peine", "Double trouble", "Terminer le palier 2 sans four ni perk.", "Finish tier 2 with no furnace and no perk.");
			Success("demo.nodrill", "À la pioche", "Pickaxe only", "Terminer le palier 2 sans aucune foreuse.", "Finish tier 2 without any drill.");
			Success("demo.noscanner", "À l'aveugle", "Blindfolded", "Terminer le palier 2 sans aucun scanner.", "Finish tier 2 without any scanner.");
			Success("demo.minimal", "Minimaliste", "Minimalist", "Terminer le palier 2 en posant 5 bâtiments au plus.", "Finish tier 2 placing 5 buildings at most.");
			Success("demo.nobuild", "Mains nues", "Bare hands", "Terminer le palier 2 sans poser un seul bâtiment.", "Finish tier 2 without placing a single building.");
			Success("demo.nocomputer", "Autodidacte", "Self-taught", "Terminer le palier 2 sans acheter d'amélioration au Computer.", "Finish tier 2 without buying a Computer upgrade.");
			Section(Domain.Success, "Runs", "Runs");
			Success("run.score2k", "Belle prise", "Nice haul", "Convertir 2 000 points en une run.", "Convert 2,000 points in a run.", (Profile p) => p.Get("best.score") >= 2000, (Profile p) => Count(p.Get("best.score"), 2000L));
			Success("run.score5k", "Gros arrivage", "Big delivery", "Convertir 5 000 points en une run.", "Convert 5,000 points in a run.", (Profile p) => p.Get("best.score") >= 5000, (Profile p) => Count(p.Get("best.score"), 5000L));
			Success("run.score10k", "Jackpot", "Jackpot", "Convertir 10 000 points en une run.", "Convert 10,000 points in a run.", (Profile p) => p.Get("best.score") >= 10000, (Profile p) => Count(p.Get("best.score"), 10000L));
			Success("run.level10", "Montée en puissance", "Powering up", "Atteindre le niveau 10 en une run.", "Reach level 10 in a run.", (Profile p) => p.Get("best.level") >= 10, (Profile p) => Count(p.Get("best.level"), 10L));
			Success("run.level15", "Surpuissant", "Overpowered", "Atteindre le niveau 15 en une run.", "Reach level 15 in a run.", (Profile p) => p.Get("best.level") >= 15, (Profile p) => Count(p.Get("best.level"), 15L));
			Success("run.level20", "Inarrêtable", "Unstoppable", "Atteindre le niveau 20 en une run.", "Reach level 20 in a run.", (Profile p) => p.Get("best.level") >= 20, (Profile p) => Count(p.Get("best.level"), 20L));
			Success("run.blocks500", "Frénésie", "Frenzy", "Miner 500 blocs en une seule