using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Text.Json;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Core.Logging.Interpolation;
using BepInEx.Logging;
using BepInEx.Unity.IL2CPP;
using Castle.DynamicProxy;
using HarmonyLib;
using Il2CppInterop.Runtime;
using Il2CppInterop.Runtime.InteropTypes;
using Il2CppInterop.Runtime.InteropTypes.Arrays;
using Il2CppSystem;
using Il2CppSystem.Collections.Generic;
using Il2CppSystem.IO;
using Il2CppSystem.Reflection;
using Microsoft.CodeAnalysis;
using Rewired;
using SOD.Common.BepInEx;
using SOD.Common.BepInEx.Configuration;
using SOD.Common.BepInEx.Proxies;
using SOD.Common.ConfigBindings;
using SOD.Common.Custom;
using SOD.Common.Extensions;
using SOD.Common.Extensions.Internal;
using SOD.Common.Helpers;
using SOD.Common.Helpers.DialogObjects;
using SOD.Common.Helpers.SyncDiskObjects;
using UnityEngine;
using UniverseLib;
using UniverseLib.Config;
using UniverseLib.Utility;

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

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

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

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace SOD.Common
{
	public class Lib
	{
		public static GameMessage GameMessage { get; } = new GameMessage();


		public static Time Time { get; } = new Time();


		public static SaveGame SaveGame { get; } = new SaveGame();


		public static InputDetection InputDetection { get; } = new InputDetection();


		public static Interaction Interaction { get; } = new Interaction();


		public static SyncDisks SyncDisks { get; } = new SyncDisks();


		public static DdsStrings DdsStrings { get; } = new DdsStrings();


		public static Dialog Dialogs { get; } = new Dialog();


		public static PluginDetection PluginDetection { get; } = new PluginDetection();


		public static PlayerStatus PlayerStatus { get; } = new PlayerStatus();


		public static RestoredUnityEngine RestoredEngineFunctions { get; } = new RestoredUnityEngine();

	}
	[BepInPlugin("Venomaus.SOD.Common", "SOD.Common", "2.0.2")]
	public class Plugin : PluginController<Plugin, IPluginBindings>
	{
		public const string PLUGIN_GUID = "Venomaus.SOD.Common";

		public const string PLUGIN_NAME = "SOD.Common";

		public const string PLUGIN_VERSION = "2.0.2";

		public override void Load()
		{
			//IL_0009: 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)
			Universe.Init(0f, (Action)null, (Action<string, LogType>)null, new UniverseLibConfig
			{
				Unhollowed_Modules_Folder = Path.Combine(Paths.BepInExRootPath, "interop")
			});
			base.Harmony.PatchAll(Assembly.GetExecutingAssembly());
			PluginController<Plugin, IPluginBindings>.Log.LogInfo((object)"Plugin is patched.");
		}
	}
	public sealed class RestoredUnityEngine
	{
		public static class JsonUtility
		{
			private delegate IntPtr Delegate_FromJsonInternal(IntPtr json, IntPtr scriptableObject, IntPtr type);

			private delegate IntPtr Delegate_ToJsonInternal(IntPtr json, bool prettyPrint);

			private static Delegate_FromJsonInternal _iCallFromJsonInternal;

			private static Delegate_ToJsonInternal _iCallToJsonInternal;

			public static T FromJsonInternal<T>(string json, T scriptableObject) where T : Object
			{
				//IL_005b: Unknown result type (might be due to invalid IL or missing references)
				if (_iCallFromJsonInternal == null)
				{
					_iCallFromJsonInternal = IL2CPP.ResolveICall<Delegate_FromJsonInternal>("UnityEngine.JsonUtility::FromJsonInternal");
				}
				IntPtr json2 = IL2CPP.ManagedStringToIl2Cpp(json);
				IntPtr scriptableObject2 = (IntPtr)typeof(T).GetMethod("get_Pointer").Invoke(scriptableObject, null);
				IntPtr pointer = ((Il2CppObjectBase)Il2CppType.Of<T>()).Pointer;
				return new Il2CppObjectBase(_iCallFromJsonInternal(json2, scriptableObject2, pointer)).TryCast<T>();
			}

			public static string ToJsonInternal(Il2CppObjectBase obj, bool prettyPrint)
			{
				if (_iCallToJsonInternal == null)
				{
					_iCallToJsonInternal = IL2CPP.ResolveICall<Delegate_ToJsonInternal>("UnityEngine.JsonUtility::ToJsonInternal");
				}
				IntPtr json = (IntPtr)typeof(ScriptableObject).GetMethod("get_Pointer").Invoke(obj, null);
				return IL2CPP.Il2CppStringToManaged(_iCallToJsonInternal(json, prettyPrint));
			}
		}

		internal RestoredUnityEngine()
		{
		}
	}
}
namespace SOD.Common.Patches
{
	internal class AssetLoaderPatches
	{
		[HarmonyPatch(typeof(AssetLoader), "GetAllPresets")]
		internal static class AssetLoader_GetAllPresets
		{
			private static bool _loaded;

			[HarmonyPostfix]
			internal static void Postfix(List<ScriptableObject> __result)
			{
				//IL_0114: Unknown result type (might be due to invalid IL or missing references)
				//IL_0132: Unknown result type (might be due to invalid IL or missing references)
				//IL_0150: 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_01b3: Expected O, but got Unknown
				if (_loaded)
				{
					return;
				}
				_loaded = true;
				HashSet<string> sprites = Lib.SyncDisks.RegisteredSyncDisks.SelectMany((SyncDisk a) => a.Icons).ToHashSet<string>(StringComparer.OrdinalIgnoreCase);
				Dictionary<string, Sprite> gameSprites = (from a in (IEnumerable<Sprite>)Resources.FindObjectsOfTypeAll<Sprite>()
					where sprites.Contains(((Object)a).name)
					group a by ((Object)a).name).ToDictionary((IGrouping<string, Sprite> a) => a.Key, (IGrouping<string, Sprite> a) => a.First());
				foreach (SyncDisk registeredSyncDisk in Lib.SyncDisks.RegisteredSyncDisks)
				{
					SyncDiskPreset preset = registeredSyncDisk.Preset;
					_createdSyncDiskPresets.Add(preset);
					preset.interactable = SyncDisk.SyncDiskInteractablePreset.Value;
					if ((int)preset.mainEffect1 != 0)
					{
						preset.mainEffect1Icon = GetSprite(gameSprites, registeredSyncDisk.Icons[0]);
					}
					if ((int)preset.mainEffect2 != 0)
					{
						preset.mainEffect2Icon = GetSprite(gameSprites, registeredSyncDisk.Icons[1]);
					}
					if ((int)preset.mainEffect3 != 0)
					{
						preset.mainEffect3Icon = GetSprite(gameSprites, registeredSyncDisk.Icons[2]);
					}
					__result.Add((ScriptableObject)(object)preset);
				}
				if (Lib.SyncDisks.RegisteredSyncDisks.Count > 0)
				{
					ManualLogSource log = PluginController<Plugin, IPluginBindings>.Log;
					bool flag = default(bool);
					BepInExInfoLogInterpolatedStringHandler val = new BepInExInfoLogInterpolatedStringHandler(26, 1, ref flag);
					if (flag)
					{
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Loaded ");
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<int>(Lib.SyncDisks.RegisteredSyncDisks.Count);
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" custom sync disks.");
					}
					log.LogInfo(val);
				}
				Lib.SyncDisks.RegisteredSyncDisks.ForEach(delegate(SyncDisk a)
				{
					a.Icons = null;
				});
			}

