using System;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("MapUnlocker")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.2.0.0")]
[assembly: AssemblyInformationalVersion("1.2.0+c4443989dc70c211efe912ba1ee9a0eb51d54bf2")]
[assembly: AssemblyProduct("MapUnlocker")]
[assembly: AssemblyTitle("MapUnlocker")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.2.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

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

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace MapUnlocker
{
	public class ConfigUI
	{
		private ManualLogSource Logger;

		private ResetManager resetManager;

		private MapUnlocker plugin;

		public ConfigEntry<bool>? debugMode;

		public ConfigEntry<bool>? resetDataAfterLeaving;

		public ConfigEntry<bool>? hasQuill;

		public ConfigEntry<bool>? unlockAllMapsAtStart;

		public ConfigEntry<bool>? unlockAllMaps;

		public ConfigEntry<bool>[]? mapConfigs;

		public ConfigEntry<bool>? unlockAllPinsAtStart;

		public ConfigEntry<bool>? unlockAllPins;

		public ConfigEntry<bool>[]? pinConfigs;

		public ConfigEntry<bool>? unlockAllMarkersAtStart;

		public ConfigEntry<bool>? unlockAllMarkers;

		public ConfigEntry<bool>[]? markerConfigs;

		private static bool allowChangeAllMaps = true;

		private static bool isChangingAllMaps = false;

		private static bool allowChangeAllPins = true;

		private static bool isChangingAllPins = false;

		private static bool allowChangeAllMarkers = true;

		private static bool isChangingAllMarkers = false;

		private ConfigFile Config => ((BaseUnityPlugin)plugin).Config;

		public ConfigUI(ManualLogSource logger, ResetManager resetManager, MapUnlocker plugin)
		{
			Logger = logger;
			this.resetManager = resetManager;
			this.plugin = plugin;
		}

		public void InitializeConfig()
		{
			debugMode = Config.Bind<bool>("Debug", "Debug mode", false, "Enables log messages for debugging purposes.");
			resetDataAfterLeaving = Config.Bind<bool>("General", "Reset Maps after leaving", false, "Resets all maps to original state after leaving.");
			hasQuill = Config.Bind<bool>("General", "Has Quill", false, "Enables the quill tool.");
			unlockAllMapsAtStart = Config.Bind<bool>("Maps", "Unlock All Maps At Start", false, "Unlock All Maps At the Start");
			mapConfigs = new ConfigEntry<bool>[29]
			{
				unlockAllMaps = Config.Bind<bool>("Maps", "Unlock All Maps Now", false, "Unlock All Maps"),
				Config.Bind<bool>("Maps", "Unlock the Map for Moss Grotto", false, "Unlock Moss Grotto"),
				Config.Bind<bool>("Maps", "Unlock the Map for Wilds", false, "Unlock Wilds"),
				Config.Bind<bool>("Maps", "Unlock the Map for Bone forest", false, "Unlock Bone forest"),
				Config.Bind<bool>("Maps", "Unlock the Map for Docks", false, "Unlock Docks"),
				Config.Bind<bool>("Maps", "Unlock the Map for Greymoor", false, "Unlock Greymoor"),
				Config.Bind<bool>("Maps", "Unlock the Map for Bellhart", false, "Unlock Bellhart"),
				Config.Bind<bool>("Maps", "Unlock the Map for Shellwood", false, "Unlock Shellwood"),
				Config.Bind<bool>("Maps", "Unlock the Map for Crawl", false, "Unlock Crawl"),
				Config.Bind<bool>("Maps", "Unlock the Map for Hunters Nest", false, "Unlock Hunters Nest"),
				Config.Bind<bool>("Maps", "Unlock the Map for Judge Steps", false, "Unlock Judge Steps"),
				Config.Bind<bool>("Maps", "Unlock the Map for Dustpens", false, "Unlock Dustpens"),
				Config.Bind<bool>("Maps", "Unlock the Map for Slab", false, "Unlock Slab"),
				Config.Bind<bool>("Maps", "Unlock the Map for Peak", false, "Unlock Peak"),
				Config.Bind<bool>("Maps", "Unlock the Map for Citadel Understore", false, "Unlock Citadel Understore"),
				Config.Bind<bool>("Maps", "Unlock the Map for Coral", false, "Unlock Coral"),
				Config.Bind<bool>("Maps", "Unlock the Map for Swamp", false, "Unlock Swamp"),
				Config.Bind<bool>("Maps", "Unlock the Map for Clover", false, "Unlock Clover"),
				Config.Bind<bool>("Maps", "Unlock the Map for Abyss", false, "Unlock Abyss"),
				Config.Bind<bool>("Maps", "Unlock the Map for Hang", false, "Unlock Hang"),
				Config.Bind<bool>("Maps", "Unlock the Map for SongGate", false, "Unlock SongGate"),
				Config.Bind<bool>("Maps", "Unlock the Map for Halls", false, "Unlock Halls"),
				Config.Bind<bool>("Maps", "Unlock the Map for Ward", false, "Unlock Ward"),
				Config.Bind<bool>("Maps", "Unlock the Map for Cog", false, "Unlock Cog"),
				Config.Bind<bool>("Maps", "Unlock the Map for Library", false, "Unlock Library"),
				Config.Bind<bool>("Maps", "Unlock the Map for Cradle", false, "Unlock Cradle"),
				Config.Bind<bool>("Maps", "Unlock the Map for Arborium", false, "Unlock Arborium"),
				Config.Bind<bool>("Maps", "Unlock the Map for Aqueduct", false, "Unlock Aqueduct"),
				Config.Bind<bool>("Maps", "Unlock the Map for Weavehome", false, "Unlock Weavehome")
			};
			unlockAllPinsAtStart = Config.Bind<bool>("Pins", "Unlock All Pins At Start", false, "Unlock All Pins At the Start");
			unlockAllPins = Config.Bind<bool>("Pins", "Unlock All Pins Now", false, "Unlock All Pins");
			pinConfigs = new ConfigEntry<bool>[12]
			{
				Config.Bind<bool>("Pins", "Unlock the Bench Pin", false, "Unlock Bench Pin"),
				Config.Bind<bool>("Pins", "Unlock the Cocoon Pin", false, "Unlock Cocoon Pin"),
				Config.Bind<bool>("Pins", "Unlock the Shop Pin forest", false, "Unlock Bone Shop Pin"),
				Config.Bind<bool>("Pins", "Unlock the Spa Pin", false, "Unlock Spa Pin"),
				Config.Bind<bool>("Pins", "Unlock the Stag Pin", false, "Unlock Stag Pin"),
				Config.Bind<bool>("Pins", "Unlock the Tube Pin", false, "Unlock Tube Pin"),
				Config.Bind<bool>("Pins", "Unlock the FleaMarrowlands Pin", false, "Unlock FleaMarrowlands Pin"),
				Config.Bind<bool>("Pins", "Unlock the FleaMidlands Pin", false, "Unlock FleaMidlands Pin"),
				Config.Bind<bool>("Pins", "Unlock the FleaBlastedlands Pin Nest", false, "Unlock Hunters FleaBlastedlands Pin"),
				Config.Bind<bool>("Pins", "Unlock the FleaCitadel Pin Steps", false, "Unlock Judge FleaCitadel Pin"),
				Config.Bind<bool>("Pins", "Unlock the FleaPeaklands Pin", false, "Unlock FleaPeaklands Pin"),
				Config.Bind<bool>("Pins", "Unlock the FleaMucklands Pin", false, "Unlock FleaMucklands Pin")
			};
			unlockAllMarkersAtStart = Config.Bind<bool>("Markers", "Unlock All Markers At Start", false, "Unlock All Markers At the Start");
			unlockAllMarkers = Config.Bind<bool>("Markers", "Unlock All Markers Now", false, "Unlock All Markers");
			markerConfigs = new ConfigEntry<bool>[5]
			{
				Config.Bind<bool>("Markers", "Unlock the hasMarker_a", false, "Unlock hasMarker_a"),
				Config.Bind<bool>("Markers", "Unlock the hasMarker_b", false, "Unlock hasMarker_b"),
				Config.Bind<bool>("Markers", "Unlock the hasMarker_c", false, "Unlock hasMarker_c"),
				Config.Bind<bool>("Markers", "Unlock the hasMarker_d", false, "Unlock hasMarker_d"),
				Config.Bind<bool>("Markers", "Unlock the hasMarker_e", false, "Unlock hasMarker_e")
			};
			Config.Save();
			resetDataAfterLeaving.SettingChanged += delegate
			{
				if (resetDataAfterLeaving.Value)
				{
					resetManager.StoreOriginalData();
				}
			};
			hasQuill.SettingChanged += delegate
			{
				plugin.changeQuillBool(hasQuill.Value);
			};
			unlockAllMaps.SettingChanged += delegate
			{
				OnConfigChangeAll(unlockAllMaps.Value, MapUnlocker.MAPS);
			};
			unlockAllPins.SettingChanged += delegate
			{
				OnConfigChangeAll(unlockAllPins.Value, MapUnlocker.PINS);
			};
			unlockAllMarkers.SettingChanged += delegate
			{
				OnConfigChangeAll(unlockAllMarkers.Value, MapUnlocker.MARKERS);
			};
			for (int i = 1; i < mapConfigs.Length; i++)
			{
				int currentMap = i;
				mapConfigs[currentMap].SettingChanged += delegate
				{
					OnConfigChange(MapUnlocker.playerDataFieldsBools[MapUnlocker.MAPS][currentMap], mapConfigs[currentMap].Value, ref allowChangeAllMaps, ref isChangingAllMaps, ref unlockAllMaps);
					if (!mapConfigs[currentMap].Value)
					{
						plugin.SetPlayerDataBool(MapUnlocker.playerDataFieldsBools[MapUnlocker.MAPS][MapUnlocker.ALL_FIELDS], value: false);
					}
				};
			}
			for (int j = 0; j < pinConfigs.Length; j++)
			{
				int currentPin = j;
				pinConfigs[currentPin].SettingChanged += delegate
				{
					OnConfigChange(MapUnlocker.playerDataFieldsBools[MapUnlocker.PINS][currentPin], pinConfigs[currentPin].Value, ref allowChangeAllPins, ref isChangingAllPins, ref unlockAllPins);
				};
			}
			for (int k = 0; k < markerConfigs.Length; k++)
			{
				int currentMarker = k;
				markerConfigs[currentMarker].SettingChanged += delegate
				{
					OnConfigChange(MapUnlocker.playerDataFieldsBools[MapUnlocker.MARKERS][currentMarker + 1], markerConfigs[currentMarker].Value, ref allowChangeAllMarkers, ref isChangingAllMarkers, ref unlockAllMarkers);
					bool? playerDataBoolValue = MapUnlocker.GetPlayerDataBoolValue(MapUnlocker.playerDataFieldsBools[MapUnlocker.MARKERS][0]);
					if (playerDataBoolValue.HasValue)
					{
						if (markerConfigs[currentMarker].Value && playerDataBoolValue == false)
						{
							plugin.SetPlayerDataBool(MapUnlocker.playerDataFieldsBools[MapUnlocker.MARKERS][0], value: true);
						}
					}
					else
					{
						Logger.LogError((object)"hasMarkerField is null!");
					}
				};
			}
			if (debugMode.Value)
			{
				Logger.LogInfo((object)$"Configuration initialized with {mapConfigs.Length} map configs");
			}
		}

		public void ChangeConfigData(ConfigEntry<bool>[] configBools, string[] dataFields)
		{
			if (PlayerData.instance != null)
			{
				for (int i = 0; i < dataFields.Length && i < configBools.Length; i++)
				{
					FieldInfo field = ((object)PlayerData.instance).GetType().GetField(dataFields[i], BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
					if (field != null && field.FieldType == typeof(bool))
					{
						bool value = (bool)field.GetValue(PlayerData.instance);
						configBools[i].Value = value;
						if (debugMode.Value)
						{
							Logger.LogInfo((object)$"{dataFields[i]}: {configBools[i].Value}");
						}
					}
				}
			}
			else if (debugMode.Value)
			{
				Logger.LogInfo((object)"(PlayerData.instance is null");
			}
		}

		public void ChangeConfigData(ConfigEntry<bool>[] configBools, FieldInfo[] dataFields)
		{
			if (PlayerData.instance != null)
			{
				for (int i = 0; i < dataFields.Length && i < configBools.Length; i++)
				{
					FieldInfo fieldInfo = dataFields[i];
					if (fieldInfo != null && fieldInfo.FieldType == typeof(bool))
					{
						bool value = (bool)fieldInfo.GetValue(PlayerData.instance);
						configBools[i].Value = value;
						if (debugMode.Value)
						{
							Logger.LogInfo((object)$"{dataFields[i]}: {configBools[i].Value}");
						}
					}
				}
			}
			else if (debugMode.Value)
			{
				Logger.LogInfo((object)"(PlayerData.instance is null");
			}
		}

		public void OnConfigChangeAll(bool value, int choice)
		{
			switch (choice)
			{
			default:
				OnConfigChangeAll(value, mapConfigs, ref allowChangeAllMaps, ref isChangingAllMaps);
				break;
			case 1:
				OnConfigChangeAll(value, pinConfigs, ref allowChangeAllPins, ref isChangingAllPins);
				break;
			case 2:
				OnConfigChangeAll(value, markerConfigs, ref allowChangeAllMarkers, ref isChangingAllMarkers);
				break;
			}
		}

		public void OnConfigChangeAll(bool value, ConfigEntry<bool>[] entries, ref bool allowChangeAll, ref bool isChangingAll)
		{
			if (debugMode.Value)
			{
				Logger.LogInfo((object)("allowChangeAll: " + allowChangeAll));
			}
			if (!allowChangeAll)
			{
				allowChangeAll = true;
				return;
			}
			if (PlayerData.instance != null)
			{
				isChangingAll = true;
				for (int i = 0; i < entries.Length; i++)
				{
					entries[i].Value = value;
				}
			}
			else if (debugMode.Value)
			{
				Logger.LogInfo((object)"PlayerData could not be found");
			}
			isChangingAll = false;
		}

		private void OnConfigChange(string fieldName, bool value, ref bool allowChangeAll, ref bool isChangingAll, ref ConfigEntry<bool> unlockAllConfig)
		{
			string text = (value ? "Unlocked" : "Locked");
			if (PlayerData.instance == null)
			{
				return;
			}
			if (plugin.SetPlayerDataBool(PlayerData.instance, fieldName, value))
			{
				if (!value)
				{
					if (debugMode.Value)
					{
						Logger.LogInfo((object)("before isChangingAll: " + isChangingAll));
					}
					if (!isChangingAll)
					{
						allowChangeAll = false;
					}
					if (debugMode.Value)
					{
						Logger.LogInfo((object)("after allowChangeAll: " + allowChangeAll));
					}
					unlockAllConfig.Value = value;
				}
			}
			else if (debugMode.Value)
			{
				Logger.LogInfo((object)(fieldName + " could not be " + text + "!"));
			}
		}

		private void OnConfigChange(FieldInfo fieldInfo, bool value, ref bool allowChangeAll, ref bool isChangingAll, ref ConfigEntry<bool> unlockAllConfig)
		{
			string text = (value ? "Unlocked" : "Locked");
			if (PlayerData.instance != null && fieldInfo != null)
			{
				if (!(fieldInfo.FieldType == typeof(bool)))
				{
					return;
				}
				if (plugin.SetPlayerDataBool(fieldInfo, value))
				{
					if (!value)
					{
						if (debugMode.Value)
						{
							Logger.LogInfo((object)("before isChangingAll: " + isChangingAll));
						}
						if (!isChangingAll)
						{
							allowChangeAll = false;
						}
						if (debugMode.Value)
						{
							Logger.LogInfo((object)("after allowChangeAll: " + allowChangeAll));
						}
						unlockAllConfig.Value = value;
					}
				}
				else if (debugMode.Value)
				{
					Logger.LogInfo((object)(fieldInfo.Name + " could not be " + text + "!"));
				}
			}
			else if (debugMode.Value)
			{
				Logger.LogInfo((object)"FieldInfo is null or PlayerData.instance is null");
			}
		}
	}
	[BepInPlugin("MapUnlocker", "MapUnlocker", "1.2.0")]
	public class MapUnlocker : BaseUnityPlugin
	{
		private Harmony harmony;

		public static readonly int ALL_FIELDS = 0;

		public static readonly int MAPS = 0;

		public static readonly int PINS = 1;

		public static readonly int MARKERS = 2;

		public ResetManager resetManager;

		public ConfigUI configUI;

		private OnStartManager onStartManager;

		public static readonly string[] mapFields = new string[29]
		{
			"mapAllRooms", "HasMossGrottoMap", "HasWildsMap", "HasBoneforestMap", "HasDocksMap", "HasGreymoorMap", "HasBellhartMap", "HasShellwoodMap", "HasCrawlMap", "HasHuntersNestMap",
			"HasJudgeStepsMap", "HasDustpensMap", "HasSlabMap", "HasPeakMap", "HasCitadelUnderstoreMap", "HasCoralMap", "HasSwampMap", "HasCloverMap", "HasAbyssMap", "HasHangMap",
			"HasSongGateMap", "HasHallsMap", "HasWardMap", "HasCogMap", "HasLibraryMap", "HasCradleMap", "HasArboriumMap", "HasAqueductMap", "HasWeavehomeMap"
		};

		public static readonly string[] pinFields = new string[12]
		{
			"hasPinBench", "hasPinCocoon", "hasPinShop", "hasPinSpa", "hasPinStag", "hasPinTube", "hasPinFleaMarrowlands", "hasPinFleaMidlands", "hasPinFleaBlastedlands", "hasPinFleaCitadel",
			"hasPinFleaPeaklands", "hasPinFleaMucklands"
		};

		public static readonly string[] markerFields = new string[6] { "hasMarker", "hasMarker_a", "hasMarker_b", "hasMarker_c", "hasMarker_d", "hasMarker_e" };

		public static readonly FieldInfo[][] playerDataFieldsBools = new FieldInfo[3][]
		{
			mapFields.Select((string fieldName) => typeof(PlayerData).GetField(fieldName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)).ToArray(),
			pinFields.Select((string fieldName) => typeof(PlayerData).GetField(fieldName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)).ToArray(),
			markerFields.Select((string fieldName) => typeof(PlayerData).GetField(fieldName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)).ToArray()
		};

		public ManualLogSource Logger => ((BaseUnityPlugin)this).Logger;

		public static MapUnlocker Instance { get; private set; } = null;


		private void Awake()
		{
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Expected O, but got Unknown
			Logger.LogInfo((object)"Plugin MapUnlocker has loaded!");
			Logger.LogInfo((object)"Plugin version: 1.2.0");
			Instance = this;
			resetManager = new ResetManager(Logger, this);
			configUI = new ConfigUI(Logger, resetManager, this);
			resetManager.SetConfigUI(configUI);
			configUI.InitializeConfig();
			harmony = new Harmony("MapUnlocker");
			harmony.PatchAll();
			Logger.LogInfo((object)"Harmony patches applied successfully!");
			onStartManager = new OnStartManager(Logger, this);
			Logger.LogInfo((object)"Map Unlocker mod initialization completed");
		}

		private void OnDestroy()
		{
			Harmony obj = harmony;
			if (obj != null)
			{
				obj.UnpatchSelf();
			}
		}

		public static bool GetPlayerDataBoolValue(int category, int index)
		{
			if (PlayerData.instance == null || category < 0 || category >= playerDataFieldsBools.Length || index < 0 || index >= playerDataFieldsBools[category].Length || playerDataFieldsBools[category][index] == null)
			{
				return false;
			}
			FieldInfo fieldInfo = playerDataFieldsBools[category][index];
			if (fieldInfo.FieldType == typeof(bool))
			{
				return (bool)fieldInfo.GetValue(PlayerData.instance);
			}
			return false;
		}

		public static bool? GetPlayerDataBoolValue(FieldInfo fieldInfo)
		{
			if (PlayerData.instance != null && fieldInfo != null && fieldInfo.FieldType == typeof(bool))
			{
				return (bool)fieldInfo.GetValue(PlayerData.instance);
			}
			return null;
		}

		public bool SetPlayerDataBool(object playerData, string fieldName, bool value)
		{
			try
			{
				FieldInfo field = playerData.GetType().GetField(fieldName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				if (field != null && field.FieldType == typeof(bool))
				{
					field.SetValue(playerData, value);
					Logger.LogInfo((object)$"{fieldName}: {value}");
					return true;
				}
				ConfigEntry<bool>? debugMode = configUI.debugMode;
				if (debugMode != null && debugMode.Value)
				{
					Logger.LogWarning((object)("Field " + fieldName + " not found or not boolean"));
				}
				return false;
			}
			catch (Exception ex)
			{
				ConfigEntry<bool>? debugMode2 = configUI.debugMode;
				if (debugMode2 != null && debugMode2.Value)
				{
					Logger.LogError((object)("Error setting " + fieldName + ": " + ex.Message));
				}
				return false;
			}
		}

		public bool SetPlayerDataBool(FieldInfo fieldInfo, bool value)
		{
			if (PlayerData.instance != null && fieldInfo != null)
			{
				if (fieldInfo.FieldType == typeof(bool))
				{
					fieldInfo.SetValue(PlayerData.instance, value);
					ConfigEntry<bool>? debugMode = configUI.debugMode;
					if (debugMode != null && debugMode.Value)
					{
						Logger.LogInfo((object)$"{fieldInfo.Name}: {value}");
					}
					return true;
				}
				ConfigEntry<bool>? debugMode2 = configUI.debugMode;
				if (debugMode2 != null && debugMode2.Value)
				{
					Logger.LogInfo((object)(fieldInfo.Name + " is not a boolean."));
				}
			}
			return false;
		}

		public void changeQuillBool(bool value)
		{
			string text = (configUI.hasQuill.Value ? "Enabled" : "Disabled");
			if (SetPlayerDataBool(PlayerData.instance, "hasQuill", configUI.hasQuill.Value))
			{
				Logger.LogInfo((object)(text + " Quill."));
			}
		}

		public void DebugArrayContents(string arrayName, bool[] array)
		{
			Logger.LogInfo((object)("=== " + arrayName + " Contents ==="));
			for (int i = 0; i < array.Length; i++)
			{
				Logger.LogInfo((object)$"{arrayName}[{i}] = {array[i]} ({mapFields[i]})");
			}
			Logger.LogInfo((object)("=== End " + arrayName + " ==="));
		}
	}
	public class OnStartManager
	{
		[HarmonyPatch]
		internal static class HeroController_Start_Patch
		{
			private static MethodBase TargetMethod()
			{
				Type type = AccessTools.TypeByName("HeroController");
				if (type == null)
				{
					throw new Exception("Could not find type HeroController");
				}
				return AccessTools.Method(type, "Start", (Type[])null, (Type[])null);
			}

			private static void Postfix(object __instance)
			{
				MapUnlocker instance = MapUnlocker.Instance;
				bool value = instance.configUI.debugMode.Value;
				if ((Object)(object)instance != (Object)null)
				{
					ConfigEntry<bool>? resetDataAfterLeaving = instance.configUI.resetDataAfterLeaving;
					if (resetDataAfterLeaving != null && resetDataAfterLeaving.Value)
					{
						instance.resetManager.StoreOriginalData();
						if (value)
						{
							instance.Logger.LogInfo((object)"Stored original map data from HeroController_Start");
						}
					}
					ConfigEntry<bool>? unlockAllMapsAtStart = instance.configUI.unlockAllMapsAtStart;
					if (unlockAllMapsAtStart != null && unlockAllMapsAtStart.Value)
					{
						instance.configUI.unlockAllMaps.Value = true;
						if (value)
						{
							instance.Logger.LogInfo((object)"UnlockAtStart unlockAllMaps finished.");
						}
					}
					else
					{
						instance.configUI.ChangeConfigData(instance.configUI.mapConfigs, MapUnlocker.playerDataFieldsBools[MapUnlocker.MAPS]);
						if (value)
						{
							instance.Logger.LogInfo((object)"Stored config data from HeroController_Start");
						}
					}
					ConfigEntry<bool>? unlockAllPinsAtStart = instance.configUI.unlockAllPinsAtStart;
					if (unlockAllPinsAtStart != null && unlockAllPinsAtStart.Value)
					{
						instance.configUI.unlockAllPins.Value = true;
						if (value)
						{
							instance.Logger.LogInfo((object)"UnlockAtStart unlockAllPins finished.");
						}
					}
					else
					{
						instance.configUI.ChangeConfigData(instance.configUI.pinConfigs, MapUnlocker.playerDataFieldsBools[MapUnlocker.PINS]);
						if (value)
						{
							instance.Logger.LogInfo((object)"Stored config data from HeroController_Start");
						}
					}
					ConfigEntry<bool>? unlockAllMarkersAtStart = instance.configUI.unlockAllMarkersAtStart;
					if (unlockAllMarkersAtStart != null && unlockAllMarkersAtStart.Value)
					{
						instance.configUI.unlockAllMarkers.Value = true;
						if (value)
						{
							instance.Logger.LogInfo((object)"UnlockAtStart unlockAllMarkers finished.");
						}
					}
					else
					{
						instance.configUI.ChangeConfigData(instance.configUI.markerConfigs, MapUnlocker.playerDataFieldsBools[MapUnlocker.MARKERS]);
						if (value)
						{
							instance.Logger.LogInfo((object)"Stored config data from HeroController_Start");
						}
					}
					ConfigEntry<bool>? hasQuill = instance.configUI.hasQuill;
					if (hasQuill != null && hasQuill.Value)
					{
						instance.changeQuillBool(value: true);
						if (value)
						{
							instance.Logger.LogInfo((object)"enabled quill from HeroController_Start");
						}
					}
					return;
				}
				throw new Exception("Could not find MapUnlocker mod.");
			}
		}

		private ManualLogSource Logger;

		private MapUnlocker plugin;

		public OnStartManager(ManualLogSource logger, MapUnlocker plugin)
		{
			Logger = logger;
			this.plugin = plugin;
		}
	}
	public class ResetManager
	{
		[HarmonyPatch]
		internal static class SaveGameData_Constructor_Patch
		{
			private static MethodBase TargetMethod()
			{
				Type type = AccessTools.TypeByName("SaveGameData");
				if (type != null)
				{
					return AccessTools.Constructor(type, new Type[2]
					{
						AccessTools.TypeByName("PlayerData"),
						AccessTools.TypeByName("SceneData")
					}, false);
				}
				return null;
			}

			private static void Prefix(PlayerData playerData, SceneData sceneData)
			{
				MapUnlocker instance = MapUnlocker.Instance;
				if (!((Object)(object)instance != (Object)null))
				{
					return;
				}
				ConfigEntry<bool>? resetDataAfterLeaving = instance.configUI.resetDataAfterLeaving;
				if (resetDataAfterLeaving != null && resetDataAfterLeaving.Value)
				{
					instance.resetManager.StoreBoolData(moddedMapData, MapUnlocker.playerDataFieldsBools[MapUnlocker.MAPS]);
					instance.resetManager.StoreBoolData(moddedPinData, MapUnlocker.playerDataFieldsBools[MapUnlocker.PINS]);
					instance.resetManager.StoreBoolData(moddedMarkerData, MapUnlocker.playerDataFieldsBools[MapUnlocker.MARKERS]);
					ConfigUI configUI = instance.configUI;
					if (configUI != null && configUI.debugMode.Value)
					{
						instance.DebugArrayContents("originalMapData", originalMapData);
					}
					ConfigUI configUI2 = instance.configUI;
					if (configUI2 != null && configUI2.debugMode.Value)
					{
						instance.DebugArrayContents("originalPinData", originalPinData);
					}
					ConfigUI configUI3 = instance.configUI;
					if (configUI3 != null && configUI3.debugMode.Value)
					{
						instance.DebugArrayContents("originalMarkerData", originalMarkerData);
					}
					instance.resetManager.OverwriteBoolData(originalMapData, MapUnlocker.playerDataFieldsBools[MapUnlocker.MAPS]);
					instance.resetManager.OverwriteBoolData(originalPinData, MapUnlocker.playerDataFieldsBools[MapUnlocker.PINS]);
					instance.resetManager.OverwriteBoolData(originalMarkerData, MapUnlocker.playerDataFieldsBools[MapUnlocker.MARKERS]);
					instance.Logger.LogInfo((object)"Restored original map states before SaveGameData constructor");
				}
			}

			private static void Postfix(PlayerData playerData, SceneData sceneData)
			{
				MapUnlocker mapUnlocker = Object.FindAnyObjectByType<MapUnlocker>();
				if ((Object)(object)mapUnlocker != (Object)null)
				{
					ConfigEntry<bool>? resetDataAfterLeaving = mapUnlocker.configUI.resetDataAfterLeaving;
					if (resetDataAfterLeaving != null && resetDataAfterLeaving.Value)
					{
						mapUnlocker.resetManager.OverwriteBoolData(moddedMapData, MapUnlocker.playerDataFieldsBools[MapUnlocker.MAPS]);
						mapUnlocker.resetManager.OverwriteBoolData(moddedPinData, MapUnlocker.playerDataFieldsBools[MapUnlocker.PINS]);
						mapUnlocker.resetManager.OverwriteBoolData(moddedMarkerData, MapUnlocker.playerDataFieldsBools[MapUnlocker.MARKERS]);
						mapUnlocker.Logger.LogInfo((object)"Re-applied mod states after SaveGameData constructor");
					}
				}
			}
		}

		private ManualLogSource Logger;

		private MapUnlocker plugin;

		private ConfigUI configUI;

		public static bool[] originalMapData = new bool[MapUnlocker.mapFields.Length];

		public static bool[] moddedMapData = new bool[MapUnlocker.mapFields.Length];

		public static bool[] originalPinData = new bool[MapUnlocker.pinFields.Length];

		public static bool[] moddedPinData = new bool[MapUnlocker.pinFields.Length];

		public static bool[] originalMarkerData = new bool[MapUnlocker.pinFields.Length];

		public static bool[] moddedMarkerData = new bool[MapUnlocker.pinFields.Length];

		public ResetManager(ManualLogSource logger, MapUnlocker plugin)
		{
			Logger = logger;
			this.plugin = plugin;
		}

		public void SetConfigUI(ConfigUI configUI)
		{
			this.configUI = configUI;
		}

		public void StoreBoolData(bool[] boolData, string[] playerDataFields)
		{
			if (PlayerData.instance != null && boolData != null)
			{
				for (int i = 0; i < playerDataFields.Length && i < boolData.Length; i++)
				{
					FieldInfo field = ((object)PlayerData.instance).GetType().GetField(playerDataFields[i], BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
					if (field != null && field.FieldType == typeof(bool))
					{
						bool flag = (bool)field.GetValue(PlayerData.instance);
						boolData[i] = flag;
						ConfigEntry<bool>? debugMode = configUI.debugMode;
						if (debugMode != null && debugMode.Value)
						{
							Logger.LogInfo((object)$"{playerDataFields[i]}: {boolData[i]}");
						}
					}
				}
				ConfigEntry<bool>? debugMode2 = configUI.debugMode;
				if (debugMode2 != null && debugMode2.Value)
				{
					Logger.LogInfo((object)"Stored original data");
					plugin.DebugArrayContents("originalBoolData", boolData);
				}
			}
			else
			{
				Logger.LogInfo((object)"(PlayerData.instance is null or configUI not initialized");
			}
		}

		public void StoreBoolData(bool[] boolData, FieldInfo[] playerDataFields)
		{
			if (PlayerData.instance != null && boolData != null)
			{
				for (int i = 0; i < playerDataFields.Length && i < boolData.Length; i++)
				{
					bool? playerDataBoolValue = MapUnlocker.GetPlayerDataBoolValue(playerDataFields[i]);
					if (playerDataBoolValue.HasValue)
					{
						boolData[i] = playerDataBoolValue.Value;
						ConfigEntry<bool>? debugMode = configUI.debugMode;
						if (debugMode != null && debugMode.Value)
						{
							Logger.LogInfo((object)$"{playerDataFields[i]}: {boolData[i]}");
						}
					}
					else
					{
						Logger.LogError((object)$"Could not get playerDataField value {i}!");
					}
				}
				ConfigEntry<bool>? debugMode2 = configUI.debugMode;
				if (debugMode2 != null && debugMode2.Value)
				{
					Logger.LogInfo((object)"Stored original data");
					plugin.DebugArrayContents("originalBoolData", boolData);
				}
			}
			else
			{
				Logger.LogInfo((object)"(PlayerData.instance is null or configUI not initialized");
			}
		}

		public void OverwriteBoolData(bool[] boolData, string[] playerDataFields)
		{
			if (PlayerData.instance == null || boolData == null || configUI == null)
			{
				return;
			}
			ConfigEntry<bool>? debugMode = configUI.debugMode;
			if (debugMode != null && debugMode.Value)
			{
				Logger.LogInfo((object)"OverwriteMapData Start --------------------------------");
			}
			for (int i = 0; i < playerDataFields.Length && i < boolData.Length; i++)
			{
				if (plugin.SetPlayerDataBool(PlayerData.instance, playerDataFields[i], boolData[i]))
				{
					ConfigEntry<bool>? debugMode2 = configUI.debugMode;
					if (debugMode2 != null && debugMode2.Value)
					{
						Logger.LogInfo((object)$"{playerDataFields[i]} -> {boolData[i]}!");
					}
				}
			}
			ConfigEntry<bool>? debugMode3 = configUI.debugMode;
			if (debugMode3 != null && debugMode3.Value)
			{
				Logger.LogInfo((object)"Restored pin states");
			}
		}

		public void OverwriteBoolData(bool[] boolData, FieldInfo[] playerDataFields)
		{
			if (PlayerData.instance == null || boolData == null || configUI == null)
			{
				return;
			}
			ConfigEntry<bool>? debugMode = configUI.debugMode;
			if (debugMode != null && debugMode.Value)
			{
				Logger.LogInfo((object)"OverwriteBoolData Start --------------------------------");
			}
			for (int i = 0; i < playerDataFields.Length && i < boolData.Length; i++)
			{
				if (plugin.SetPlayerDataBool(playerDataFields[i], boolData[i]))
				{
					ConfigEntry<bool>? debugMode2 = configUI.debugMode;
					if (debugMode2 != null && debugMode2.Value)
					{
						Logger.LogInfo((object)$"playerDataFields: {playerDataFields[i]} -> {boolData[i]}!");
					}
				}
			}
			ConfigEntry<bool>? debugMode3 = configUI.debugMode;
			if (debugMode3 != null && debugMode3.Value)
			{
				Logger.LogInfo((object)"Restored pin states");
			}
		}

		public void StoreOriginalData()
		{
			if (PlayerData.instance != null && configUI != null)
			{
				StoreBoolData(originalMapData, MapUnlocker.playerDataFieldsBools[MapUnlocker.MAPS]);
				StoreBoolData(originalPinData, MapUnlocker.playerDataFieldsBools[MapUnlocker.PINS]);
				StoreBoolData(originalMarkerData, MapUnlocker.playerDataFieldsBools[MapUnlocker.MARKERS]);
			}
			else
			{
				Logger.LogInfo((object)"(PlayerData.instance is null or configUI not initialized");
			}
		}
	}
	public static class PluginInfo
	{
		public const string PLUGIN_GUID = "MapUnlocker";

		public const string PLUGIN_NAME = "MapUnlocker";

		public const string PLUGIN_VERSION = "1.2.0";
	}
}