using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.IO.Compression;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Text;
using System.Threading;
using BepInEx;
using BepInEx.Bootstrap;
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 Microsoft.CodeAnalysis;
using SCTCommon;
using UnityEngine;
using UnityEngine.Localization;
using UnityEngine.Localization.Settings;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: AssemblyCompany("SCTUpgrade.ConversionBonus")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("SCTUpgrade.ConversionBonus")]
[assembly: AssemblyTitle("SCTUpgrade.ConversionBonus")]
[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.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;

		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 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_0038: Unknown result type (might be due to invalid IL or missing references)
				//IL_0049: Expected O, but got Unknown
				//IL_0059: 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 = label.fontSize,
						padding = label.padding
					};
					_label.normal.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));

		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_00a0: 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_008c: 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_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: 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_011a: Unknown result type (might be due to invalid IL or missing references)
			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 flag = GUI.enabled && Event.current != null && Contains(rect, Event.current.mousePosition);
			Color color = GUI.color;
			if (on)
			{
				GUI.color = color * new Color(0.65f, 0.9f, 1f, 1f);
			}
			else if (!GUI.enabled)
			{
				GUI.color = color * new Color(1f, 1f, 1f, 0.5f);
			}
			GUI.Box(rect, text, on ? _buttonOn : (flag ? _buttonHover : _button));
			GUI.color = color;
		}

		public static void DrawCheck(Rect rect, string text, bool on)
		{
			//IL_0057: 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)
			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_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)
			//IL_0011: 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_0031: 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_0049: 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_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Expected O, but got Unknown
			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) * 18f + 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;

		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_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: 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_004f: Unknown result type (might be due to invalid IL or missing references)
			Rect = (_modal ? GUI.ModalWindow(_id, Rect, _function, _title()) : GUI.Window(_id, Rect, _function, _title()));
		}

		private void Draw(int id)
		{
			//IL_0032: 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_00df: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				_layout.Begin(new Rect(8f, 22f, ((Rect)(ref Rect)).width - 16f, ((Rect)(ref Rect)).height - 28f), _id);
				_content(_layout);
				_layout.End();
			}
			catch (Exception ex)
			{
				SctGui.Report("Fenêtre " + _id, ex);
				GUI.Label(new Rect(8f, 22f, ((Rect)(ref Rect)).width - 16f, 60f), "Erreur : " + ex.Message, SctGui.Label);
			}
			if (!_modal)
			{
				GUI.DragWindow(new Rect(0f, 0f, ((Rect)(ref Rect)).width, 20f));
			}
		}
	}
	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 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_003f: Unknown result type (might be due to invalid IL or missing references)
			string text = NextKey();
			BoxHeights.TryGetValue(text, out var value);
			if (value > 0f)
			{
				GUI.Box(new Rect(_f.X, _f.Y, _f.Width, value), "");
			}
			_frames.Push(_f);
			_f.X += 6f;
			_f.Width -= 12f;
			_f.Y += 4f;
			_boxKeys.Push((text, _f.Y - 4f));
		}

		public void EndBox()
		{
			(string Key, float Top) tuple = _boxKeys.Pop();
			string item = tuple.Key;
			float item2 = tuple.Top;
			float y = _f.Y;
			_f = _frames.Pop();
			BoxHeights[item] = y - item2 + 2f;
			_f.Y = y + 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) : 22f), text, SctGui.Label);
		}

		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 = 22f)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			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, 22f);
			if (Clicked(rect))
			{
				value = !value;
			}
			SctGui.DrawCheck(rect, text, value);
			return value;
		}

		public bool ToggleButton(bool value, string text, float width = -1f, float height = 22f)
		{
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: 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)
			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)
		{
			//IL_0046: 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_004e: 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)
			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, 22f);
				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_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: 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_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Invalid comparison between Unknown and I4
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Invalid comparison between Unknown and I4
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: Unknown result type (might be due to invalid IL or missing references)
			//IL_012d: Invalid comparison between Unknown and I4
			string text = NextKey();
			Rect r = Next(width, 22f);
			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);
			GUI.Box(val, "");
			GUI.Box(new Rect(((Rect)(ref val)).x + num * (((Rect)(ref val)).width - 12f), ((Rect)(ref r)).y + 2f, 12f, ((Rect)(ref r)).height - 4f), "");
			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_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_0157: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Invalid comparison between Unknown and I4
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Invalid comparison between Unknown and I4
			//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, 22f);
			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;
			GUI.Box(val, "");
			GUI.Label(new Rect(((Rect)(ref val)).x + 4f, ((Rect)(ref val)).y, ((Rect)(ref val)).width - 8f, ((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_0108: 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), "");
			}
			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 SCTComputer
{
	internal class ComputerUpgrade
	{
		public UpgradeType Type;

		public string NameFr;

		public string NameEn;

		public float[] Values;

		public int[] Costs;

		public int[] AvailableTiers;

		public string DisplayName => Pick(NameFr, NameEn);

		public float Value
		{
			get
			{
				//IL_001a: Unknown result type (might be due to invalid IL or missing references)
				if (!((Object)(object)UpgradeManager.Instance != (Object)null))
				{
					return 0f;
				}
				return ValueAtTier(UpgradeManager.Instance.GetTier(Type));
			}
		}

		public static string Pick(string fr, string en)
		{
			return Lang.Pick(fr, en);
		}

		public float ValueFrom(PersistentSaveData save)
		{
			//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_001d: 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)
			int tier = 0;
			List<UpgradeTier> upgradeTiers = save.UpgradeTiers;
			if (upgradeTiers != null)
			{
				for (int i = 0; i < upgradeTiers.Count; i++)
				{
					if (upgradeTiers[i].upgradeType == Type)
					{
						tier = upgradeTiers[i].tier;
					}
				}
			}
			return ValueAtTier(tier);
		}

		private float ValueAtTier(int tier)
		{
			if (!Vanilla.Active)
			{
				return Values[Math.Max(0, Math.Min(tier, Values.Length - 1))];
			}
			return Values[0];
		}

		public static ComputerUpgrade Create(int id, string fr, string en, float[] values, int[] costs, int[] availableTiers)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			return new ComputerUpgrade
			{
				Type = (UpgradeType)id,
				NameFr = fr,
				NameEn = en,
				Values = values,
				Costs = costs,
				AvailableTiers = availableTiers
			};
		}
	}
	public abstract class UpgradePlugin : BasePlugin
	{
		internal static ComputerUpgrade Upgrade;

		private static UpgradePlugin _instance;

		public UpgradeType UpgradeType => Upgrade.Type;

		public string UpgradeName => Upgrade.DisplayName;

		internal abstract ComputerUpgrade CreateUpgrade();

		protected virtual void BindConfig()
		{
		}

		protected virtual void OnNewRun(Game game)
		{
		}

		public override void Load()
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_015d: Unknown result type (might be due to invalid IL or missing references)
			//IL_017d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0183: Expected O, but got Unknown
			//IL_002b: 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_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Expected O, but got Unknown
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Expected O, but got Unknown
			_instance = this;
			Upgrade = CreateUpgrade();
			bool flag = default(bool);
			BepInExInfoLogInterpolatedStringHandler val2;
			if (Il2CppUpgradeList.IndexOf(Upgrade.Type) < 0)
			{
				if (!Il2CppUpgradeList.Append(Upgrade.Type, Upgrade.Values, Upgrade.Costs, Upgrade.AvailableTiers))
				{
					ManualLogSource log = ((BasePlugin)this).Log;
					BepInExErrorLogInterpolatedStringHandler val = new BepInExErrorLogInterpolatedStringHandler(70, 2, ref flag);
					if (flag)
					{
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Upgrade ");
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(Upgrade.NameFr);
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" : écriture dans la liste du jeu refusée (");
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(Il2CppUpgradeList.Layout);
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral("), upgrade désactivé");
					}
					log.LogError(val);
					return;
				}
				int num = Il2CppUpgradeList.IndexOf(Upgrade.Type);
				ManualLogSource log2 = ((BasePlugin)this).Log;
				val2 = new BepInExInfoLogInterpolatedStringHandler(46, 5, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("Upgrade ");
					((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>(Upgrade.NameFr);
					((BepInExLogInterpolatedStringHandler)val2).AppendLiteral(" ajouté au Computer (position ");
					((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<int>(num);
					((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("/");
					((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<int>(Il2CppUpgradeList.Count);
					((BepInExLogInterpolatedStringHandler)val2).AppendLiteral(" ; ");
					((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>(Il2CppUpgradeList.Layout);
					((BepInExLogInterpolatedStringHandler)val2).AppendLiteral(" ; ");
					((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>(Il2CppUpgradeList.InteropView(num));
					((BepInExLogInterpolatedStringHandler)val2).AppendLiteral(")");
				}
				log2.LogInfo(val2);
			}
			BindConfig();
			new Harmony(Il2CppUtil.Guid((BasePlugin)(object)this)).PatchAll(((object)this).GetType().Assembly);
			ManualLogSource log3 = ((BasePlugin)this).Log;
			val2 = new BepInExInfoLogInterpolatedStringHandler(15, 1, ref flag);
			if (flag)
			{
				((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("Upgrade ");
				((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>(Upgrade.NameFr);
				((BepInExLogInterpolatedStringHandler)val2).AppendLiteral(" chargé");
			}
			log3.LogInfo(val2);
		}

		internal static void RaiseNewRun(Game game)
		{
			_instance?.OnNewRun(game);
		}
	}
	[HarmonyPatch(typeof(Game), "Start")]
	internal static class NewRunPatch
	{
		private static void Prefix(out bool __state)
		{
			__state = SaveSystem.ExistGameFile();
		}

		private static void Postfix(Game __instance, bool __state)
		{
			Safe.Run("Upgrade " + UpgradePlugin.Upgrade?.NameFr + " début de run", delegate
			{
				if (!__state && !__instance._runEnded && __instance._persistentSaveData.RunCount != 0)
				{
					UpgradePlugin.RaiseNewRun(__instance);
					if ((Object)(object)PlayerStatsHUD.Instance != (Object)null)
					{
						PlayerStatsHUD.Instance.Refresh();
					}
				}
			});
		}
	}
	[HarmonyPatch(typeof(ComputerManager), "GetAvailableUpgrades")]
	internal static class UpgradeVanillaPatch
	{
		private static void Postfix(List<Upgrade> __result)
		{
			Safe.Run("Upgrade " + UpgradePlugin.Upgrade?.NameFr + " sans mods", delegate
			{
				//IL_0027: 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_0036: Unknown result type (might be due to invalid IL or missing references)
				if (Vanilla.Active && __result != null)
				{
					for (int num = __result.Count - 1; num >= 0; num--)
					{
						if (__result[num].upgradeType == UpgradePlugin.Upgrade.Type)
						{
							__result.RemoveAt(num);
						}
					}
				}
			});
		}
	}
	[HarmonyPatch(typeof(CMDUpgrade), "FormatUpgradeName")]
	internal static class UpgradeNamePatch
	{
		private static bool Prefix(CMDUpgrade __instance, UpgradeType upgradeType, int tier, ref string __result)
		{
			//IL_0014: 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)
			if (upgradeType != UpgradePlugin.Upgrade.Type)
			{
				return true;
			}
			string name = null;
			bool num = Safe.Prefix("Upgrade " + UpgradePlugin.Upgrade.NameFr + " nom", delegate
			{
				name = UpgradePlugin.Upgrade.DisplayName.ToUpperInvariant() + " " + __instance.FormatTier(tier);
				return false;
			});
			if (!num)
			{
				__result = name;
			}
			return num;
		}
	}
}
namespace SCTComputer.ConversionBonus
{
	[BepInPlugin("sct.upgrade.conversionbonus", "SCT Upgrade - Prime de conversion", "2.0.1")]
	public class ConversionBonusUpgrade : UpgradePlugin
	{
		internal override ComputerUpgrade CreateUpgrade()
		{
			return ComputerUpgrade.Create(207, "Prime de conversion", "Conversion bonus", new float[4] { 0f, 0.05f, 0.1f, 0.15f }, new int[4] { 0, 400, 1200, 3500 }, new int[4] { 0, 1, 1, 2 });
		}
	}
	[HarmonyPatch(typeof(ComputerManager), "ProcessRunResults")]
	internal static class ConversionBonusPatch
	{
		private static void Postfix(ComputerManager __instance)
		{
			Safe.Run("Prime de conversion", delegate
			{
				Apply(__instance);
			});
		}

		private static void Apply(ComputerManager __instance)
		{
			PersistentSaveData persistentSaveData = __instance._persistentSaveData;
			int num = Mathf.RoundToInt((float)__instance._convertedTotal * UpgradePlugin.Upgrade.ValueFrom(persistentSaveData));
			if (num > 0)
			{
				persistentSaveData.DataPoints += num;
				persistentSaveData.TotalDataPoints += num;
				__instance._persistentSaveData = persistentSaveData;
				__instance.Save();
			}
		}
	}
}