			private static Sprite GetSprite(Dictionary<string, Sprite> gameSprites, string spriteName)
			{
				//IL_0015: Unknown result type (might be due to invalid IL or missing references)
				//IL_001b: Expected O, but got Unknown
				if (!gameSprites.TryGetValue(spriteName, out var value))
				{
					ManualLogSource log = PluginController<Plugin, IPluginBindings>.Log;
					bool flag = default(bool);
					BepInExErrorLogInterpolatedStringHandler val = new BepInExErrorLogInterpolatedStringHandler(71, 1, ref flag);
					if (flag)
					{
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Could not find sprite with name \"");
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(spriteName);
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral("\", falling back to default dna sprite.");
					}
					log.LogError(val);
				}
				return value ?? gameSprites["IconDNA"];
			}
		}

		[HarmonyPatch(typeof(Toolbox), "LoadAll")]
		internal static class Toolbox_LoadAll
		{
			private static bool _loaded;

			[HarmonyPostfix]
			internal static void Postfix()
			{
				LoadDDSEntries();
				if (_loaded)
				{
					return;
				}
				_loaded = true;
				int count = Toolbox.Instance.allSyncDisks.Count;
				foreach (SyncDiskPreset createdSyncDiskPreset in _createdSyncDiskPresets)
				{
					createdSyncDiskPreset.syncDiskNumber = count++;
				}
				_createdSyncDiskPresets = null;
				Lazy<Il2CppArrayBase<MenuPreset>> lazy = new Lazy<Il2CppArrayBase<MenuPreset>>((Func<Il2CppArrayBase<MenuPreset>>)Resources.FindObjectsOfTypeAll<MenuPreset>);
				if (PluginController<Plugin, IPluginBindings>.Instance.Config.DebugMode)
				{
					foreach (string item in ((IEnumerable<MenuPreset>)lazy.Value).Select((MenuPreset a) => ((SoCustomComparison)a).GetPresetName()).Except<string>(from a in Enum.GetValues<SyncDiskBuilder.SyncDiskSaleLocation>()
						select a.ToString(), StringComparer.OrdinalIgnoreCase))
					{
						PluginController<Plugin, IPluginBindings>.Log.LogInfo((object)("[UpdateRequired] Missing following new sale locations in enum: " + item));
					}
				}
				AddToMenuPresets(Lib.SyncDisks.RegisteredSyncDisks.Where((SyncDisk a) => a.MenuPresetLocations.Count > 0), lazy);
			}

			private static void AddToMenuPresets(IEnumerable<SyncDisk> syncDisk, Lazy<Il2CppArrayBase<MenuPreset>> menus)
			{
				Dictionary<string, SyncDiskPreset[]> dictionary = (from x in syncDisk.SelectMany((SyncDisk a) => a.MenuPresetLocations.Select((string saleLocation) => new
					{
						Preset = a.Preset,
						SaleLocation = saleLocation
					}))
					group x by x.SaleLocation).ToDictionary(group => group.Key, group => group.Select(item => item.Preset).ToArray(), StringComparer.OrdinalIgnoreCase);
				if (dictionary.Count == 0)
				{
					return;
				}
				foreach (MenuPreset item in menus.Value)
				{
					string presetName = ((SoCustomComparison)item).GetPresetName();
					if (dictionary.TryGetValue(presetName, out var value))
					{
						SyncDiskPreset[] array = value;
						foreach (SyncDiskPreset val in array)
						{
							item.syncDisks.Add(val);
						}
					}
				}
				Lib.SyncDisks.RegisteredSyncDisks.ForEach(delegate(SyncDisk a)
				{
					a.MenuPresetLocations = null;
				});
			}

			private static void LoadDDSEntries()
			{
				foreach (SyncDisk registeredSyncDisk in Lib.SyncDisks.RegisteredSyncDisks)
				{
					Lib.DdsStrings["evidence.syncdisks", ((Object)registeredSyncDisk.Preset).name] = registeredSyncDisk.Name;
					for (int i = 0; i < registeredSyncDisk.Effects.Length; i++)
					{
						string text = i switch
						{
							1 => registeredSyncDisk.Preset.mainEffect2Name, 
							0 => registeredSyncDisk.Preset.mainEffect1Name, 
							_ => registeredSyncDisk.Preset.mainEffect3Name, 
						};
						string text2 = i switch
						{
							1 => registeredSyncDisk.Preset.mainEffect2Description, 
							0 => registeredSyncDisk.Preset.mainEffect1Description, 
							_ => registeredSyncDisk.Preset.mainEffect3Description, 
						};
						Lib.DdsStrings.AddOrUpdateEntries("evidence.syncdisks", (text, SyncDisk.GetName(text)), (text2, SyncDisk.GetName(text2)));
					}
					for (int j = 0; j < registeredSyncDisk.UpgradeOptions.Length; j++)
					{
						List<string> val = (List<string>)(j switch
						{
							1 => registeredSyncDisk.Preset.option2UpgradeNameReferences, 
							0 => registeredSyncDisk.Preset.option1UpgradeNameReferences, 
							_ => registeredSyncDisk.Preset.option3UpgradeNameReferences, 
						});
						for (int k = 0; k < val.Count; k++)
						{
							Lib.DdsStrings["evidence.syncdisks", val[k]] = SyncDisk.GetName(val[k]);
						}
					}
					if (registeredSyncDisk.SideEffect.HasValue)
					{
						Lib.DdsStrings["evidence.syncdisks", registeredSyncDisk.SideEffect.Value.DdsIdentifier] = registeredSyncDisk.SideEffect.Value.Name;
					}
				}
				if (Lib.SyncDisks.RegisteredSyncDisks.Any())
				{
					PluginController<Plugin, IPluginBindings>.Log.LogInfo((object)"Loaded custom sync disk dds entries.");
				}
				foreach (DialogObject registeredDialog in Lib.Dialogs.RegisteredDialogs)
				{
					if (registeredDialog.Text != null)
					{
						Lib.DdsStrings["dds.blocks", registeredDialog.BlockId] = registeredDialog.Text;
					}
					foreach (DialogResponse response in registeredDialog.Responses)
					{
						if (response.Text != null)
						{
							Lib.DdsStrings["dds.blocks", response.BlockId] = response.Text;
						}
					}
					foreach (DDSBlockSave block in registeredDialog.Blocks)
					{
						Toolbox.Instance.allDDSBlocks.Add(((DDSComponent)block).id, block);
					}
					foreach (DDSMessageSave message in registeredDialog.Messages)
					{
						Toolbox.Instance.allDDSMessages.Add(((DDSComponent)message).id, message);
					}
				}
				if (Lib.Dialogs.RegisteredDialogs.Any())
				{
					PluginController<Plugin, IPluginBindings>.Log.LogInfo((object)"Loaded custom dialog dds entries.");
				}
			}
		}

		internal static List<SyncDiskPreset> _createdSyncDiskPresets = new List<SyncDiskPreset>();
	}
	internal class DialogControllerPatches
	{
		[HarmonyPatch(typeof(DialogController), "Start")]
		internal static class DialogController_Start
		{
			[HarmonyPostfix]
			internal static void Postfix(DialogController __instance)
			{
				//IL_0115: Unknown result type (might be due to invalid IL or missing references)
				//IL_011c: Expected O, but got Unknown
				foreach (DialogObject registeredDialog in Lib.Dialogs.RegisteredDialogs)
				{
					Toolbox.Instance.allDialog.Add(registeredDialog.Preset);
					if (registeredDialog.Preset.defaultOption)
					{
						Toolbox.Instance.defaultDialogOptions.Add(registeredDialog.Preset);
					}
					MethodInfo val = null;
					Enumerator<DialogPreset> enumerator2 = Toolbox.Instance.allDialog.GetEnumerator();
					while (enumerator2.MoveNext())
					{
						DialogPreset current2 = enumerator2.Current;
						if (((Object)current2).name == "WarnNotewriter")
						{
							val = __instance.dialogRef[current2];
							break;
						}
					}
					if (val == (MethodInfo)null)
					{
						PluginController<Plugin, IPluginBindings>.Log.LogError((object)"Warn note writer is no longer present in this version of the game. Dialog mods will no longer work at the moment.");
						break;
					}
					__instance.dialogRef.Add(registeredDialog.Preset, val);
					_customDialogInterceptors[((Object)registeredDialog.Preset).name] = registeredDialog;
				}
				if (Lib.Dialogs.RegisteredDialogs.Count > 0)
				{
					ManualLogSource log = PluginController<Plugin, IPluginBindings>.Log;
					bool flag = default(bool);
					BepInExInfoLogInterpolatedStringHandler val2 = new BepInExInfoLogInterpolatedStringHandler(23, 1, ref flag);
					if (flag)
					{
						((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("Loaded ");
						((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<int>(Lib.Dialogs.RegisteredDialogs.Count);
						((BepInExLogInterpolatedStringHandler)val2).AppendLiteral(" custom dialogs.");
					}
					log.LogInfo(val2);
				}
			}
		}

		[HarmonyPatch(typeof(DialogController), "WarnNotewriter")]
		public class DialogController_WarnNotewriter
		{
			[HarmonyPrefix]
			internal static bool Prefix(DialogController __instance, Citizen saysTo, Interactable saysToInteractable, NewNode where, Actor saidBy, bool success, NewRoom roomRef, SideJob jobRef)
			{
				if (_customDialogInterceptors.TryGetValue(((Object)__instance.preset).name, out var value) && value.DialogLogic != null)
				{
					value.DialogLogic.OnDialogExecute(__instance, saysTo, saysToInteractable, where, saidBy, success, roomRef, jobRef);
					return false;
				}
				return true;
			}
		}

		[HarmonyPatch(typeof(DialogController), "TestSpecialCaseAvailability")]
		public class DialogController_TestSpecialCaseAvailability
		{
			[HarmonyPrefix]
			internal static bool Prefix(ref bool __result, DialogPreset preset, Citizen saysTo, SideJob jobRef)
			{
				if (_customDialogInterceptors.TryGetValue(((Object)preset).name, out var value) && value.DialogLogic != null)
				{
					__result = value.DialogLogic.IsDialogShown(preset, saysTo, jobRef);
					if (__result)
					{
						value.UpdateDynamicText();
					}
					return false;
				}
				return true;
			}
		}

		[HarmonyPatch(typeof(DialogController), "ExecuteDialog")]
		public class DialogController_ExecuteDialog
		{
			[HarmonyPrefix]
			internal static void Prefix(DialogController __instance, DialogOption dialog, Interactable saysTo, NewNode where, Actor saidBy, ref ForceSuccess forceSuccess)
			{
				//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e6: Expected I4, but got Unknown
				if ((int)forceSuccess == 0 && _customDialogInterceptors.TryGetValue(((Object)dialog.preset).name, out var value) && value.DialogLogic != null)
				{
					Citizen saysTo2 = (Citizen)((dynamic)saysTo.isActor).Cast<Citizen>();
					forceSuccess = (ForceSuccess)(int)value.DialogLogic.ShouldDialogSucceedOverride(__instance, dialog, saysTo2, where, saidBy);
					value.UpdateDynamicText();
				}
			}
		}

		private static readonly Dictionary<string, DialogObject> _customDialogInterceptors = new Dictionary<string, DialogObject>();
	}
	internal class InputControllerPatches
	{
		[HarmonyPatch(typeof(InputController), "Update")]
		internal class InputController_Update
		{
			private static readonly List<string> _actionNames = new List<string>();

			private static readonly Dictionary<string, InteractionKey> _gameMappedKeyDictionary = new Dictionary<string, InteractionKey>();

			[HarmonyPrefix]
			internal static void Prefix(InputController __instance)
			{
				//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
				//IL_0109: Unknown result type (might be due to invalid IL or missing references)
				//IL_010e: 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_0146: Unknown result type (might be due to invalid IL or missing references)
				if (!((Behaviour)__instance).enabled || !ReInput.isReady || __instance.player == null)
				{
					return;
				}
				if (_actionNames.Count == 0)
				{
					foreach (InputAction item in MappingHelper.Instance.Actions.ToList<InputAction>())
					{
						_actionNames.Add(item.name);
					}
				}
				if (_gameMappedKeyDictionary.Count == 0)
				{
					string[] names = Enum.GetNames(typeof(InteractionKey));
					foreach (string text in names)
					{
						string text2 = text.Substring(0, 1).ToUpper() + text.Substring(1);
						if (_actionNames.Contains(text2))
						{
							_gameMappedKeyDictionary.Add(text2, Enum.Parse<InteractionKey>(text, ignoreCase: true));
						}
					}
				}
				foreach (string actionName in _actionNames)
				{
					InteractionKey key = (InteractionKey)(_gameMappedKeyDictionary.ContainsKey(actionName) ? ((int)_gameMappedKeyDictionary[actionName]) : 0);
					if (__instance.player.GetButtonDown(actionName))
					{
						Lib.InputDetection.ReportButtonStateChange(actionName, key, isDown: true);
					}
					else if (__instance.player.GetButtonUp(actionName))
					{
						Lib.InputDetection.ReportButtonStateChange(actionName, key, isDown: false);
					}
				}
			}
		}
	}
	internal class InteractionControllerPatches
	{
		[HarmonyPatch(typeof(InteractionController), "SetCurrentPlayerInteraction")]
		internal class InteractionController_SetCurrentPlayerInteraction
		{
			[HarmonyPrefix]
			internal static void Prefix(InteractionKey key, Interactable newInteractable, InteractableCurrentAction newCurrentAction, bool fpsItem = false)
			{
				//IL_008a: 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)
				Interaction.SimpleActionArgs currentPlayerInteraction = Lib.Interaction.CurrentPlayerInteraction;
				if (!Lib.Interaction.LongActionInProgress || currentPlayerInteraction == null)
				{
					if (currentPlayerInteraction != null)
					{
						currentPlayerInteraction.CurrentAction = newCurrentAction ?? null;
						currentPlayerInteraction.Action = ((newCurrentAction != null) ? newCurrentAction.currentAction : null) ?? null;
						currentPlayerInteraction.Key = key;
						currentPlayerInteraction.InteractableInstanceData = newInteractable;
						currentPlayerInteraction.IsFpsItemTarget = fpsItem;
					}
					else
					{
						Lib.Interaction.CurrentPlayerInteraction = new Interaction.SimpleActionArgs
						{
							CurrentAction = (newCurrentAction ?? null),
							Action = (((newCurrentAction != null) ? newCurrentAction.currentAction : null) ?? null),
							Key = key,
							InteractableInstanceData = newInteractable,
							IsFpsItemTarget = fpsItem
						};
					}
				}
			}
		}

		[HarmonyPatch(typeof(Interactable), "OnInteraction", new Type[]
		{
			typeof(InteractionAction),
			typeof(Actor),
			typeof(bool),
			typeof(float)
		})]
		internal class Interactable_OnInteraction
		{
			[HarmonyPrefix]
			internal static void Prefix(Interactable __instance, out Interaction.SimpleActionArgs __state, InteractionAction action, Actor who)
			{
				__state = null;
				if (!((Object)(object)who == (Object)null) && who.isPlayer)
				{
					__state = new Interaction.SimpleActionArgs
					{
						Action = action,
						InteractableInstanceData = __instance,
						IsFpsItemTarget = false
					};
					Lib.Interaction.OnActionStarted(__state, after: false);
				}
			}

			[HarmonyPostfix]
			internal static void Postfix(Interaction.SimpleActionArgs __state, Actor who)
			{
				if (__state != null && !((Object)(object)who == (Object)null) && who.isPlayer)
				{
					Lib.Interaction.OnActionStarted(__state, after: true);
				}
			}
		}

		[HarmonyPatch(typeof(InteractionController), "SetIllegalActionActive")]
		internal static class InteractionController_SetIllegalActionActive
		{
			[HarmonyPrefix]
			internal static void Prefix(out PlayerStatus.IllegalActionStatusArgs __state, bool val)
			{
				__state = null;
				if (!((Object)(object)Player.Instance == (Object)null) && val != ((Actor)Player.Instance).illegalActionActive)
				{
					__state = new PlayerStatus.IllegalActionStatusArgs(((Actor)Player.Instance).illegalActionActive, val);
					Lib.PlayerStatus.OnSetIllegalActionStatus(__state, after: false);
				}
			}

			[HarmonyPostfix]
			internal static void Postfix(PlayerStatus.IllegalActionStatusArgs __state)
			{
				if (__state != null)
				{
					Lib.PlayerStatus.OnSetIllegalActionStatus(__state, after: true);
				}
			}
		}
	}
	internal class InteriorCreatorPatches
	{
		[HarmonyPatch(typeof(InteriorCreator), "StartLoading")]
		internal class InteriorCreator_StartLoading
		{
			[HarmonyPrefix]
			internal static void Prefix()
			{
				_isGeneratingChunk = true;
				foreach (SyncDisk item in Lib.SyncDisks.RegisteredSyncDisks.Where((SyncDisk a) => !a.EnableWorldSpawn))
				{
					if (_removedPresets == null)
					{
						_removedPresets = new List<SyncDiskPreset>();
					}
					_removedPresets.Add(item.Preset);
					Toolbox.Instance.allSyncDisks.Remove(item.Preset);
				}
			}
		}

		[HarmonyPatch(typeof(Creator), "SetComplete")]
		internal class Creator_SetComplete
		{
			[HarmonyPrefix]
			internal static void Prefix()
			{
				if (!_isGeneratingChunk)
				{
					return;
				}
				_isGeneratingChunk = false;
				if (_removedPresets == null)
				{
					return;
				}
				foreach (SyncDiskPreset removedPreset in _removedPresets)
				{
					Toolbox.Instance.allSyncDisks.Add(removedPreset);
				}
				_removedPresets = null;
			}
		}

		private static bool _isGeneratingChunk;

		private static List<SyncDiskPreset> _removedPresets;
	}
	internal class SaveStateControllerPatches
	{
		[HarmonyPatch(typeof(CityConstructor), "StartLoading")]
		internal class CityConstructor_StartLoading
		{
			[HarmonyPrefix]
			internal static void Prefix(CityConstructor __instance)
			{
				if (__instance.generateNew || RestartSafeController.Instance.newGameLoadCity)
				{
					_isStartingNewGame = true;
					SessionDataPatches.SessionData_Update.LastTime = null;
					Lib.Time.InitializeTime(reset: true);
					Lib.SaveGame.OnNewGame(after: false);
				}
				else if (RestartSafeController.Instance.loadSaveGame)
				{
					SessionDataPatches.SessionData_Update.LastTime = null;
					Lib.Time.InitializeTime(reset: true);
					FileInfo saveStateFileInfo = RestartSafeController.Instance.saveStateFileInfo;
					string path = ((saveStateFileInfo != null) ? ((FileSystemInfo)saveStateFileInfo).FullPath : null);
					Lib.SaveGame.OnLoad(path, after: false);
				}
			}
		}

		[HarmonyPatch(typeof(MurderController), "OnStartGame")]
		internal class MurderController_OnStartGame
		{
			internal static Action InteractionActionCancelled = Lib.Interaction.OnLongActionCancelled;

			internal static Action InteractionActionCompleted = Lib.Interaction.OnLongActionCompleted;

			[HarmonyPrefix]
			internal static void Prefix()
			{
				if (_isStartingNewGame)
				{
					_isStartingNewGame = false;
					Lib.SaveGame.OnNewGame(after: true);
					return;
				}
				FileInfo saveStateFileInfo = RestartSafeController.Instance.saveStateFileInfo;
				string path = ((saveStateFileInfo != null) ? ((FileSystemInfo)saveStateFileInfo).FullPath : null);
				Lib.SaveGame.OnLoad(path, after: true);
				InteractionController.Instance.OnInteractionActionCancelled -= InteractionActionCancelled.op_Implicit(InteractionActionCancelled);
				InteractionController.Instance.OnInteractionActionCancelled += InteractionActionCancelled.op_Implicit(InteractionActionCancelled);
				InteractionController.Instance.OnInteractionActionCompleted -= InteractionActionCompleted.op_Implicit(InteractionActionCompleted);
				InteractionController.Instance.OnInteractionActionCompleted += InteractionActionCompleted.op_Implicit(InteractionActionCompleted);
			}
		}

		[HarmonyPatch(typeof(MainMenuController), "OnMenuComponentSwitchComplete")]
		internal class MainMenuController_OnMenuComponentSwitchComplete
		{
			private static Component? _previousComponentCompleted;

			private static bool _wasDirty;

			[HarmonyPrefix]
			internal static bool Prefix(MainMenuController __instance)
			{
				//IL_001c: 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_0031: 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)
				if (__instance.currentComponent == null || !_previousComponentCompleted.HasValue)
				{
					return true;
				}
				if (__instance.currentComponent.component == __instance.previousComponent)
				{
					return true;
				}
				if ((Component?)__instance.currentComponent.component == _previousComponentCompleted && SessionData.Instance.dirtyScene == _wasDirty)
				{
					return false;
				}
				return true;
			}

			[HarmonyPostfix]
			internal static void Postfix(MainMenuController __instance)
			{
				//IL_0015: Unknown result type (might be due to invalid IL or missing references)
				MenuComponent currentComponent = __instance.currentComponent;
				_previousComponentCompleted = ((currentComponent != null) ? new Component?(currentComponent.component) : null);
				_wasDirty = SessionData.Instance.dirtyScene;
			}
		}

		[HarmonyPatch(typeof(SaveStateController), "CaptureSaveStateAsync")]
		internal class SaveStateController_CaptureSaveStateAsync
		{
			[HarmonyPrefix]
			internal static void Prefix(string path)
			{
				if (path != null && Game.Instance.useSaveGameCompression && path.EndsWith(".sod"))
				{
					path += "b";
				}
				path = path.Replace('/', '\\');
				Lib.SaveGame.OnSave(path, after: false);
			}

			[HarmonyPostfix]
			internal static void Postfix(string path)
			{
				if (path != null && Game.Instance.useSaveGameCompression && path.EndsWith(".sod"))
				{
					path += "b";
				}
				path = path.Replace('/', '\\');
				Lib.SaveGame.OnSave(path, after: true);
			}
		}

		[HarmonyPatch(typeof(MainMenuController), "DeleteSave")]
		internal class MainMenuController_DeleteSave
		{
			private static bool _delete;

			private static FileInfo _fileInfo;

			[HarmonyPrefix]
			internal static void Prefix(MainMenuController __instance)
			{
				if ((Object)(object)__instance.selectedSave != (Object)null && !__instance.selectedSave.isInternal && __instance.selectedSave.info != null && File.Exists(((FileSystemInfo)__instance.selectedSave.info).FullName))
				{
					_delete = true;
					_fileInfo = __instance.selectedSave.info;
					Lib.SaveGame.OnDelete(((FileSystemInfo)_fileInfo).FullName, after: false);
				}
			}

			[HarmonyPostfix]
			internal static void Postfix()
			{
				if (_delete)
				{
					_delete = false;
					string fullPath = ((FileSystemInfo)_fileInfo).FullPath;
					_fileInfo = null;
					Lib.SaveGame.OnDelete(fullPath, after: true);
				}
			}
		}

		private static bool _isStartingNewGame;
	}
	internal class SessionDataPatches
	{
		[HarmonyPatch(typeof(SessionData), "PauseGame")]
		internal static class SessionDataPauseGame
		{
			[HarmonyPostfix]
			internal static void Postfix()
			{
				if (!_wasPaused)
				{
					_wasPaused = true;
					Lib.Time.IsGamePaused = true;
					Lib.Time.OnPauseModeChanged(paused: true);
				}
			}
		}

		[HarmonyPatch(typeof(SessionData), "ResumeGame")]
		internal static class SessionDataResumeGame
		{
			[HarmonyPostfix]
			internal static void Postfix()
			{
				if (_wasPaused)
				{
					_wasPaused = false;
					Lib.Time.IsGamePaused = false;
					Lib.Time.OnPauseModeChanged(paused: false);
				}
			}
		}

		[HarmonyPatch(typeof(SessionData), "Update")]
		internal static class SessionData_Update
		{
			internal static Time.TimeData? LastTime;

			[HarmonyPostfix]
			internal static void Postfix()
			{
				if (SessionData.Instance.play)
				{
					if (!Lib.Time.IsInitialized)
					{
						Lib.Time.InitializeTime();
					}
					Time.TimeData currentDateTime = Lib.Time.CurrentDateTime;
					if (!LastTime.HasValue)
					{
						LastTime = currentDateTime;
					}
					if (!LastTime.Equals(currentDateTime))
					{
						Lib.Time.OnTimeChanged(LastTime.Value, currentDateTime);
						LastTime = currentDateTime;
					}
				}
			}
		}

		[HarmonyPatch(typeof(SessionData), "Start")]
		internal static class SessionData_Start
		{
			[HarmonyPostfix]
			internal static void Postfix()
			{
				Lib.Time.InitializeTime();
			}
		}

		private static bool _wasPaused;
	}
	internal class UpgradesControllerPatches
	{
		[HarmonyPatch(typeof(UpgradesController), "InstallSyncDisk")]
		internal class InstallSyncDiskHook
		{
			[HarmonyPrefix]
			internal static void Prefix(Upgrades application)
			{
				if (application != null && !((SoCustomComparison)(object)application.preset == (SoCustomComparison)null))
				{
					Lib.SyncDisks.RaiseSyncDiskEvent(SyncDisks.SyncDiskEvent.OnInstall, after: false, application);
				}
			}

			[HarmonyPostfix]
			public static void Postfix(Upgrades application)
			{
				if (application != null && !((SoCustomComparison)(object)application.preset == (SoCustomComparison)null))
				{
					Lib.SyncDisks.RaiseSyncDiskEvent(SyncDisks.SyncDiskEvent.OnInstall, after: true, application);
				}
			}
		}

		[HarmonyPatch(typeof(UpgradesController), "UpgradeSyncDisk")]
		internal class UpgradeSyncDiskHook
		{
			[HarmonyPrefix]
			public static void Prefix(Upgrades upgradeThis)
			{
				if (upgradeThis != null && !((SoCustomComparison)(object)upgradeThis.preset == (SoCustomComparison)null))
				{
					Lib.SyncDisks.RaiseSyncDiskEvent(SyncDisks.SyncDiskEvent.OnUpgrade, after: false, upgradeThis);
				}
			}

			[HarmonyPostfix]
			public static void Postfix(Upgrades upgradeThis)
			{
				if (upgradeThis != null && !((SoCustomComparison)(object)upgradeThis.preset == (SoCustomComparison)null))
				{
					Lib.SyncDisks.RaiseSyncDiskEvent(SyncDisks.SyncDiskEvent.OnUpgrade, after: true, upgradeThis);
				}
			}
		}

		[HarmonyPatch(typeof(UpgradesController), "UninstallSyncDisk")]
		internal class UninstallSyncDiskHook
		{
			[HarmonyPrefix]
			public static void Prefix(Upgrades removal)
			{
				if (removal != null && !((SoCustomComparison)(object)removal.preset == (SoCustomComparison)null))
				{
					Lib.SyncDisks.RaiseSyncDiskEvent(SyncDisks.SyncDiskEvent.OnUninstall, after: false, removal);
				}
			}

			[HarmonyPostfix]
			public static void Postfix(Upgrades removal)
			{
				if (removal != null && !((SoCustomComparison)(object)removal.preset == (SoCustomComparison)null))
				{
					Lib.SyncDisks.RaiseSyncDiskEvent(SyncDisks.SyncDiskEvent.OnUninstall, after: true, removal);
				}
			}
		}
	}
}
namespace SOD.Common.ConfigBindings
{
	public interface IPluginBindings
	{
		[Binding(false, "Enables extra logging for development.", null)]
		bool DebugMode { get; set; }
	}
}
namespace SOD.Common.Helpers
{
	public sealed class DdsStrings
	{
		public string this[string dictionary, string key]
		{
			get
			{
				if ((Object)(object)Strings.Instance == (Object)null || Strings.stringTable == null)
				{
					return null;
				}
				if (!Strings.textFilesLoaded)
				{
					Strings.Instance.LoadTextFiles();
				}
				Dictionary<string, DisplayString> val = default(Dictionary<string, DisplayString>);
				DisplayString val2 = default(DisplayString);
				if (Strings.stringTable.TryGetValue(dictionary.ToLower(), ref val) && val.TryGetValue(key.ToLower(), ref val2))
				{
					return val2.displayStr;
				}
				return null;
			}
			set
			{
				//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
				//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
				//IL_00cb: Expected O, but got Unknown
				//IL_009a: 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_00ab: Expected O, but got Unknown
				if ((Object)(object)Strings.Instance == (Object)null || Strings.stringTable == null)
				{
					throw new Exception("DDS Strings are not yet initialized at this point.");
				}
				if (!Strings.textFilesLoaded)
				{
					Strings.Instance.LoadTextFiles();
				}
				string text = dictionary.ToLower();
				string text2 = key.ToLower();
				Dictionary<string, DisplayString> val = default(Dictionary<string, DisplayString>);
				if (Strings.stringTable.TryGetValue(text, ref val))
				{
					DisplayString val2 = default(DisplayString);
					if (val.TryGetValue(text2, ref val2))
					{
						if (value == null)
						{
							val.Remove(text2);
							if (val.Count == 0)
							{
								Strings.stringTable.Remove(text);
							}
						}
						else
						{
							val2.displayStr = value;
						}
					}
					else if (value == null)
					{
						if (val.Count == 0)
						{
							Strings.stringTable.Remove(text);
						}
					}
					else
					{
						val[text2] = new DisplayString
						{
							displayStr = value
						};
					}
				}
				else if (value != null)
				{
					Dictionary<string, DisplayString> val3 = new Dictionary<string, DisplayString>();
					val3.Add(text2, new DisplayString
					{
						displayStr = value
					});
					Strings.stringTable.Add(text, val3);
				}
			}
		}

		internal DdsStrings()
		{
		}

		public void AddOrUpdate(string dictionary, string key, string value)
		{
			this[dictionary, key] = value;
		}

		public void Remove(string dictionary, string key)
		{
			this[dictionary, key] = null;
		}

		public string Get(string dictionary, string key)
		{
			return this[dictionary, key] ?? string.Empty;
		}

		public bool Exists(string dictionary, string key)
		{
			return this[dictionary, key] != null;
		}

		public void AddOrUpdateEntries(string dictionary, params (string key, string value)[] entries)
		{
			if (entries != null)
			{
				for (int i = 0; i < entries.Length; i++)
				{
					(string key, string value) tuple = entries[i];
					string item = tuple.key;
					string item2 = tuple.value;
					this[dictionary, item] = item2;
				}
			}
		}

		public void RemoveEntries(string dictionary, params string[] entries)
		{
			if (entries != null)
			{
				foreach (string key in entries)
				{
					this[dictionary, key] = null;
				}
			}
		}
	}
	public sealed class Dialog
	{
		internal List<DialogObject> RegisteredDialogs = new List<DialogObject>();

		public IReadOnlyList<DialogObject> KnownModDialogs => RegisteredDialogs;

		internal Dialog()
		{
		}

		public DialogBuilder Builder(string dialogName = null)
		{
			return new DialogBuilder(dialogName);
		}
	}
	public sealed class GameMessage
	{
		private readonly HashSet<string> _queuedPlayerSpeechMessages = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

		internal GameMessage()
		{
		}

		public void Broadcast(string message, GameMessageType messageType = 0, Icon icon = 21, Color? color = null, float delay = 0f)
		{
			//IL_001f: 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_0027: 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)
			if (!color.HasValue)
			{
				color = InterfaceControls.Instance.messageRed;
			}
			InterfaceController.Instance.NewGameMessage(messageType, 0, message, icon, (AudioEvent)null, true, color.Value, -1, delay, (RectTransform)null, (PingOnComplete)0, (Evidence)null, (List<DataKey>)null, (Sprite)null);
		}

		public void ShowPlayerSpeech(string message, float durationSec, bool doNotQueueMultiple = true)
		{
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			if (!doNotQueueMultiple || !_queuedPlayerSpeechMessages.Contains(message))
			{
				_queuedPlayerSpeechMessages.Add(message);
				((Actor)Player.Instance).speechController.Speak("", "temp", false, false, true, 0f, true, Color.white, (Human)null, false, false, (SideJob)null, (DialogPreset)null, (AISpeechPreset)null, (Interactable)null);
				RuntimeHelper.StartCoroutine(ShowPlayerSpeechWaitForBubble(message, durationSec));
			}
		}

		private IEnumerator ShowPlayerSpeechWaitForBubble(string message, float durationSec)
		{
			SpeechController speechController = ((Actor)Player.Instance).speechController;
			while (UnityHelpers.IsNullOrDestroyed((object)speechController.activeSpeechBubble, true) || speechController.activeSpeechBubble.actualString != string.Empty)
			{
				yield return (object)new WaitForEndOfFrame();
			}
			SpeechBubbleController activeSpeechBubble = speechController.activeSpeechBubble;
			activeSpeechBubble.actualString = message;
			activeSpeechBubble.oncreenTime = durationSec;
			while (!UnityHelpers.IsNullOrDestroyed((object)speechController.activeSpeechBubble, true) && speechController.activeSpeechBubble.actualString == message)
			{
				yield return (object)new WaitForEndOfFrame();
			}
			_queuedPlayerSpeechMessages.Remove(message);
		}
	}
	public sealed class InputDetection
	{
		public event EventHandler<InputDetectionEventArgs> OnButtonStateChanged;

		internal InputDetection()
		{
		}

		internal void ReportButtonStateChange(string actionName, InteractionKey key, bool isDown)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			this.OnButtonStateChanged?.Invoke(this, new InputDetectionEventArgs(actionName, key, isDown));
		}
	}
	public sealed class InputDetectionEventArgs : EventArgs
	{
		public string ActionName { get; }

		public InteractionKey Key { get; }

		public bool IsDown { get; }

		internal InputDetectionEventArgs(string actionName, InteractionKey key, bool isDown)
		{
			//IL_000e: 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)
			ActionName = actionName;
			Key = key;
			IsDown = isDown;
		}
	}
	public sealed class Interaction
	{
		public class SimpleActionArgs : EventArgs
		{
			internal InteractionAction Action { get; set; }

			internal InteractableCurrentAction CurrentAction { get; set; }

			public InteractionKey Key { get; set; }

			public InteractableInstanceData InteractableInstanceData { get; internal set; }

			public bool IsFpsItemTarget { get; internal set; }

			internal SimpleActionArgs()
			{
			}

			public bool TryGetAction(out InteractionAction action)
			{
				action = Action;
				return action != null;
			}

			public bool TryGetCurrentAction(out InteractableCurrentAction currentAction)
			{
				currentAction = CurrentAction;
				return currentAction != null;
			}
		}

		internal SimpleActionArgs CurrentPlayerInteraction;

		internal bool LongActionInProgress;

		public event EventHandler<SimpleActionArgs> OnBeforeActionStarted;

		public event EventHandler<SimpleActionArgs> OnAfterActionStarted;

		public event EventHandler<SimpleActionArgs> OnAfterLongActionCancelled;

		public event EventHandler<SimpleActionArgs> OnAfterLongActionCompleted;

		internal Interaction()
		{
		}

		internal void OnLongActionCancelled()
		{
			LongActionInProgress = false;
			this.OnAfterLongActionCancelled?.Invoke(this, CurrentPlayerInteraction);
		}

		internal void OnLongActionCompleted()
		{
			LongActionInProgress = false;
			this.OnAfterLongActionCompleted?.Invoke(this, CurrentPlayerInteraction);
		}

		internal void OnActionStarted(SimpleActionArgs args, bool after)
		{
			if (after)
			{
				this.OnAfterActionStarted?.Invoke(this, args);
			}
			else
			{
				this.OnBeforeActionStarted?.Invoke(this, args);
			}
		}
	}
	public sealed class PlayerStatus
	{
		public sealed class IllegalActionStatusArgs : EventArgs
		{
			public bool PreviousIllegalStatus { get; }

			public bool NewIllegalStatus { get; }

			internal IllegalActionStatusArgs(bool previous, bool @new)
			{
				PreviousIllegalStatus = previous;
				NewIllegalStatus = @new;
			}
		}

		internal Dictionary<string, IllegalStatusModifier> IllegalStatusModifierDictionary { get; private set; }

		public event EventHandler<IllegalActionStatusArgs> OnBeforeSetIllegalStatus;

		public event EventHandler<IllegalActionStatusArgs> OnAfterSetIllegalStatus;

		internal PlayerStatus()
		{
		}

		public void SetIllegalStatusModifier(string key, TimeSpan? duration = null, bool overwrite = false)
		{
			if (string.IsNullOrEmpty(key))
			{
				throw new ArgumentException("Key cannot be null or empty.", "key");
			}
			if (IllegalStatusModifierDictionary == null)
			{
				Dictionary<string, IllegalStatusModifier> dictionary2 = (IllegalStatusModifierDictionary = new Dictionary<string, IllegalStatusModifier>());
			}
			if (IllegalStatusModifierDictionary.TryGetValue(key, out var value))
			{
				if (!overwrite)
				{
					return;
				}
				value.Stop();
				IllegalStatusModifierDictionary.Remove(key);
			}
			value = new IllegalStatusModifier(key, duration);
			IllegalStatusModifierDictionary.Add(key, value);
			value.Start();
			UpdatePlayerIllegalStatus();
		}

		public void RemoveIllegalStatusModifier(string key)
		{
			if (string.IsNullOrEmpty(key))
			{
				throw new ArgumentException("Key cannot be null or empty.", "key");
			}
			if (IllegalStatusModifierDictionary != null && IllegalStatusModifierDictionary.TryGetValue(key, out var value))
			{
				value.Stop();
				IllegalStatusModifierDictionary.Remove(key);
				UpdatePlayerIllegalStatus();
			}
		}

		public bool ModifierExists(string key, out TimeSpan? timeLeft)
		{
			timeLeft = null;
			if (IllegalStatusModifierDictionary != null && IllegalStatusModifierDictionary.TryGetValue(key, out var value))
			{
				if (value.TimeRemainingSec > 0f)
				{
					timeLeft = TimeSpan.FromSeconds(value.TimeRemainingSec);
				}
				return true;
			}
			return false;
		}

		internal void UpdatePlayerIllegalStatus()
		{
			if (IllegalStatusModifierDictionary != null && IllegalStatusModifierDictionary.Any())
			{
				AdjustIllegalStatus(((Actor)Player.Instance).illegalStatus, newStatus: true);
			}
			else
			{
				AdjustIllegalStatus(((Actor)Player.Instance).illegalStatus, newStatus: false);
			}
		}

		internal void Load(string path)
		{
			string uniqueString = Lib.SaveGame.GetUniqueString(path);
			string savestoreDirectoryPath = Lib.SaveGame.GetSavestoreDirectoryPath(Assembly.GetExecutingAssembly(), "playerstatus_" + uniqueString + ".json");
			if (!File.Exists(savestoreDirectoryPath))
			{
				return;
			}
			List<IllegalStatusModifier.JsonData> list = JsonSerializer.Deserialize<List<IllegalStatusModifier.JsonData>>(File.ReadAllText(savestoreDirectoryPath));
			if (list.Count <= 0)
			{
				return;
			}
			IllegalStatusModifierDictionary = new Dictionary<string, IllegalStatusModifier>();
			foreach (IllegalStatusModifier.JsonData item in list)
			{
				IllegalStatusModifier illegalStatusModifier = new IllegalStatusModifier(item.Key, (item.Time == 0f) ? null : new TimeSpan?(TimeSpan.FromSeconds(item.Time)));
				IllegalStatusModifierDictionary[item.Key] = illegalStatusModifier;
				illegalStatusModifier.Start();
			}
			UpdatePlayerIllegalStatus();
		}

		internal void Save(string path)
		{
			string uniqueString = Lib.SaveGame.GetUniqueString(path);
			string savestoreDirectoryPath = Lib.SaveGame.GetSavestoreDirectoryPath(Assembly.GetExecutingAssembly(), "playerstatus_" + uniqueString + ".json");
			if (IllegalStatusModifierDictionary == null || IllegalStatusModifierDictionary.Count == 0)
			{
				if (File.Exists(savestoreDirectoryPath))
				{
					File.Delete(savestoreDirectoryPath);
				}
				return;
			}
			string contents = JsonSerializer.Serialize(IllegalStatusModifierDictionary.Select((KeyValuePair<string, IllegalStatusModifier> a) => new IllegalStatusModifier.JsonData
			{
				Key = a.Key,
				Time = a.Value.TimeRemainingSec
			}).ToList(), new JsonSerializerOptions
			{
				WriteIndented = false
			});
			File.WriteAllText(savestoreDirectoryPath, contents);
		}

		internal void ResetStatusTracking()
		{
			if (IllegalStatusModifierDictionary == null)
			{
				return;
			}
			foreach (IllegalStatusModifier value in IllegalStatusModifierDictionary.Values)
			{
				value.Stop();
			}
			IllegalStatusModifierDictionary = null;
		}

		private static void AdjustIllegalStatus(bool previousStatus, bool newStatus)
		{
			if (previousStatus != newStatus)
			{
				IllegalActionStatusArgs eventArgs = new IllegalActionStatusArgs(previousStatus, newStatus);
				Lib.PlayerStatus.OnSetIllegalActionStatus(eventArgs, after: false);
				((Actor)Player.Instance).illegalActionActive = newStatus;
				Player.Instance.illegalActionTimer = (newStatus ? float.MaxValue : 0f);
				((Actor)Player.Instance).UpdateIllegalStatus();
				Lib.PlayerStatus.OnSetIllegalActionStatus(eventArgs, newStatus);
			}
		}

		internal void OnSetIllegalActionStatus(IllegalActionStatusArgs eventArgs, bool after)
		{
			if (after)
			{
				this.OnAfterSetIllegalStatus?.Invoke(this, eventArgs);
			}
			else
			{
				this.OnBeforeSetIllegalStatus?.Invoke(this, eventArgs);
			}
		}
	}
	public sealed class PluginDetection
	{
		public bool AllPluginsFinishedLoading { get; private set; }

		public event EventHandler OnAllPluginsFinishedLoading;

		internal PluginDetection()
		{
			((BaseChainloader<BasePlugin>)(object)IL2CPPChainloader.Instance).Finished += OnAllPluginsFinishedLoadingListener;
		}

		private void OnAllPluginsFinishedLoadingListener()
		{
			AllPluginsFinishedLoading = true;
			this.OnAllPluginsFinishedLoading?.Invoke(this, EventArgs.Empty);
			((BaseChainloader<BasePlugin>)(object)IL2CPPChainloader.Instance).Finished -= OnAllPluginsFinishedLoadingListener;
		}

		public bool IsPluginLoaded(string pluginGuid)
		{
			return ((BaseChainloader<BasePlugin>)(object)IL2CPPChainloader.Instance).Plugins.ContainsKey(pluginGuid);
		}

		public bool TryGetPluginInfo(string pluginGuid, out PluginInfo info)
		{
			return ((BaseChainloader<BasePlugin>)(object)IL2CPPChainloader.Instance).Plugins.TryGetValue(pluginGuid, out info);
		}

		public PluginInfo GetPluginInfo(string pluginGuid)
		{
			if (!TryGetPluginInfo(pluginGuid, out var info))
			{
				throw new KeyNotFoundException("Plugin GUID (" + pluginGuid + ") not found.");
			}
			return info;
		}

		public T GetPluginConfigEntryValue<T>(string pluginGuid, string section, string key)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			ConfigEntry<T> val = default(ConfigEntry<T>);
			if (!((BasePlugin)ReflectionExtensions.TryCast(GetPluginInfo(pluginGuid).Instance, typeof(BasePlugin))).Config.TryGetEntry<T>(section, key, ref val))
			{
				throw new InvalidOperationException($"No configuration entry found for ({section}, {key}).");
			}
			return val.Value;
		}

		public void AddPluginConfigEntryChangedListener(string pluginGuid, Action<SettingChangedEventArgs> listener)
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			((BasePlugin)ReflectionExtensions.TryCast(GetPluginInfo(pluginGuid).Instance, typeof(BasePlugin))).Config.SettingChanged += delegate(object? _, SettingChangedEventArgs args)
			{
				listener(args);
			};
		}
	}
	public sealed class SaveGame
	{
		private const uint FnvPrime = 16777619u;

		private const uint FnvOffsetBasis = 2166136261u;

		internal bool IsSaving { get; private set; }

		public event EventHandler<SaveGameArgs> OnBeforeSave;

		public event EventHandler<SaveGameArgs> OnAfterSave;

		public event EventHandler<SaveGameArgs> OnBeforeLoad;

		public event EventHandler<SaveGameArgs> OnAfterLoad;

		public event EventHandler<SaveGameArgs> OnBeforeDelete;

		public event EventHandler<SaveGameArgs> OnAfterDelete;

		public event EventHandler OnBeforeNewGame;

		public event EventHandler OnAfterNewGame;

		internal SaveGame()
		{
		}

		public string GetUniqueString(string value)
		{
			return GetFnvHash(value).ToString();
		}

		public uint GetUniqueNumber(string value)
		{
			return GetFnvHash(value);
		}

		private static uint GetFnvHash(string value)
		{
			if (value == null)
			{
				throw new ArgumentNullException("value");
			}
			uint num = 2166136261u;
			foreach (char c in value)
			{
				num ^= c;
				num *= 16777619;
			}
			return num;
		}

		public string GetSavestoreDirectoryPath(Assembly executingAssembly, string fileName)
		{
			string text = GetSavestoreDirectoryPath(executingAssembly);
			if (!string.IsNullOrWhiteSpace(fileName))
			{
				text = Path.Combine(text, fileName);
			}
			return text;
		}

		public string GetSavestoreDirectoryPath(Assembly executingAssembly)
		{
			string text = Path.Combine(Path.GetDirectoryName(executingAssembly.Location), "Savestore");
			if (!Directory.Exists(text))
			{
				Directory.CreateDirectory(text);
			}
			return text;
		}

		public string GetPluginDirectoryPath(Assembly executingAssembly)
		{
			string directoryName = Path.GetDirectoryName(executingAssembly.Location);
			if (!Directory.Exists(directoryName))
			{
				throw new Exception("There is no plugin directory for this assembly location: " + directoryName);
			}
			return directoryName;
		}

		internal void OnSave(string path, bool after)
		{
			if (after)
			{
				this.OnAfterSave?.Invoke(this, new SaveGameArgs(path));
			}
			else
			{
				this.OnBeforeSave?.Invoke(this, new SaveGameArgs(path));
			}
			if (after)
			{
				IsSaving = false;
				if (Lib.PlayerStatus.IllegalStatusModifierDictionary != null && Lib.PlayerStatus.IllegalStatusModifierDictionary.Count > 0)
				{
					Player.Instance.illegalActionTimer = float.MaxValue;
				}
				Lib.SyncDisks.CheckForSyncDiskData(onLoad: false, path);
				Lib.PlayerStatus.Save(path);
			}
			else
			{
				IsSaving = true;
				if (Lib.PlayerStatus.IllegalStatusModifierDictionary != null && Lib.PlayerStatus.IllegalStatusModifierDictionary.Count > 0)
				{
					Player.Instance.illegalActionTimer = 1f;
				}
			}
		}

		internal void OnLoad(string path, bool after)
		{
			if (after)
			{
				this.OnAfterLoad?.Invoke(this, new SaveGameArgs(path));
			}
			else
			{
				this.OnBeforeLoad?.Invoke(this, new SaveGameArgs(path));
			}
			if (after)
			{
				Lib.SyncDisks.CheckForSyncDiskData(onLoad: true, path);
				Lib.PlayerStatus.Load(path);
			}
			else
			{
				Lib.PlayerStatus.ResetStatusTracking();
			}
		}

		internal void OnDelete(string path, bool after)
		{
			if (after)
			{
				this.OnAfterDelete?.Invoke(this, new SaveGameArgs(path));
			}
			else
			{
				this.OnBeforeDelete?.Invoke(this, new SaveGameArgs(path));
			}
			string uniqueString = Lib.SaveGame.GetUniqueString(path);
			string savestoreDirectoryPath = Lib.SaveGame.GetSavestoreDirectoryPath(Assembly.GetExecutingAssembly(), "syncdiskdata_" + uniqueString + ".json");
			if (File.Exists(savestoreDirectoryPath))
			{
				File.Delete(savestoreDirectoryPath);
			}
			string savestoreDirectoryPath2 = Lib.SaveGame.GetSavestoreDirectoryPath(Assembly.GetExecutingAssembly(), "playerstatus_" + uniqueString + ".json");
			if (File.Exists(savestoreDirectoryPath2))
			{
				File.Delete(savestoreDirectoryPath2);
			}
		}

		internal void OnNewGame(bool after)
		{
			if (after)
			{
				this.OnAfterNewGame?.Invoke(this, EventArgs.Empty);
			}
			else
			{
				Lib.PlayerStatus.ResetStatusTracking();
				this.OnBeforeNewGame?.Invoke(this, EventArgs.Empty);
			}
			Lib.SyncDisks.InstalledSyncDisks.Clear();
		}
	}
	public sealed class SaveGameArgs : EventArgs
	{
		public string FilePath { get; }

		internal SaveGameArgs(string filePath)
		{
			FilePath = filePath;
		}
	}
	public sealed class SyncDisks
	{
		internal class InstalledSyncDiskData
		{
			public string SyncDiskName { get; set; }

			public string Effect { get; set; }

			public List<string> UpgradeOptions { get; set; }

			public InstalledSyncDiskData()
			{
			}

			internal InstalledSyncDiskData(string name, string effectName)
			{
				SyncDiskName = name;
				Effect = effectName;
				UpgradeOptions = new List<string>();
			}
		}

		internal class SyncDiskJsonData
		{
			public List<InstalledSyncDiskData> SyncDiskData { get; set; }
		}

		internal enum SyncDiskEvent
		{
			OnInstall,
			OnUninstall,
			OnUpgrade
		}

		public readonly struct Effect : IEquatable<Effect>
		{
			public readonly int Id;

			public readonly string Name;

			internal readonly string DdsIdentifier;

			internal Effect(int id, string name)
			{
				Id = id;
				Name = SyncDisk.GetName(name);
				DdsIdentifier = name;
			}

			public bool Equals(Effect other)
			{
				return Id == other.Id;
			}

			public override bool Equals(object obj)
			{
				if (obj is Effect other)
				{
					return Equals(other);
				}
				return false;
			}

			public static bool operator ==(Effect left, Effect right)
			{
				return left.Equals(right);
			}

			public static bool operator !=(Effect left, Effect right)
			{
				return !(left == right);
			}

			public override int GetHashCode()
			{
				return Id.GetHashCode();
			}
		}

		public readonly struct UpgradeOption : IEquatable<UpgradeOption>
		{
			public readonly int? Id1;

			public readonly int? Id2;

			public readonly int? Id3;

			public readonly string Name1;

			public readonly string Name2;

			public readonly string Name3;

			internal readonly SyncDiskBuilder.Options Options;

			internal bool HasOptions
			{
				get
				{
					if (string.IsNullOrWhiteSpace(Name1) && string.IsNullOrWhiteSpace(Name2))
					{
						return !string.IsNullOrWhiteSpace(Name3);
					}
					return true;
				}
			}

			internal UpgradeOption(SyncDiskBuilder.Options options)
			{
				//IL_004f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0059: Expected I4, but got Unknown
				//IL_007e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0088: Expected I4, but got Unknown
				//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b7: Expected I4, but got Unknown
				Id1 = null;
				Id2 = null;
				Id3 = null;
				Name1 = null;
				Name2 = null;
				Name3 = null;
				Options = options;
				if (!string.IsNullOrWhiteSpace(options.Option1))
				{
					Id1 = (int)options.Option1Effect;
					Name1 = SyncDisk.GetName(options.Option1);
				}
				if (!string.IsNullOrWhiteSpace(options.Option2))
				{
					Id2 = (int)options.Option2Effect;
					Name2 = SyncDisk.GetName(options.Option2);
				}
				if (!string.IsNullOrWhiteSpace(options.Option3))
				{
					Id3 = (int)options.Option3Effect;
					Name3 = SyncDisk.GetName(options.Option3);
				}
			}

			public bool Equals(UpgradeOption other)
			{
				if (Id1 == other.Id1 && Id2 == other.Id2)
				{
					return Id3 == other.Id3;
				}
				return false;
			}

			public override bool Equals(object obj)
			{
				if (obj is UpgradeOption other)
				{
					return Equals(other);
				}
				return false;
			}

			public static bool operator ==(UpgradeOption left, UpgradeOption right)
			{
				return left.Equals(right);
			}

			public static bool operator !=(UpgradeOption left, UpgradeOption right)
			{
				return !(left == right);
			}

			public override int GetHashCode()
			{
				return HashCode.Combine(Id1, Id2, Id3);
			}
		}

		private static int? _currentSyncDiskEffectId;

		private static int? _currentSyncDiskOptionId;

		internal readonly Dictionary<string, List<InstalledSyncDiskData>> InstalledSyncDisks = new Dictionary<string, List<InstalledSyncDiskData>>();

		internal List<SyncDisk> RegisteredSyncDisks = new List<SyncDisk>();

		public IReadOnlyList<SyncDisk> KnownModSyncDisks => RegisteredSyncDisks;

		public event EventHandler<SyncDiskArgs> OnBeforeSyncDiskInstalled;

		public event EventHandler<SyncDiskArgs> OnAfterSyncDiskInstalled;

		public event EventHandler<SyncDiskArgs> OnBeforeSyncDiskUpgraded;

		public event EventHandler<SyncDiskArgs> OnAfterSyncDiskUpgraded;

		public event EventHandler<SyncDiskArgs> OnBeforeSyncDiskUninstalled;

		public event EventHandler<SyncDiskArgs> OnAfterSyncDiskUninstalled;

		internal SyncDisks()
		{
		}

		internal static int GetNewSyncDiskEffectId()
		{
			if (!_currentSyncDiskEffectId.HasValue)
			{
				int[] source = (int[])Enum.GetValues(typeof(Effect));
				_currentSyncDiskEffectId = source.DefaultIfEmpty().Max();
			}
			_currentSyncDiskEffectId++;
			return _currentSyncDiskEffectId.Value;
		}

		internal static int GetNewSyncDiskOptionId()
		{
			if (!_currentSyncDiskOptionId.HasValue)
			{
				int[] source = (int[])Enum.GetValues(typeof(UpgradeEffect));
				_currentSyncDiskOptionId = source.DefaultIfEmpty().Max();
			}
			_currentSyncDiskOptionId++;
			return _currentSyncDiskOptionId.Value;
		}

		public SyncDiskBuilder Builder(string syncDiskName, string pluginGuid, bool reRaiseEventsOnSaveLoad = true)
		{
			if (string.IsNullOrWhiteSpace(syncDiskName))
			{
				throw new ArgumentException("Parameter cannot be empty or whitespace.", "syncDiskName");
			}
			if (string.IsNullOrWhiteSpace(pluginGuid))
			{
				throw new ArgumentException("Parameter cannot be empty or whitespace.", "pluginGuid");
			}
			return new SyncDiskBuilder(syncDiskName, pluginGuid, reRaiseEventsOnSaveLoad);
		}

		internal void CheckForSyncDiskData(bool onLoad, string saveFilePath)
		{
			//IL_0501: Unknown result type (might be due to invalid IL or missing references)
			//IL_0508: Expected O, but got Unknown
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Expected O, but got Unknown
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: Expected O, but got Unknown
			//IL_01df: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e6: Expected O, but got Unknown
			//IL_02e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e8: Expected O, but got Unknown
			//IL_0375: Unknown result type (might be due to invalid IL or missing references)
			//IL_037c: Expected O, but got Unknown
			if (onLoad)
			{
				InstalledSyncDisks.Clear();
			}
			string uniqueString = Lib.SaveGame.GetUniqueString(saveFilePath);
			string savestoreDirectoryPath = Lib.SaveGame.GetSavestoreDirectoryPath(Assembly.GetExecutingAssembly(), "syncdiskdata_" + uniqueString + ".json");
			if (onLoad && !File.Exists(savestoreDirectoryPath))
			{
				return;
			}
			bool flag = default(bool);
			BepInExInfoLogInterpolatedStringHandler val;
			if (onLoad)
			{
				SyncDiskJsonData syncDiskJsonData = JsonSerializer.Deserialize<SyncDiskJsonData>(File.ReadAllText(savestoreDirectoryPath));
				if (syncDiskJsonData == null || syncDiskJsonData.SyncDiskData == null)
				{
					return;
				}
				{
					foreach (InstalledSyncDiskData disk in syncDiskJsonData.SyncDiskData)
					{
						SyncDisk syncDisk = RegisteredSyncDisks.FirstOrDefault((SyncDisk a) => ((Object)a.Preset).name.Equals(disk.SyncDiskName));
						if (syncDisk == null)
						{
							ManualLogSource log = PluginController<Plugin, IPluginBindings>.Log;
							val = new BepInExInfoLogInterpolatedStringHandler(67, 1, ref flag);
							if (flag)
							{
								((BepInExLogInterpolatedStringHandler)val).AppendLiteral("[Skipped]: Could not find registered sync disk with preset name \"");
								((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(SyncDisk.GetSyncDiskNameFromPreset(disk.SyncDiskName));
								((BepInExLogInterpolatedStringHandler)val).AppendLiteral("\".");
							}
							log.LogInfo(val);
							continue;
						}
						if (!syncDisk.Effects.Any((Effect a) => a.Name.Equals(disk.Effect)))
						{
							ManualLogSource log2 = PluginController<Plugin, IPluginBindings>.Log;
							val = new BepInExInfoLogInterpolatedStringHandler(56, 2, ref flag);
							if (flag)
							{
								((BepInExLogInterpolatedStringHandler)val).AppendLiteral("[Skipped]: Could not find effect \"");
								((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(disk.Effect);
								((BepInExLogInterpolatedStringHandler)val).AppendLiteral("\" within sync disk \"");
								((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(SyncDisk.GetSyncDiskNameFromPreset(disk.SyncDiskName));
								((BepInExLogInterpolatedStringHandler)val).AppendLiteral("\".");
							}
							log2.LogInfo(val);
							continue;
						}
						Effect effect = syncDisk.Effects.First((Effect a) => a.Name.Equals(disk.Effect));
						int num = Array.IndexOf(syncDisk.Effects, effect);
						this.OnAfterSyncDiskInstalled?.Invoke(this, new SyncDiskArgs(syncDisk, effect));
						ManualLogSource log3 = PluginController<Plugin, IPluginBindings>.Log;
						val = new BepInExInfoLogInterpolatedStringHandler(58, 2, ref flag);
						if (flag)
						{
							((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Loaded savegame, raised install event for custom disk: ");
							((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(SyncDisk.GetSyncDiskNameFromPreset(disk.SyncDiskName));
							((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" | ");
							((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(effect.Name);
						}
						log3.LogInfo(val);
						if (disk.UpgradeOptions != null && syncDisk.UpgradeOptions.Length > num)
						{
							UpgradeOption upgradeOption = syncDisk.UpgradeOptions[num];
							foreach (string upgradeOption2 in disk.UpgradeOptions)
							{
								int? num2 = ((upgradeOption.Name1 != null && upgradeOption.Name1.Equals(upgradeOption2)) ? upgradeOption.Id1 : ((upgradeOption.Name2 != null && upgradeOption.Name2.Equals(upgradeOption2)) ? upgradeOption.Id2 : upgradeOption.Id3));
								if (!num2.HasValue)
								{
									ManualLogSource log4 = PluginController<Plugin, IPluginBindings>.Log;
									val = new BepInExInfoLogInterpolatedStringHandler(64, 2, ref flag);
									if (flag)
									{
										((BepInExLogInterpolatedStringHandler)val).AppendLiteral("[Skipped]: Could not find upgrade option \"");
										((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(upgradeOption2);
										((BepInExLogInterpolatedStringHandler)val).AppendLiteral("\" within sync disk \"");
										((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(SyncDisk.GetSyncDiskNameFromPreset(disk.SyncDiskName));
										((BepInExLogInterpolatedStringHandler)val).AppendLiteral("\".");
									}
									log4.LogInfo(val);
									continue;
								}
								this.OnAfterSyncDiskUpgraded?.Invoke(this, new SyncDiskArgs(syncDisk, effect, new SyncDiskArgs.Option(num2.Value, upgradeOption2)));
								ManualLogSource log5 = PluginController<Plugin, IPluginBindings>.Log;
								val = new BepInExInfoLogInterpolatedStringHandler(54, 3, ref flag);
								if (flag)
								{
									((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Loaded savegame, raised upgrade event for disk: ");
									((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(SyncDisk.GetSyncDiskNameFromPreset(disk.SyncDiskName));
									((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" | ");
									((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(effect.Name);
									((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" | ");
									((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(upgradeOption2);
								}
								log5.LogInfo(val);
							}
						}
						if (!InstalledSyncDisks.TryGetValue(disk.SyncDiskName, out var value))
						{
							InstalledSyncDisks.Add(disk.SyncDiskName, value = new List<InstalledSyncDiskData>());
						}
						value.Add(disk);
					}
					return;
				}
			}
			if (InstalledSyncDisks.Count == 0)
			{
				if (File.Exists(savestoreDirectoryPath))
				{
					File.Delete(savestoreDirectoryPath);
				}
				return;
			}
			string contents = JsonSerializer.Serialize(new SyncDiskJsonData
			{
				SyncDiskData = (from a in InstalledSyncDisks.Values.SelectMany((List<InstalledSyncDiskData> a) => a)
					orderby a.SyncDiskName
					select a).ToList()
			}, new JsonSerializerOptions
			{
				WriteIndented = false
			});
			File.WriteAllText(savestoreDirectoryPath, contents);
			ManualLogSource log6 = PluginController<Plugin, IPluginBindings>.Log;
			val = new BepInExInfoLogInterpolatedStringHandler(63, 0, ref flag);
			if (flag)
			{
				((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Saving game, writing custom sync disk data to common savestore.");
			}
			log6.LogInfo(val);
		}

		internal void RaiseSyncDiskEvent(SyncDiskEvent syncDiskEvent, bool after, Upgrades upgrade)
		{
			//IL_021a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0221: Expected O, but got Unknown
			//IL_03f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ff: Expected O, but got Unknown
			//IL_0289: Unknown result type (might be due to invalid IL or missing references)
			//IL_0290: Expected O, but got Unknown
			//IL_0480: Unknown result type (might be due to invalid IL or missing references)
			//IL_0487: Expected O, but got Unknown
			bool flag = default(bool);
			switch (syncDiskEvent)
			{
			case SyncDiskEvent.OnInstall:
			{
				SyncDiskArgs syncDiskArgs = new SyncDiskArgs(upgrade, setEffect: true, setUpgradeOption: false);
				if (after)
				{
					this.OnAfterSyncDiskInstalled?.Invoke(this, syncDiskArgs);
				}
				else
				{
					this.OnBeforeSyncDiskInstalled?.Invoke(this, syncDiskArgs);
				}
				if (after && ((Object)syncDiskArgs.SyncDisk.Preset).name.StartsWith($"{SyncDisk.UniqueDiskIdentifier}_") && syncDiskArgs.SyncDisk.ReRaiseEventsOnSaveLoad && syncDiskArgs.Effect.HasValue)
				{
					if (!InstalledSyncDisks.TryGetValue(((Object)syncDiskArgs.SyncDisk.Preset).name, out var value3))
					{
						value3 = new List<InstalledSyncDiskData>();
						InstalledSyncDisks.Add(((Object)syncDiskArgs.SyncDisk.Preset).name, value3);
					}
					value3.Add(new InstalledSyncDiskData(((Object)syncDiskArgs.SyncDisk.Preset).name, syncDiskArgs.Effect.Value.Name));
				}
				break;
			}
			case SyncDiskEvent.OnUninstall:
			{
				SyncDiskArgs uninstallArgs = new SyncDiskArgs(upgrade, setEffect: true, setUpgradeOption: false);
				if (after)
				{
					this.OnAfterSyncDiskUninstalled?.Invoke(this, uninstallArgs);
				}
				else
				{
					this.OnBeforeSyncDiskUninstalled?.Invoke(this, uninstallArgs);
				}
				if (!after || !uninstallArgs.Effect.HasValue || !((Object)uninstallArgs.SyncDisk.Preset).name.StartsWith($"{SyncDisk.UniqueDiskIdentifier}_") || !uninstallArgs.SyncDisk.ReRaiseEventsOnSaveLoad)
				{
					break;
				}
				if (!InstalledSyncDisks.TryGetValue(((Object)uninstallArgs.SyncDisk.Preset).name, out var value2))
				{
					ManualLogSource log3 = PluginController<Plugin, IPluginBindings>.Log;
					BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(54, 1, ref flag);
					if (flag)
					{
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Could not find uninstall data for custom sync disk \"");
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(SyncDisk.GetSyncDiskNameFromPreset(((Object)uninstallArgs.SyncDisk.Preset).name));
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral("\".");
					}
					log3.LogWarning(val);
					break;
				}
				InstalledSyncDiskData installedSyncDiskData2 = value2.FirstOrDefault((InstalledSyncDiskData a) => a.Effect.Equals(uninstallArgs.Effect.Value.Name));
				if (installedSyncDiskData2 == null)
				{
					ManualLogSource log4 = PluginController<Plugin, IPluginBindings>.Log;
					BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(61, 1, ref flag);
					if (flag)
					{
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Could not find uninstall effect data for custom sync disk \"");
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(SyncDisk.GetSyncDiskNameFromPreset(((Object)uninstallArgs.SyncDisk.Preset).name));
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral("\".");
					}
					log4.LogWarning(val);
				}
				else
				{
					value2.Remove(installedSyncDiskData2);
					if (value2.Count == 0)
					{
						InstalledSyncDisks.Remove(((Object)uninstallArgs.SyncDisk.Preset).name);
					}
				}
				break;
			}
			case SyncDiskEvent.OnUpgrade:
			{
				SyncDiskArgs upgradeArgs = new SyncDiskArgs(upgrade);
				if (after)
				{
					this.OnAfterSyncDiskUpgraded?.Invoke(this, upgradeArgs);
				}
				else
				{
					this.OnBeforeSyncDiskUpgraded?.Invoke(this, upgradeArgs);
				}
				if (!after || !upgradeArgs.Effect.HasValue || !((Object)upgradeArgs.SyncDisk.Preset).name.StartsWith($"{SyncDisk.UniqueDiskIdentifier}_") || !upgradeArgs.SyncDisk.ReRaiseEventsOnSaveLoad)
				{
					break;
				}
				if (!InstalledSyncDisks.TryGetValue(((Object)upgradeArgs.SyncDisk.Preset).name, out var value))
				{
					ManualLogSource log = PluginController<Plugin, IPluginBindings>.Log;
					BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(52, 1, ref flag);
					if (flag)
					{
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Could not find upgrade data for custom sync disk \"");
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(SyncDisk.GetSyncDiskNameFromPreset(((Object)upgradeArgs.SyncDisk.Preset).name));
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral("\".");
					}
					log.LogWarning(val);
					break;
				}
				InstalledSyncDiskData installedSyncDiskData = value.FirstOrDefault((InstalledSyncDiskData a) => a.Effect.Equals(upgradeArgs.Effect.Value.Name));
				if (!upgradeArgs.UpgradeOption.HasValue || installedSyncDiskData == null)
				{
					ManualLogSource log2 = PluginController<Plugin, IPluginBindings>.Log;
					BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(45, 2, ref flag);
					if (flag)
					{
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Could not find ");
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>((!upgradeArgs.UpgradeOption.HasValue) ? "upgrade option" : "effect");
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" data for custom sync disk \"");
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(SyncDisk.GetSyncDiskNameFromPreset(((Object)upgradeArgs.SyncDisk.Preset).name));
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral("\".");
					}
					log2.LogWarning(val);
				}
				else
				{
					installedSyncDiskData.UpgradeOptions.Add(upgradeArgs.UpgradeOption.Value.Name);
				}
				break;
			}
			default:
				throw new NotSupportedException($"Invalid event: {syncDiskEvent}");
			}
		}
	}
	public sealed class Time
	{
		public readonly struct TimeData : IEquatable<TimeData>, IComparable<TimeData>, IComparable
		{
			public int Year { get; }

			public int Month { get; }

			public int Day { get; }

			public int Hour { get; }

			public int Minute { get; }

			public WeekDay DayEnum => SessionData.Instance.WeekdayFromInt(Day - 1);

			public Month MonthEnum => SessionData.Instance.MonthFromInt(Month - 1);

			public TimeData(int year, int month, int day, int hour, int minute)
			{
				Year = year;
				Month = month;
				Day = day;
				Hour = hour;
				Minute = minute;
			}

			public string Serialize()
			{
				return $"{Year}|{Month}|{Day}|{Hour}|{Minute}";
			}

			public static TimeData Deserialize(string serializedString)
			{
				int[] array = serializedString.Split('|').Select(int.Parse).ToArray();
				if (array.Length != 5)
				{
					throw new Exception("Invalid timedata serialize string, use method .Serialize() on TimeData instance.");
				}
				return new TimeData(array[0], array[1], array[2], array[3], array[4]);
			}

			public override string ToString()
			{
				return ToString("MM/dd/yyyy HH:mm");
			}

			public string ToString(string format)
			{
				return format.Replace("dd", Day.ToString("00")).Replace("MM", Month.ToString("00")).Replace("yyyy", Year.ToString())
					.Replace("HH", Hour.ToString("00"))
					.Replace("mm", Minute.ToString("00"));
			}

			public bool Equals(TimeData other)
			{
				if (other.Year == Year && other.Month == Month && other.Day == Day && other.Hour == Hour)
				{
					return other.Minute == Minute;
				}
				return false;
			}

			public override int GetHashCode()
			{
				return HashCode.Combine(Year, Month, Day, Hour, Minute);
			}

			public override bool Equals(object obj)
			{
				if (obj is TimeData other)
				{
					return Equals(other);
				}
				return false;
			}

			public TimeData AddDays(int days)
			{
				return AddHours(days * 24);
			}

			public TimeData AddHours(int hours)
			{
				return AddMinutes(hours * 60);
			}

			public TimeData AddMinutes(int minutes)
			{
				DateTime dateTime = new DateTime(Year, (Month == 0) ? (Month + 1) : Month, (Day == 0) ? (Day + 1) : Day, Hour, Minute, 0);
				DateTime dateTime2 = dateTime.AddMinutes(minutes);
				return new TimeData(dateTime2.Year, (Month == 0) ? (dateTime2.Month - 1) : dateTime2.Month, (Day == 0) ? (dateTime2.Day - 1) : dateTime2.Day, dateTime2.Hour, dateTime2.Minute);
			}

			public int CompareTo(TimeData other)
			{
				int num = Year.CompareTo(other.Year);
				if (num != 0)
				{
					return num;
				}
				num = Month.CompareTo(other.Month);
				if (num != 0)
				{
					return num;
				}
				num = Day.CompareTo(other.Day);
				if (num != 0)
				{
					return num;
				}
				num = Hour.CompareTo(other.Hour);
				if (num != 0)
				{
					return num;
				}
				return Minute.CompareTo(other.Minute);
			}

			public int CompareTo(object obj)
			{
				if (obj == null)
				{
					return 1;
				}
				if (obj is TimeData other)
				{
					return CompareTo(other);
				}
				throw new ArgumentException("Object is not a TimeData");
			}

			public static bool operator ==(TimeData left, TimeData right)
			{
				return left.Equals(right);
			}

			public static bool operator !=(TimeData left, TimeData right)
			{
				return !(left == right);
			}

			public static bool operator <(TimeData t1, TimeData t2)
			{
				if (t1.Year < t2.Year)
				{
					return true;
				}
				if (t1.Year == t2.Year)
				{
					if (t1.Month < t2.Month)
					{
						return true;
					}
					if (t1.Month == t2.Month)
					{
						if (t1.Day < t2.Day)
						{
							return true;
						}
						if (t1.Day == t2.Day)
						{
							if (t1.Hour < t2.Hour)
							{
								return true;
							}
							if (t1.Hour == t2.Hour && t1.Minute < t2.Minute)
							{
								return true;
							}
						}
					}
				}
				return false;
			}

			public static bool operator >(TimeData t1, TimeData t2)
			{
				return t2 < t1;
			}

			public static bool operator <=(TimeData t1, TimeData t2)
			{
				if (!(t1 < t2))
				{
					return t1 == t2;
				}
				return true;
			}

			public static bool operator >=(TimeData t1, TimeData t2)
			{
				if (!(t1 > t2))
				{
					return t1 == t2;
				}
				return true;
			}

			public static TimeSpan operator -(TimeData left, TimeData right)
			{
				//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00be: Expected O, but got Unknown
				try
				{
					DateTime dateTime = new DateTime(left.Year, (left.Month == 0) ? (left.Month + 1) : left.Month, (left.Day == 0) ? (left.Day + 1) : left.Day, left.Hour, left.Minute, 0);
					DateTime dateTime2 = new DateTime(right.Year, (right.Month == 0) ? (right.Month + 1) : right.Month, (right.Day == 0) ? (right.Day + 1) : right.Day, right.Hour, right.Minute, 0);
					return dateTime - dateTime2;
				}
				catch (Exception)
				{
					ManualLogSource log = PluginController<Plugin, IPluginBindings>.Log;
					bool flag = default(bool);
					BepInExErrorLogInterpolatedStringHandler val = new BepInExErrorLogInterpolatedStringHandler(38, 2, ref flag);
					if (flag)
					{
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral("[Date information]: Left (");
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<TimeData>(left);
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral(") | Right (");
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<TimeData>(right);
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral(")");
					}
					log.LogError(val);
					throw;
				}
			}
		}

		private bool _initialized;

		private float? _currentGameTime;

		private TimeData? _currentTimeData;

		private TimeData? _currentDateData;

		public bool IsInitialized => _initialized;

		public bool IsGamePaused { get; internal set; }

		public TimeData CurrentDateTime
		{
			get
			{
				if (!IsInitialized)
				{
					throw new Exception("Time is not initialized at this state of the game, check for the property \"Lib.Time.IsInitialized\".");
				}
				if (!_currentGameTime.HasValue || !_currentGameTime.Value.Equals(SessionData.Instance.gameTime))
				{
					_currentGameTime = SessionData.Instance.gameTime;
					GetGameTimeInfo(out _currentTimeData, out _currentDateData);
				}
				return _currentTimeData.Value;
			}
		}

		public TimeData CurrentDate
		{
			get
			{
				if (!IsInitialized)
				{
					throw new Exception("Time is not initialized at this state of the game, check for the property \"Lib.Time.IsInitialized\".");
				}
				if (!_currentGameTime.HasValue || !_currentGameTime.Value.Equals(SessionData.Instance.gameTime))
				{
					_currentGameTime = SessionData.Instance.gameTime;
					GetGameTimeInfo(out _currentTimeData, out _currentDateData);
				}
				return _currentDateData.Value;
			}
		}

		public WeekDay CurrentDayEnum => SessionData.Instance.WeekdayFromInt(CurrentDateTime.Day);

		public Month CurrentMonthEnum => SessionData.Instance.MonthFromInt(CurrentDateTime.Month);

		public event EventHandler OnGamePaused;

		public event EventHandler OnGameResumed;

		public event EventHandler<TimeChangedArgs> OnMinuteChanged;

		public event EventHandler<TimeChangedArgs> OnHourChanged;

		public event EventHandler<TimeChangedArgs> OnDayChanged;

		public event EventHandler<TimeChangedArgs> OnMonthChanged;

		public event EventHandler<TimeChangedArgs> OnYearChanged;

		public event EventHandler<TimeChangedArgs> OnTimeInitialized;

		internal Time()
		{
		}

		public void ResumeGame()
		{
			SessionData.Instance.ResumeGame();
		}

		public void PauseGame(bool showPauseText = true, bool openDesktopMode = true, bool delayOverride = false)
		{
			SessionData.Instance.PauseGame(showPauseText, delayOverride, openDesktopMode);
		}

		private static void GetGameTimeInfo(out TimeData? dateTime, out TimeData? date)
		{
			float num = SessionData.Instance.gameTime;
			SessionData instance = SessionData.Instance;
			int num2 = 0;
			int num3 = GameplayControls.Instance.yearZeroLeapYearCycle;
			int num4 = GameplayControls.Instance.dayZero;
			int num5 = 0;
			int num6 = GameplayControls.Instance.publicYearZero + GameplayControls.Instance.startingYear;
			while (num >= 24f)
			{
				num -= 24f;
				num4++;
				num2++;
				if (num4 >= 7)
				{
					num4 -= 7;
				}
				int num7 = instance.daysInMonths[num5];
				if (num3 == 3 && num5 == 1)
				{
					num7++;
				}
				if (num2 < num7)
				{
					continue;
				}
				num2 -= num7;
				num5++;
				if (num5 >= 12)
				{
					num5 -= 12;
					num6++;
					for (num3++; num3 >= 4; num3 -= 4)
					{
					}
				}
			}
			float num8 = instance.FloatMinutes24H(num);
			int num9 = Mathf.FloorToInt(num8);
			int minute = Mathf.RoundToInt((num8 - (float)num9) * 100f);
			num5++;
			num4++;
			date = new TimeData(num6, num5, num4, 0, 0);
			dateTime = new TimeData(num6, num5, num4, num9, minute);
		}

		internal void OnTimeChanged(TimeData previous, TimeData current)
		{
			if (previous.Minute != current.Minute)
			{
				this.OnMinuteChanged?.Invoke(this, new TimeChangedArgs(previous, current));
			}
			if (previous.Hour != current.Hour)
			{
				this.OnHourChanged?.Invoke(this, new TimeChangedArgs(previous, current));
			}
			if (previous.Day != current.Day)
			{
				this.OnDayChanged?.Invoke(this, new TimeChangedArgs(previous, current));
			}
			if (previous.Month != current.Month)
			{
				this.OnMonthChanged?.Invoke(this, new TimeChangedArgs(previous, current));
			}
			if (previous.Year != current.Year)
			{
				this.OnYearChanged?.Invoke(this, new TimeChangedArgs(previous, current));
			}
		}

		internal void OnPauseModeChanged(bool paused)
		{
			if (paused)
			{
				this.OnGamePaused?.Invoke(this, EventArgs.Empty);
			}
			else
			{
				this.OnGameResumed?.Invoke(this, EventArgs.Empty);
			}
		}

		internal void InitializeTime(bool reset = false)
		{
			if (reset)
			{
				_initialized = false;
				_currentGameTime = null;
				_currentDateData = null;
				_currentTimeData = null;
			}
			else if (!_initialized)
			{
				_initialized = true;
				this.OnTimeInitialized?.Invoke(this, new TimeChangedArgs(CurrentDateTime, CurrentDateTime));
			}
		}
	}
	public sealed class TimeChangedArgs : EventArgs
	{
		public Time.TimeData Previous { get; }

		public Time.TimeData Current { get; }

		public bool IsMinuteChanged { get; }

		public bool IsHourChanged { get; }

		public bool IsDayChanged { get; }

		public bool IsMonthChanged { get; }

		public bool IsYearChanged { get; }

		internal TimeChangedArgs(Time.TimeData previous, Time.TimeData current)
		{
			Previous = previous;
			Current = current;
			IsMinuteChanged = previous.Minute != current.Minute;
			IsHourChanged = previous.Hour != current.Hour;
			IsDayChanged = previous.Day != current.Day;
			IsMonthChanged = previous.Month != current.Month;
			IsYearChanged = previous.Year != current.Year;
		}
	}
}
namespace SOD.Common.Helpers.SyncDiskObjects
{
	public sealed class SyncDisk
	{
		internal static Lazy<InteractablePreset> SyncDiskInteractablePreset = new Lazy<InteractablePreset>((Func<InteractablePreset>)delegate
		{
			InteractablePreset val = ((IEnumerable<InteractablePreset>)Resources.FindObjectsOfTypeAll<InteractablePreset>()).Where((InteractablePreset preset) => ((SoCustomComparison)preset).presetName == "SyncDisk").LastOrDefault();
			if (!((SoCustomComparison)(object)val == (SoCustomComparison)null))
			{
				return val;
			}
			throw new Exception("Could not find sync disk interactable, did something change in this game version?");
		});

		private SyncDisks.Effect? _sideEffect;

		internal string[] Icons;

		internal static int UniqueDiskIdentifier = "Venomaus.SOD.Common".GetFnvHashCode();

		public bool RegisteredInGame
		{
			get
			{
				if (Lib.SyncDisks.RegisteredSyncDisks.Contains(this))
				{
					return true;
				}
				if ((Object)(object)Toolbox.Instance == (Object)null)
				{
					return false;
				}
				if (Toolbox.Instance.allSyncDisks == null)
				{
					return false;
				}
				if ((SoCustomComparison)(object)Preset == (SoCustomComparison)null)
				{
					return false;
				}
				return Toolbox.Instance.allSyncDisks.Contains(Preset);
			}
		}

		public SyncDiskPreset Preset { get; private set; }

		internal string Hash { get; private set; }

		internal bool ReRaiseEventsOnSaveLoad { get; private set; }

		public string Name { get; private set; }

		public int Number => Preset.syncDiskNumber;

		public int Price => Preset.price;

		public bool EnableWorldSpawn { get; private set; } = true;


		public Rarity Rarity => Preset.rarity;

		public Manufacturer Manufacturer => Preset.manufacturer;

		public SyncDisks.Effect[] Effects => new SyncDisks.Effect[3]
		{
			new SyncDisks.Effect((int)Preset.mainEffect1, Preset.mainEffect1Name),
			new SyncDisks.Effect((int)Preset.mainEffect2, Preset.mainEffect2Name),
			new SyncDisks.Effect((int)Preset.mainEffect3, Preset.mainEffect3Name)
		}.Where((SyncDisks.Effect a) => a.Id != 0).ToArray();

		public SyncDisks.Effect? SideEffect
		{
			get
			{
				//IL_0013: Unknown result type (might be due to invalid IL or missing references)
				//IL_003b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0050: Expected I4, but got Unknown
				if (!_sideEffect.HasValue && (int)Preset.sideEffect != 0)
				{
					SyncDisks.Effect valueOrDefault = _sideEffect.GetValueOrDefault();
					if (!_sideEffect.HasValue)
					{
						valueOrDefault = new SyncDisks.Effect((int)Preset.sideEffect, Preset.sideEffectDescription);
						_sideEffect = valueOrDefault;
					}
				}
				return _sideEffect;
			}
		}

		public SyncDisks.UpgradeOption[] UpgradeOptions => new SyncDisks.UpgradeOption[3]
		{
			new SyncDisks.UpgradeOption(new SyncDiskBuilder.Options(Preset, 1)),
			new SyncDisks.UpgradeOption(new SyncDiskBuilder.Options(Preset, 2)),
			new SyncDisks.UpgradeOption(new SyncDiskBuilder.Options(Preset, 3))
		}.Where((SyncDisks.UpgradeOption a) => a.HasOptions).ToArray();

		internal HashSet<string> MenuPresetLocations { get; set; }

		private SyncDisk(bool createPresetInstance = true)
		{
			if (createPresetInstance)
			{
				Preset = ScriptableObject.CreateInstance<SyncDiskPreset>();
			}
		}

		public void Register()
		{
			if (!RegisteredInGame)
			{
				Lib.SyncDisks.RegisteredSyncDisks.Add(this);
			}
		}

		internal static string GetName(string name)
		{
			if (name == null)
			{
				return null;
			}
			if (name.StartsWith($"{UniqueDiskIdentifier}_"))
			{
				string[] array = name.Split('_');
				int length = (array[0] + "_" + array[1] + "_").Length;
				return name.Substring(length, name.Length - length);
			}
			return name;
		}

		internal static SyncDisk ConvertFrom(SyncDiskBuilder builder)
		{
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_0216: Unknown result type (might be due to invalid IL or missing references)
			//IL_0495: Unknown result type (might be due to invalid IL or missing references)
			//IL_0504: Unknown result type (might be due to invalid IL or missing references)
			//IL_0519: Expected I4, but got Unknown
			//IL_03ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0632: Unknown result type (might be due to invalid IL or missing references)
			//IL_06b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_072e: Unknown result type (might be due to invalid IL or missing references)
			SyncDisk syncDisk = new SyncDisk
			{
				Name = builder.Name,
				Hash = Lib.SaveGame.GetUniqueString(builder.PluginGuid + "_" + builder.Name),
				ReRaiseEventsOnSaveLoad = builder.ReRaiseEventsOnSaveLoad,
				EnableWorldSpawn = builder.EnableWorldSpawn
			};
			((Object)syncDisk.Preset).name = $"{UniqueDiskIdentifier}_{syncDisk.Hash}_{syncDisk.ReRaiseEventsOnSaveLoad}_{builder.Name}";
			((SoCustomComparison)syncDisk.Preset).presetName = ((Object)syncDisk.Preset).name;
			syncDisk.Preset.price = builder.Price;
			syncDisk.Preset.rarity = builder.Rarity;
			syncDisk.Preset.manufacturer = builder.Manufacturer;
			syncDisk.Preset.canBeSideJobReward = builder.CanBeSideJobReward;
			if (builder.OccupationPresets != null && builder.OccupationPresets.Length != 0)
			{
				syncDisk.Preset.occupation = new List<OccupationPreset>();
				((IEnumerable<OccupationPreset>)builder.OccupationPresets).ForEach((Action<OccupationPreset>)syncDisk.Preset.occupation.Add);
				syncDisk.Preset.occupationWeight = builder.OccupationWeight;
			}
			if (builder.Traits != null && builder.Traits.Length != 0)
			{
				syncDisk.Preset.traits = new List<TraitPick>();
				((IEnumerable<TraitPick>)builder.Traits).ForEach((Action<TraitPick>)syncDisk.Preset.traits.Add);
				syncDisk.Preset.traitWeight = builder.TraitWeight;
			}
			syncDisk.MenuPresetLocations = builder.MenuPresetLocations;
			syncDisk.Icons = new string[builder.Effects.Count];
			for (int i = 0; i < builder.Effects.Count; i++)
			{
				SyncDiskBuilder.Effect effect = builder.Effects[i];
				syncDisk.Icons[i] = effect.Icon;
				switch (i)
				{
				case 0:
					syncDisk.Preset.mainEffect1 = effect.EffectValue;
					syncDisk.Preset.mainEffect1Name = $"{UniqueDiskIdentifier}_{syncDisk.Hash}_{effect.Name}";
					syncDisk.Preset.mainEffect1Description = $"{UniqueDiskIdentifier}_{syncDisk.Hash}_{effect.Description}";
					break;
				case 1:
					syncDisk.Preset.mainEffect2 = effect.EffectValue;
					syncDisk.Preset.mainEffect2Name = $"{UniqueDiskIdentifier}_{syncDisk.Hash}_{effect.Name}";
					syncDisk.Preset.mainEffect2Description = $"{UniqueDiskIdentifier}_{syncDisk.Hash}_{effect.Description}";
					break;
				default:
					syncDisk.Preset.mainEffect3 = effect.EffectValue;
					syncDisk.Preset.mainEffect3Name = $"{UniqueDiskIdentifier}_{syncDisk.Hash}_{effect.Name}";
					syncDisk.Preset.mainEffect3Description = $"{UniqueDiskIdentifier}_{syncDisk.Hash}_{effect.Description}";
					break;
				}
			}
			if (builder.SideEffect != null)
			{
				syncDisk.Preset.sideEffect = builder.SideEffect.EffectValue;
				syncDisk.Preset.sideEffectDescription = $"{UniqueDiskIdentifier}_{syncDisk.Hash}_{builder.SideEffect.Description}";
				syncDisk._sideEffect = new SyncDisks.Effect((int)builder.SideEffect.EffectValue, syncDisk.Preset.sideEffectDescription);
			}
			for (int j = 0; j < builder.UpgradeOptions.Count; j++)
			{
				SyncDiskBuilder.Options options = builder.UpgradeOptions[j];
				List<string> val = (List<string>)(j switch
				{
					1 => syncDisk.Preset.option2UpgradeNameReferences, 
					0 => syncDisk.Preset.option1UpgradeNameReferences, 
					_ => syncDisk.Preset.option3UpgradeNameReferences, 
				});
				List<UpgradeEffect> val2 = (List<UpgradeEffect>)(j switch
				{
					1 => syncDisk.Preset.option2UpgradeEffects, 
					0 => syncDisk.Preset.option1UpgradeEffects, 
					_ => syncDisk.Preset.option3UpgradeEffects, 
				});
				List<float> val3 = (List<float>)(j switch
				{
					1 => syncDisk.Preset.option2UpgradeValues, 
					0 => syncDisk.Preset.option1UpgradeValues, 
					_ => syncDisk.Preset.option3UpgradeValues, 
				});
				if (!string.IsNullOrWhiteSpace(options.Option1))
				{
					val.Add($"{UniqueDiskIdentifier}_{syncDisk.Hash}_{options.Option1}");
					val2.Add(options.Option1Effect);
					val3.Add(0f);
				}
				if (!string.IsNullOrWhiteSpace(options.Option2))
				{
					val.Add($"{UniqueDiskIdentifier}_{syncDisk.Hash}_{options.Option2}");
					val2.Add(options.Option2Effect);
					val3.Add(0f);
				}
				if (!string.IsNullOrWhiteSpace(options.Option3))
				{
					val.Add($"{UniqueDiskIdentifier}_{syncDisk.Hash}_{options.Option3}");
					val2.Add(options.Option3Effect);
					val3.Add(0f);
				}
			}
			return syncDisk;
		}

		internal static SyncDisk ConvertFrom(SyncDiskPreset preset)
		{
			if (!((Object)preset).name.StartsWith($"{UniqueDiskIdentifier}_"))
			{
				return new SyncDisk(createPresetInstance: false)
				{
					Name = ((Object)preset).name,
					Preset = preset
				};
			}
			string[] array = ((Object)preset).name.Split('_');
			string text = array[1];
			bool flag = bool.Parse(array[2]);
			string obj = $"{array[0]}_{text}_{flag}_";
			string name = ((Object)preset).name;
			int length = obj.Length;
			string name2 = name.Substring(length, name.Length - length);
			return new SyncDisk(createPresetInstance: false)
			{
				Name = name2,
				Preset = preset,
				Hash = text,
				ReRaiseEventsOnSaveLoad = flag
			};
		}

		internal static string GetSyncDiskNameFromPreset(string presetName)
		{
			if (presetName == null || !presetName.StartsWith($"{UniqueDiskIdentifier}_"))
			{
				return presetName;
			}
			string[] array = presetName.Split('_');
			int length = $"{array[0]}_{array[1]}_{array[2]}_".Length;
			return presetName.Substring(length, presetName.Length - length);
		}
	}
	public sealed class SyncDiskArgs : EventArgs
	{
		public readonly struct Option
		{
			public readonly int Id;

			public readonly string Name;

			public Option(int id, string name)
			{
				Id = id;
				Name = name;
			}
		}

		public Upgrades SyncDiskChange { get; }

		public SyncDisk SyncDisk { get; }

		public int Number => SyncDisk.Number;

		public SyncDisks.Effect? Effect { get; }

		public Option? UpgradeOption { get; }

		internal SyncDiskArgs(SyncDisk syncDisk, SyncDisks.Effect effect, Option? option = null)
		{
			SyncDisk = syncDisk;
			Effect = effect;
			UpgradeOption = option;
		}

		internal SyncDiskArgs(Upgrades upgrades, bool setEffect = true, bool setUpgradeOption = true)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Expected I4, but got Unknown
			SyncDiskChange = upgrades;
			SyncDisk = SyncDisk.ConvertFrom(upgrades.preset);
			int num = (int)upgrades.state;
			if (setEffect)
			{
				if (num == 0)
				{
					Effect = null;
				}
				else
				{
					int num2 = num - 1;
					if (SyncDisk.Effects.Length > num2)
					{
						Effect = SyncDisk.Effects[num2];
					}
				}
			}
			if (!setUpgradeOption)
			{
				return;
			}
			int level = upgrades.level;
			if (level == 0 || num == 0)
			{
				UpgradeOption = null;
				return;
			}
			int num3 = num - 1;
			if (SyncDisk.UpgradeOptions.Length > num3)
			{
				SyncDisks.UpgradeOption upgradeOption = SyncDisk.UpgradeOptions[num3];
				if (level == 1 && upgradeOption.Id1.HasValue)
				{
					UpgradeOption = new Option(upgradeOption.Id1.Value, upgradeOption.Name1);
				}
				else if (level == 2 && upgradeOption.Id2.HasValue)
				{
					UpgradeOption = new Option(upgradeOption.Id2.Value, upgradeOption.Name2);
				}
				else if (level == 3 && upgradeOption.Id3.HasValue)
				{
					UpgradeOption = new Option(upgradeOption.Id3.Value, upgradeOption.Name3);
				}
			}
		}
	}
	public sealed class SyncDiskBuilder
	{
		internal class Effect
		{
			internal const string DefaultSprite = "IconDNA";

			public string Name { get; }

			public string Description { get; }

			public string Icon { get; }

			public Effect EffectValue { get; }

			internal Effect(int id, string name, string description, string icon)
			{
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				EffectValue = (Effect)id;
				Name = name;
				Description = description;
				Icon = ((!string.IsNullOrWhiteSpace(icon)) ? icon : "IconDNA");
			}
		}

		public struct Options
		{
			public readonly string Option1;

			public readonly string Option2;

			public readonly string Option3;

			internal UpgradeEffect Option1Effect;

			internal UpgradeEffect Option2Effect;

			internal UpgradeEffect Option3Effect;

			internal Options(SyncDiskPreset preset, int count)
			{
				//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_0081: 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_00a4: 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_00c7: Unknown result type (might be due to invalid IL or missing references)
				//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
				Option1 = null;
				Option2 = null;
				Option3 = null;
				Option1Effect = (UpgradeEffect)0;
				Option2Effect = (UpgradeEffect)0;
				Option3Effect = (UpgradeEffect)0;
				List<string> val = (List<string>)(count switch
				{
					2 => preset.option2UpgradeNameReferences, 
					1 => preset.option1UpgradeNameReferences, 
					_ => preset.option3UpgradeNameReferences, 
				});
				List<UpgradeEffect> val2 = (List<UpgradeEffect>)(count switch
				{
					2 => preset.option2UpgradeEffects, 
					1 => preset.option1UpgradeEffects, 
					_ => preset.option3UpgradeEffects, 
				});
				if (val.Count >= 1)
				{
					Option1 = val[0];
					Option1Effect = val2[0];
				}
				if (val.Count >= 2)
				{
					Option2 = val[1];
					Option2Effect = val2[1];
				}
				if (val.Count == 3)
				{
					Option3 = val[2];
					Option3Effect = val2[2];
				}
			}

			public Options(string option1)
			{
				//IL_0010: 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)
				Option2 = null;
				Option3 = null;
				Option1Effect = (UpgradeEffect)0;
				Option2Effect = (UpgradeEffect)0;
				Option3Effect = (UpgradeEffect)0;
				Option1 = option1;
			}

			public Options(string option1, string option2)
				: this(option1)
			{
				Option2 = option2;
			}

			public Options(string option1, string option2, string option3)
				: this(option1, option2)
			{
				Option3 = option3;
			}
		}

		public readonly struct OptionIds
		{
			public readonly int Option1Id;

			public readonly int Option2Id;

			public readonly int Option3Id;

			internal OptionIds(ref Options options)
			{
				//IL_0034: 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_007c: Unknown result type (might be due to invalid IL or missing references)
				Option1Id = 0;
				Option2Id = 0;
				Option3Id = 0;
				if (!string.IsNullOrWhiteSpace(options.Option1))
				{
					Option1Id = SyncDisks.GetNewSyncDiskOptionId();
					options.Option1Effect = (UpgradeEffect)Option1Id;
				}
				if (!string.IsNullOrWhiteSpace(options.Option2))
				{
					Option2Id = SyncDisks.GetNewSyncDiskOptionId();
					options.Option2Effect = (UpgradeEffect)Option2Id;
				}
				if (!string.IsNullOrWhiteSpace(options.Option3))
				{
					Option3Id = SyncDisks.GetNewSyncDiskOptionId();
					options.Option3Effect = (UpgradeEffect)Option3Id;
				}
			}
		}

		public enum SyncDiskSaleLocation
		{
			CigaretteMachine,
			AmericanDiner,
			SupermarketFridge,
			CoffeeMachine,
			BlackmarketSyncClinic,
			StreetVendorSnacks,
			ElGenMachine,
			PawnShop,
			KolaMachine,
			SupermarketMagazines,
			AmericanBar,
			SupermarketFruit,
			Chinese,
			Newsstand,
			Supermarket,
			Chemist,
			Hardware,
			SupermarketDrinksCooler,
			SupermarketShelf,
			PoliceAutomat,
			SupermarketFreezer,
			HomeCoffee,
			NewspaperBox,
			BlackmarketTrader,
			WeaponsDealer,
			SyncClinic,
			LoanShark
		}

		internal string Name { get; private set; }

		intern