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 AlwaysMist.Behaviour;
using AlwaysMist.Datas;
using AlwaysMist.Extensions;
using AlwaysMist.Proxy;
using BepInEx;
using BepInEx.Configuration;
using BepInExUtils.Attributes;
using BepInExUtils.Extensions;
using BepInExUtils.Interfaces;
using BepInExUtils.Logging;
using BepInExUtils.Proxy;
using HarmonyLib;
using JetBrains.Annotations;
using Microsoft.CodeAnalysis;
using Newtonsoft.Json;
using TeamCherry.SharedUtils;
using UnityEngine;
using UnityEngine.SceneManagement;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: AssemblyCompany("AlwaysMist")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+d69756569b627b2d0e211a9ca559bf464726f86c")]
[assembly: AssemblyProduct("AlwaysMist")]
[assembly: AssemblyTitle("AlwaysMist")]
[assembly: AssemblyVersion("1.0.0.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.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 AlwaysMist
{
	[BepInUtils("io.github.ykysnk.AlwaysMist", "Always Mist", "0.1.29")]
	[BepInDependency("io.github.ykysnk.BepinExUtils", "1.0.0")]
	[BepInProcess("Hollow Knight Silksong.exe")]
	[ConfigBind<bool>("ResetMazeSaveData", "Options", false, "Always reset maze save data when enter even if you're not dead.")]
	[ConfigBind<bool>("RandomNeededCorrectDoors", "Options", false, "Random the correct doors are needed when enter every single time.")]
	[ConfigBind<int>("MaxRandomNeededCorrectDoors", "Options", 10, "The max value of random the correct doors needed.", 2, 100)]
	[ConfigBind<int>("MinRandomNeededCorrectDoors", "Options", 2, "The min value of random the correct doors needed.", 2, 100)]
	[ConfigBind<bool>("TrueAlwaysMist", "Options", false, "Always enter the mist maze first when entering any rooms or any doors.")]
	[ConfigBind<bool>("RestBenchInMist", "Options", false, "Turn on the rest bench in the mist maze.")]
	[BepInPlugin("io.github.ykysnk.AlwaysMist", "Always Mist", "0.1.29")]
	public class Main : BaseUnityPlugin, IBepInUtils
	{
		private const string SectionOptions = "Options";

		private const string Version = "0.1.29";

		private static Main? _instance;

		private readonly Harmony _harmony = new Harmony("io.github.ykysnk.AlwaysMist");

		private void Awake()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Expected O, but got Unknown
			GameObject val = new GameObject("AlwaysMistController");
			val.AddComponent<AlwaysMistController>();
			Object.DontDestroyOnLoad((Object)val);
		}

		public void Init()
		{
		}

		public Main()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Expected O, but got Unknown
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Expected O, but got Unknown
			//IL_0047: Expected O, but got Unknown
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Expected O, but got Unknown
			//IL_0077: Expected O, but got Unknown
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Expected O, but got Unknown
			//IL_00af: Expected O, but got Unknown
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Expected O, but got Unknown
			//IL_00e6: Expected O, but got Unknown
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Expected O, but got Unknown
			//IL_0116: Expected O, but got Unknown
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_013c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0146: Expected O, but got Unknown
			//IL_0146: Expected O, but got Unknown
			_instance = this;
			Configs._ResetMazeSaveData = ((BaseUnityPlugin)this).Config.Bind<bool>(new ConfigDefinition("Options", "ResetMazeSaveData"), false, new ConfigDescription("Always reset maze save data when enter even if you're not dead.", (AcceptableValueBase)null, Array.Empty<object>()));
			Configs._RandomNeededCorrectDoors = ((BaseUnityPlugin)this).Config.Bind<bool>(new ConfigDefinition("Options", "RandomNeededCorrectDoors"), false, new ConfigDescription("Random the correct doors are needed when enter every single time.", (AcceptableValueBase)null, Array.Empty<object>()));
			Configs._MaxRandomNeededCorrectDoors = ((BaseUnityPlugin)this).Config.Bind<int>(new ConfigDefinition("Options", "MaxRandomNeededCorrectDoors"), 10, new ConfigDescription("The max value of random the correct doors needed.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(2, 100), Array.Empty<object>()));
			Configs._MinRandomNeededCorrectDoors = ((BaseUnityPlugin)this).Config.Bind<int>(new ConfigDefinition("Options", "MinRandomNeededCorrectDoors"), 2, new ConfigDescription("The min value of random the correct doors needed.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(2, 100), Array.Empty<object>()));
			Configs._TrueAlwaysMist = ((BaseUnityPlugin)this).Config.Bind<bool>(new ConfigDefinition("Options", "TrueAlwaysMist"), false, new ConfigDescription("Always enter the mist maze first when entering any rooms or any doors.", (AcceptableValueBase)null, Array.Empty<object>()));
			Configs._RestBenchInMist = ((BaseUnityPlugin)this).Config.Bind<bool>(new ConfigDefinition("Options", "RestBenchInMist"), false, new ConfigDescription("Turn on the rest bench in the mist maze.", (AcceptableValueBase)null, Array.Empty<object>()));
			Configs.Init();
			Utils.Logger.Info((object)"Plugin Always Mist is loaded, version 0.1.29");
			_harmony.PatchAll(Assembly.GetExecutingAssembly());
			Init();
		}
	}
	public static class Utils
	{
		internal const string FolderName = "AlwaysMist";

		internal const string GameName = "Hollow Knight Silksong.exe";

		internal const string Guid = "io.github.ykysnk.AlwaysMist";

		internal const string Name = "Always Mist";

		internal const string Version = "0.1.29";

		private static Logger? _logger;

		public static Logger Logger
		{
			get
			{
				//IL_000e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0013: Unknown result type (might be due to invalid IL or missing references)
				//IL_0019: Expected O, but got Unknown
				object obj = _logger;
				if (obj == null)
				{
					Logger val = new Logger("Always Mist");
					_logger = val;
					obj = (object)val;
				}
				return (Logger)obj;
			}
		}

		public static string? GetDoorDir(string doorName)
		{
			if (doorName.StartsWith("left"))
			{
				return "left";
			}
			if (doorName.StartsWith("right"))
			{
				return "right";
			}
			if (doorName.StartsWith("top"))
			{
				return "top";
			}
			if (!doorName.StartsWith("bot"))
			{
				return null;
			}
			return "bot";
		}

		public static string? GetDoorDirMatch(string doorName)
		{
			string doorDir = GetDoorDir(doorName);
			if (doorDir == null)
			{
				return null;
			}
			return doorDir switch
			{
				"left" => "right", 
				"right" => "left", 
				"top" => "bot", 
				"bot" => "top", 
				_ => null, 
			};
		}

		public static string? GetEntryDoorDir(string doorName)
		{
			string doorDir = GetDoorDir(doorName);
			if (doorDir == null)
			{
				return null;
			}
			return doorDir switch
			{
				"left" => "left", 
				"right" => "right", 
				"top" => "left", 
				"bot" => "right", 
				_ => null, 
			};
		}
	}
	public static class Configs
	{
		public delegate void OnResetMazeSaveDataValueChangedEvent(bool oldValue, bool newValue);

		public delegate void OnRandomNeededCorrectDoorsValueChangedEvent(bool oldValue, bool newValue);

		public delegate void OnMaxRandomNeededCorrectDoorsValueChangedEvent(int oldValue, int newValue);

		public delegate void OnMinRandomNeededCorrectDoorsValueChangedEvent(int oldValue, int newValue);

		public delegate void OnTrueAlwaysMistValueChangedEvent(bool oldValue, bool newValue);

		public delegate void OnRestBenchInMistValueChangedEvent(bool oldValue, bool newValue);

		internal static ConfigEntry<bool>? _ResetMazeSaveData;

		internal static ConfigEntry<bool>? _RandomNeededCorrectDoors;

		internal static ConfigEntry<int>? _MaxRandomNeededCorrectDoors;

		internal static ConfigEntry<int>? _MinRandomNeededCorrectDoors;

		internal static ConfigEntry<bool>? _TrueAlwaysMist;

		internal static ConfigEntry<bool>? _RestBenchInMist;

		private static bool? _oldResetMazeSaveData;

		private static bool? _oldRandomNeededCorrectDoors;

		private static int? _oldMaxRandomNeededCorrectDoors;

		private static int? _oldMinRandomNeededCorrectDoors;

		private static bool? _oldTrueAlwaysMist;

		private static bool? _oldRestBenchInMist;

		public static bool ResetMazeSaveData
		{
			get
			{
				return _ResetMazeSaveData?.Value ?? false;
			}
			set
			{
				if (_ResetMazeSaveData != null)
				{
					_ResetMazeSaveData.Value = value;
				}
			}
		}

		public static bool RandomNeededCorrectDoors
		{
			get
			{
				return _RandomNeededCorrectDoors?.Value ?? false;
			}
			set
			{
				if (_RandomNeededCorrectDoors != null)
				{
					_RandomNeededCorrectDoors.Value = value;
				}
			}
		}

		public static int MaxRandomNeededCorrectDoors
		{
			get
			{
				return _MaxRandomNeededCorrectDoors?.Value ?? 0;
			}
			set
			{
				if (_MaxRandomNeededCorrectDoors != null)
				{
					_MaxRandomNeededCorrectDoors.Value = value;
				}
			}
		}

		public static int MinRandomNeededCorrectDoors
		{
			get
			{
				return _MinRandomNeededCorrectDoors?.Value ?? 0;
			}
			set
			{
				if (_MinRandomNeededCorrectDoors != null)
				{
					_MinRandomNeededCorrectDoors.Value = value;
				}
			}
		}

		public static bool TrueAlwaysMist
		{
			get
			{
				return _TrueAlwaysMist?.Value ?? false;
			}
			set
			{
				if (_TrueAlwaysMist != null)
				{
					_TrueAlwaysMist.Value = value;
				}
			}
		}

		public static bool RestBenchInMist
		{
			get
			{
				return _RestBenchInMist?.Value ?? false;
			}
			set
			{
				if (_RestBenchInMist != null)
				{
					_RestBenchInMist.Value = value;
				}
			}
		}

		public static event OnResetMazeSaveDataValueChangedEvent? OnResetMazeSaveDataValueChanged;

		public static event OnRandomNeededCorrectDoorsValueChangedEvent? OnRandomNeededCorrectDoorsValueChanged;

		public static event OnMaxRandomNeededCorrectDoorsValueChangedEvent? OnMaxRandomNeededCorrectDoorsValueChanged;

		public static event OnMinRandomNeededCorrectDoorsValueChangedEvent? OnMinRandomNeededCorrectDoorsValueChanged;

		public static event OnTrueAlwaysMistValueChangedEvent? OnTrueAlwaysMistValueChanged;

		public static event OnRestBenchInMistValueChangedEvent? OnRestBenchInMistValueChanged;

		internal static void Init()
		{
			_oldResetMazeSaveData = _ResetMazeSaveData?.Value;
			ConfigEntry<bool>? resetMazeSaveData = _ResetMazeSaveData;
			if (resetMazeSaveData != null)
			{
				resetMazeSaveData.SettingChanged += delegate
				{
					Configs.OnResetMazeSaveDataValueChanged?.Invoke(_oldResetMazeSaveData.GetValueOrDefault(), _ResetMazeSaveData.Value);
					_oldResetMazeSaveData = _ResetMazeSaveData.Value;
				};
			}
			_oldRandomNeededCorrectDoors = _RandomNeededCorrectDoors?.Value;
			ConfigEntry<bool>? randomNeededCorrectDoors = _RandomNeededCorrectDoors;
			if (randomNeededCorrectDoors != null)
			{
				randomNeededCorrectDoors.SettingChanged += delegate
				{
					Configs.OnRandomNeededCorrectDoorsValueChanged?.Invoke(_oldRandomNeededCorrectDoors.GetValueOrDefault(), _RandomNeededCorrectDoors.Value);
					_oldRandomNeededCorrectDoors = _RandomNeededCorrectDoors.Value;
				};
			}
			_oldMaxRandomNeededCorrectDoors = _MaxRandomNeededCorrectDoors?.Value;
			ConfigEntry<int>? maxRandomNeededCorrectDoors = _MaxRandomNeededCorrectDoors;
			if (maxRandomNeededCorrectDoors != null)
			{
				maxRandomNeededCorrectDoors.SettingChanged += delegate
				{
					Configs.OnMaxRandomNeededCorrectDoorsValueChanged?.Invoke(_oldMaxRandomNeededCorrectDoors.GetValueOrDefault(), _MaxRandomNeededCorrectDoors.Value);
					_oldMaxRandomNeededCorrectDoors = _MaxRandomNeededCorrectDoors.Value;
				};
			}
			_oldMinRandomNeededCorrectDoors = _MinRandomNeededCorrectDoors?.Value;
			ConfigEntry<int>? minRandomNeededCorrectDoors = _MinRandomNeededCorrectDoors;
			if (minRandomNeededCorrectDoors != null)
			{
				minRandomNeededCorrectDoors.SettingChanged += delegate
				{
					Configs.OnMinRandomNeededCorrectDoorsValueChanged?.Invoke(_oldMinRandomNeededCorrectDoors.GetValueOrDefault(), _MinRandomNeededCorrectDoors.Value);
					_oldMinRandomNeededCorrectDoors = _MinRandomNeededCorrectDoors.Value;
				};
			}
			_oldTrueAlwaysMist = _TrueAlwaysMist?.Value;
			ConfigEntry<bool>? trueAlwaysMist = _TrueAlwaysMist;
			if (trueAlwaysMist != null)
			{
				trueAlwaysMist.SettingChanged += delegate
				{
					Configs.OnTrueAlwaysMistValueChanged?.Invoke(_oldTrueAlwaysMist.GetValueOrDefault(), _TrueAlwaysMist.Value);
					_oldTrueAlwaysMist = _TrueAlwaysMist.Value;
				};
			}
			_oldRestBenchInMist = _RestBenchInMist?.Value;
			ConfigEntry<bool>? restBenchInMist = _RestBenchInMist;
			if (restBenchInMist != null)
			{
				restBenchInMist.SettingChanged += delegate
				{
					Configs.OnRestBenchInMistValueChanged?.Invoke(_oldRestBenchInMist.GetValueOrDefault(), _RestBenchInMist.Value);
					_oldRestBenchInMist = _RestBenchInMist.Value;
				};
			}
		}
	}
}
namespace AlwaysMist.Proxy
{
	[PublicAPI]
	public class MazeControllerEntryMatchProxy : ClassProxy
	{
		private const string ClassName = "MazeController+EntryMatch";

		public string EntryScene
		{
			get
			{
				return ObjectExtensions.GetFieldValue<string>(((ClassProxy)this).Native, "EntryScene");
			}
			set
			{
				ObjectExtensions.SetFieldValue<string>(((ClassProxy)this).Native, "EntryScene", value);
			}
		}

		public string EntryDoorDir
		{
			get
			{
				return ObjectExtensions.GetFieldValue<string>(((ClassProxy)this).Native, "EntryDoorDir");
			}
			set
			{
				ObjectExtensions.SetFieldValue<string>(((ClassProxy)this).Native, "EntryDoorDir", value);
			}
		}

		public string ExitDoorDir
		{
			get
			{
				return ObjectExtensions.GetFieldValue<string>(((ClassProxy)this).Native, "ExitDoorDir");
			}
			set
			{
				ObjectExtensions.SetFieldValue<string>(((ClassProxy)this).Native, "ExitDoorDir", value);
			}
		}

		public MinMaxFloat FogRotationRange
		{
			get
			{
				//IL_000b: Unknown result type (might be due to invalid IL or missing references)
				return ObjectExtensions.GetFieldValue<MinMaxFloat>(((ClassProxy)this).Native, "FogRotationRange");
			}
			set
			{
				//IL_000b: Unknown result type (might be due to invalid IL or missing references)
				ObjectExtensions.SetFieldValue<MinMaxFloat>(((ClassProxy)this).Native, "FogRotationRange", value);
			}
		}

		public MazeControllerEntryMatchProxy()
			: base("MazeController+EntryMatch")
		{
		}

		public MazeControllerEntryMatchProxy(object obj)
			: base(obj, "MazeController+EntryMatch")
		{
		}
	}
}
namespace AlwaysMist.Patches
{
	[HarmonyPatch(typeof(DesktopPlatform))]
	internal class DesktopPlatformPatches
	{
		private const string SaveFileName = "saveData{0}.json";

		private const string SaveFileBackupName = "saveData{0}.json.bak";

		private const string SaveFileNewName = "saveData{0}.json.new";

		[HarmonyPatch("WriteSaveSlot")]
		[HarmonyPostfix]
		private static void WriteSaveSlot(DesktopPlatform __instance, int slotIndex, byte[] bytes, Action<bool> callback)
		{
			Utils.Logger.Debug((object)$"DesktopPlatform.WriteSaveSlot: {slotIndex}");
			AlwaysMistController instance = AlwaysMistController.Instance;
			if (!Object.op_Implicit((Object)(object)instance) || !instance.SaveDatas.TryGetValue(slotIndex, out AlwaysMistData data))
			{
				return;
			}
			string savePath = __instance.GetSavePath();
			string filePath = Path.Combine(savePath, $"saveData{slotIndex}.json");
			string newFilePath = Path.Combine(savePath, $"saveData{slotIndex}.json.new");
			string backupFilePath = Path.Combine(savePath, $"saveData{slotIndex}.json.bak");
			CoreLoop.InvokeNext((Action)delegate
			{
				SaveDataUtility.SerializeToJsonAsync<AlwaysMistData>(data, (Action<bool, string>)delegate(bool success, string result)
				{
					if (!success)
					{
						return;
					}
					try
					{
						File.WriteAllText(newFilePath, result);
					}
					catch (Exception ex)
					{
						Utils.Logger.Error((object)ex);
					}
					try
					{
						if (File.Exists(filePath))
						{
							File.Replace(newFilePath, filePath, backupFilePath);
						}
						else
						{
							File.Move(newFilePath, filePath);
						}
					}
					catch (Exception ex2)
					{
						Utils.Logger.Error((object)ex2);
					}
				});
			});
		}

		[HarmonyPatch("ReadSaveSlot")]
		[HarmonyPostfix]
		private static void ReadSaveSlot(DesktopPlatform __instance, int slotIndex, Action<byte[]> callback)
		{
			Utils.Logger.Debug((object)$"DesktopPlatform.ReadSaveSlot: {slotIndex}");
			AlwaysMistController controller = AlwaysMistController.Instance;
			if (!Object.op_Implicit((Object)(object)controller))
			{
				return;
			}
			string path = Path.Combine(__instance.GetSavePath(), $"saveData{slotIndex}.json");
			string saveJson = "";
			try
			{
				if (File.Exists(path))
				{
					saveJson = File.ReadAllText(path);
				}
			}
			catch (Exception ex)
			{
				Utils.Logger.Error((object)ex);
			}
			if (!string.IsNullOrEmpty(saveJson))
			{
				CoreLoop.InvokeSafe((Action)delegate
				{
					controller.SaveDatas[slotIndex] = SaveDataUtility.DeserializeSaveData<AlwaysMistData>(saveJson);
				});
			}
		}
	}
	[HarmonyPatch(typeof(MazeController))]
	internal class MazeControllerPatches
	{
		[HarmonyPatch("Activate")]
		[HarmonyPrefix]
		private static void Activate(MazeController __instance)
		{
			MazeController __instance2 = __instance;
			if (MazeControllerExtensions.get_isActive(__instance2))
			{
				return;
			}
			AlwaysMistController instance = AlwaysMistController.Instance;
			if (!Object.op_Implicit((Object)(object)instance))
			{
				return;
			}
			if (Configs.RandomNeededCorrectDoors || Configs.TrueAlwaysMist)
			{
				if (instance.LastRandomValue < 0)
				{
					instance.LastRandomValue = Random.Range(Configs.MinRandomNeededCorrectDoors, Configs.MaxRandomNeededCorrectDoors);
				}
				MazeControllerExtensions.set_neededCorrectDoors(__instance2, instance.LastRandomValue);
				MazeControllerExtensions.set_restScenePoint(__instance2, (int)Math.Round((float)instance.LastRandomValue / 2f));
			}
			if (instance.CurrentSceneName == "Dust_Maze_Last_Hall" && !string.IsNullOrEmpty(instance.TargetSceneName))
			{
				MazeControllerExtensions.set_exitSceneName(__instance2, instance.TargetSceneName);
			}
			if (!(instance.CurrentSceneName != "Dust_Maze_09_entrance") && Configs.TrueAlwaysMist && !string.IsNullOrEmpty(instance.TargetEntryDoorDir) && !(instance.TargetEntryDoorDir == "left"))
			{
				TransitionPoint val = ((IEnumerable<TransitionPoint>)TransitionPoint.TransitionPoints).FirstOrDefault((Func<TransitionPoint, bool>)((TransitionPoint door) => ((Component)door).gameObject.scene == ((Component)__instance2).gameObject.scene && ((Object)((Component)door).gameObject).name == "right1"));
				if (Object.op_Implicit((Object)(object)val))
				{
					PlayerData instance2 = PlayerData.instance;
					Utils.Logger.Debug((object)("playerData.PreviousMazeTargetDoor: " + instance2.PreviousMazeTargetDoor));
					MazeControllerExtensions.get_entryDoors(__instance2).Clear();
					MazeControllerExtensions.get_entryDoors(__instance2).Add(val);
				}
			}
		}

		[HarmonyPatch("GetExitMatch")]
		[HarmonyPrefix]
		private static bool GetExitMatch(MazeController __instance, ref object __result)
		{
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			AlwaysMistController instance = AlwaysMistController.Instance;
			if (!Object.op_Implicit((Object)(object)instance))
			{
				return true;
			}
			if (!Configs.TrueAlwaysMist)
			{
				return true;
			}
			if (string.IsNullOrEmpty(instance.TargetSceneName))
			{
				return true;
			}
			if (!instance.IsEnteredMaze)
			{
				return true;
			}
			Utils.Logger.Debug((object)"Create Entry Match");
			MazeControllerEntryMatchProxy mazeControllerEntryMatchProxy = new MazeControllerEntryMatchProxy();
			mazeControllerEntryMatchProxy.EntryScene = instance.EnterSceneName;
			mazeControllerEntryMatchProxy.EntryDoorDir = instance.TargetEntryDoorDir;
			mazeControllerEntryMatchProxy.ExitDoorDir = ((instance.CurrentSceneName == "Dust_Maze_Last_Hall") ? instance.TargetExitDoorName : instance.TargetExitDoorDir);
			MazeControllerEntryMatchProxy mazeControllerEntryMatchProxy2 = mazeControllerEntryMatchProxy;
			string targetEntryDoorDir = instance.TargetEntryDoorDir;
			MinMaxFloat fogRotationRange = ((targetEntryDoorDir == "left") ? new MinMaxFloat(0f, 0f) : ((!(targetEntryDoorDir == "right")) ? new MinMaxFloat(0f, 0f) : new MinMaxFloat(0f, 3.1416f)));
			mazeControllerEntryMatchProxy2.FogRotationRange = fogRotationRange;
			object native = ((ClassProxy)mazeControllerEntryMatchProxy).Native;
			Utils.Logger.Debug((object)$"Create Entry Match is {native}");
			__result = native;
			return false;
		}

		[HarmonyPatch("SubscribeDoorEntered")]
		[HarmonyPrefix]
		private static bool SubscribeDoorEntered(MazeController __instance, TransitionPoint door)
		{
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Expected O, but got Unknown
			TransitionPoint door2 = door;
			MazeController __instance2 = __instance;
			AlwaysMistController controller = AlwaysMistController.Instance;
			if (!Object.op_Implicit((Object)(object)controller))
			{
				return true;
			}
			if (!Configs.TrueAlwaysMist)
			{
				return true;
			}
			door2.OnBeforeTransition += (BeforeTransitionEvent)delegate
			{
				//IL_016a: Unknown result type (might be due to invalid IL or missing references)
				//IL_016f: Unknown result type (might be due to invalid IL or missing references)
				PlayerData instance = PlayerData.instance;
				string name = ((Object)door2).name;
				if (!MazeControllerExtensions.get_isCapScene(__instance2))
				{
					if (door2.targetScene == MazeControllerExtensions.get_restSceneName(__instance2))
					{
						instance.EnteredMazeRestScene = true;
						instance.CorrectMazeDoorsEntered = MazeControllerExtensions.get_neededCorrectDoors(__instance2) - MazeControllerExtensions.get_restScenePoint(__instance2);
						instance.IncorrectMazeDoorsEntered = 0;
					}
					else if (instance.PreviousMazeTargetDoor != name)
					{
						if (MazeControllerExtensions.get_correctDoors(__instance2).Contains(door2))
						{
							instance.CorrectMazeDoorsEntered++;
							instance.IncorrectMazeDoorsEntered = 0;
						}
						else
						{
							instance.CorrectMazeDoorsEntered = 0;
							instance.IncorrectMazeDoorsEntered++;
							instance.EnteredMazeRestScene = false;
							bool flag = string.IsNullOrEmpty(controller.TargetEntryDoorDir) || controller.TargetEntryDoorDir == "left";
							if (instance.IncorrectMazeDoorsEntered >= MazeControllerExtensions.get_allowedIncorrectDoors(__instance2) && name.StartsWith(flag ? "right" : "left"))
							{
								door2.SetTargetScene("Dust_Maze_09_entrance");
								door2.entryPoint = (flag ? "left1" : "right1");
							}
						}
					}
				}
				instance.PreviousMazeTargetDoor = door2.entryPoint;
				Scene scene = ((Component)door2).gameObject.scene;
				instance.PreviousMazeScene = ((Scene)(ref scene)).name;
				instance.PreviousMazeDoor = name;
			};
			return false;
		}
	}
	[HarmonyPatch(typeof(TransitionPoint))]
	internal static class TransitionPointPatches
	{
		[HarmonyPatch("DoSceneTransition")]
		[HarmonyPrefix]
		private static void DoSceneTransition(TransitionPoint __instance, bool doFade)
		{
			if (Configs.TrueAlwaysMist)
			{
				AlwaysMistController instance = AlwaysMistController.Instance;
				if (Object.op_Implicit((Object)(object)instance) && instance.IsOutsideMaze && instance.ChangedTransitionPoint.TryGetValue(__instance, out string value))
				{
					instance.TargetSceneName = value;
					instance.TargetEntryDoorDir = Utils.GetEntryDoorDir(((Object)__instance).name) ?? Utils.GetDoorDirMatch(__instance.entryPoint) ?? "left";
					instance.TargetExitDoorDir = Utils.GetDoorDir(__instance.entryPoint) ?? "right";
					instance.TargetExitDoorName = __instance.entryPoint;
					instance.EnterDoorName = ((Object)__instance).name;
					Utils.Logger.Debug((object)("controller.TargetSceneName: " + instance.TargetSceneName));
					Utils.Logger.Debug((object)("controller.TargetEntryDoorDir: " + instance.TargetEntryDoorDir));
					Utils.Logger.Debug((object)("controller.TargetExitDoorDir: " + instance.TargetExitDoorDir));
					Utils.Logger.Debug((object)("controller.TargetExitDoorName: " + instance.TargetExitDoorName));
					Utils.Logger.Debug((object)("controller.EnterDoorName: " + instance.EnterDoorName));
					string targetEntryDoorDir = instance.TargetEntryDoorDir;
					string targetDoor = ((targetEntryDoorDir == "left") ? "right1" : ((!(targetEntryDoorDir == "right")) ? "right1" : "left1"));
					__instance.SetTargetDoor(targetDoor);
				}
			}
		}
	}
}
namespace AlwaysMist.Extensions
{
	[AccessExtensions]
	[AccessInstance<DesktopPlatform>]
	[AccessField<string>("saveDirPath")]
	public static class DesktopPlatformExtensions
	{
		public sealed class <>E__0
		{
			public string GetSavePath()
			{
				throw null;
			}
		}

		public sealed class <>E__1
		{
			public string saveDirPath
			{
				get
				{
					throw null;
				}
				set
				{
					throw null;
				}
			}
		}

		[SpecialName]
		public static string GetSavePath(this DesktopPlatform instance)
		{
			string text = Path.Combine(get_saveDirPath(instance), "AlwaysMist");
			if (!Directory.Exists(text))
			{
				Directory.CreateDirectory(text);
			}
			return text;
		}

		[SpecialName]
		public static string get_saveDirPath(DesktopPlatform instance)
		{
			return ObjectExtensions.GetFieldValue<string>((object)instance, "saveDirPath");
		}

		[SpecialName]
		public static void set_saveDirPath(DesktopPlatform instance, string value)
		{
			ObjectExtensions.SetFieldValue<string>((object)instance, "saveDirPath", value);
		}
	}
	[AccessExtensions]
	[AccessInstance<MazeController>]
	[AccessField<bool>("isCapScene")]
	[AccessField<List<TransitionPoint>>("entryDoors")]
	[AccessField<string[]>("sceneNames")]
	[AccessField<int>("neededCorrectDoors")]
	[AccessField<int>("allowedIncorrectDoors")]
	[AccessField<int>("restScenePoint")]
	[AccessField<string>("restSceneName")]
	[AccessField<string>("exitSceneName")]
	[AccessField<object[]>("entryMatchExit")]
	[AccessField<bool>("isActive")]
	[AccessField<List<TransitionPoint>>("correctDoors")]
	[PublicAPI]
	public static class MazeControllerExtensions
	{
		public sealed class <>E__0
		{
			public bool isCapScene
			{
				get
				{
					throw null;
				}
				set
				{
					throw null;
				}
			}

			public List<TransitionPoint> entryDoors
			{
				get
				{
					throw null;
				}
				set
				{
					throw null;
				}
			}

			public string[] sceneNames
			{
				get
				{
					throw null;
				}
				set
				{
					throw null;
				}
			}

			public int neededCorrectDoors
			{
				get
				{
					throw null;
				}
				set
				{
					throw null;
				}
			}

			public int allowedIncorrectDoors
			{
				get
				{
					throw null;
				}
				set
				{
					throw null;
				}
			}

			public int restScenePoint
			{
				get
				{
					throw null;
				}
				set
				{
					throw null;
				}
			}

			public string restSceneName
			{
				get
				{
					throw null;
				}
				set
				{
					throw null;
				}
			}

			public string exitSceneName
			{
				get
				{
					throw null;
				}
				set
				{
					throw null;
				}
			}

			public object[] entryMatchExit
			{
				get
				{
					throw null;
				}
				set
				{
					throw null;
				}
			}

			public bool isActive
			{
				get
				{
					throw null;
				}
				set
				{
					throw null;
				}
			}

			public List<TransitionPoint> correctDoors
			{
				get
				{
					throw null;
				}
				set
				{
					throw null;
				}
			}
		}

		[SpecialName]
		public static bool get_isCapScene(MazeController instance)
		{
			return ObjectExtensions.GetFieldValue<bool>((object)instance, "isCapScene");
		}

		[SpecialName]
		public static void set_isCapScene(MazeController instance, bool value)
		{
			ObjectExtensions.SetFieldValue<bool>((object)instance, "isCapScene", value);
		}

		[SpecialName]
		public static List<TransitionPoint> get_entryDoors(MazeController instance)
		{
			return ObjectExtensions.GetFieldValue<List<TransitionPoint>>((object)instance, "entryDoors");
		}

		[SpecialName]
		public static void set_entryDoors(MazeController instance, List<TransitionPoint> value)
		{
			ObjectExtensions.SetFieldValue<List<TransitionPoint>>((object)instance, "entryDoors", value);
		}

		[SpecialName]
		public static string[] get_sceneNames(MazeController instance)
		{
			return ObjectExtensions.GetFieldValue<string[]>((object)instance, "sceneNames");
		}

		[SpecialName]
		public static void set_sceneNames(MazeController instance, string[] value)
		{
			ObjectExtensions.SetFieldValue<string[]>((object)instance, "sceneNames", value);
		}

		[SpecialName]
		public static int get_neededCorrectDoors(MazeController instance)
		{
			return ObjectExtensions.GetFieldValue<int>((object)instance, "neededCorrectDoors");
		}

		[SpecialName]
		public static void set_neededCorrectDoors(MazeController instance, int value)
		{
			ObjectExtensions.SetFieldValue<int>((object)instance, "neededCorrectDoors", value);
		}

		[SpecialName]
		public static int get_allowedIncorrectDoors(MazeController instance)
		{
			return ObjectExtensions.GetFieldValue<int>((object)instance, "allowedIncorrectDoors");
		}

		[SpecialName]
		public static void set_allowedIncorrectDoors(MazeController instance, int value)
		{
			ObjectExtensions.SetFieldValue<int>((object)instance, "allowedIncorrectDoors", value);
		}

		[SpecialName]
		public static int get_restScenePoint(MazeController instance)
		{
			return ObjectExtensions.GetFieldValue<int>((object)instance, "restScenePoint");
		}

		[SpecialName]
		public static void set_restScenePoint(MazeController instance, int value)
		{
			ObjectExtensions.SetFieldValue<int>((object)instance, "restScenePoint", value);
		}

		[SpecialName]
		public static string get_restSceneName(MazeController instance)
		{
			return ObjectExtensions.GetFieldValue<string>((object)instance, "restSceneName");
		}

		[SpecialName]
		public static void set_restSceneName(MazeController instance, string value)
		{
			ObjectExtensions.SetFieldValue<string>((object)instance, "restSceneName", value);
		}

		[SpecialName]
		public static string get_exitSceneName(MazeController instance)
		{
			return ObjectExtensions.GetFieldValue<string>((object)instance, "exitSceneName");
		}

		[SpecialName]
		public static void set_exitSceneName(MazeController instance, string value)
		{
			ObjectExtensions.SetFieldValue<string>((object)instance, "exitSceneName", value);
		}

		[SpecialName]
		public static object[] get_entryMatchExit(MazeController instance)
		{
			return ObjectExtensions.GetFieldValue<object[]>((object)instance, "entryMatchExit");
		}

		[SpecialName]
		public static void set_entryMatchExit(MazeController instance, object[] value)
		{
			ObjectExtensions.SetFieldValue<object[]>((object)instance, "entryMatchExit", value);
		}

		[SpecialName]
		public static bool get_isActive(MazeController instance)
		{
			return ObjectExtensions.GetFieldValue<bool>((object)instance, "isActive");
		}

		[SpecialName]
		public static void set_isActive(MazeController instance, bool value)
		{
			ObjectExtensions.SetFieldValue<bool>((object)instance, "isActive", value);
		}

		[SpecialName]
		public static List<TransitionPoint> get_correctDoors(MazeController instance)
		{
			return ObjectExtensions.GetFieldValue<List<TransitionPoint>>((object)instance, "correctDoors");
		}

		[SpecialName]
		public static void set_correctDoors(MazeController instance, List<TransitionPoint> value)
		{
			ObjectExtensions.SetFieldValue<List<TransitionPoint>>((object)instance, "correctDoors", value);
		}
	}
}
namespace AlwaysMist.Datas
{
	[Serializable]
	[JsonObject]
	public class AlwaysMistData
	{
		public string TargetSceneName = "";

		public string TargetEntryDoorDir = "";

		public string TargetExitDoorDir = "";

		public string TargetExitDoorName = "";

		public string EnterSceneName = "";

		public string EnterDoorName = "";

		public bool IsEnteredMaze;

		public int LastRandomValue = -1;
	}
}
namespace AlwaysMist.Behaviour
{
	public class AlwaysMistController : MonoBehaviour
	{
		[CompilerGenerated]
		private sealed class <OnSceneLoadedDelay>d__49 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public AlwaysMistController <>4__this;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <OnSceneLoadedDelay>d__49(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0024: Unknown result type (might be due to invalid IL or missing references)
				//IL_002e: Expected O, but got Unknown
				int num = <>1__state;
				AlwaysMistController alwaysMistController = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForSeconds(0.1f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					alwaysMistController.EnterMazeHandle();
					if (Configs.TrueAlwaysMist)
					{
						if (alwaysMistController.IsOutsideMaze)
						{
							alwaysMistController.EnterSceneName = alwaysMistController.CurrentSceneName;
							alwaysMistController.ChangeAllTransitionScene();
						}
						else
						{
							string currentSceneName = alwaysMistController.CurrentSceneName;
							if (!(currentSceneName == "Dust_Maze_09_entrance"))
							{
								if (currentSceneName == "Dust_Maze_Last_Hall")
								{
									Utils.Logger.Debug((object)("TargetSceneName: " + alwaysMistController.TargetSceneName));
									Utils.Logger.Debug((object)("TargetExitDoorDir: " + alwaysMistController.TargetExitDoorDir));
									if (!string.IsNullOrEmpty(alwaysMistController.TargetSceneName))
									{
										alwaysMistController.FixExitTransition();
									}
								}
							}
							else
							{
								Utils.Logger.Debug((object)("EnterSceneName: " + alwaysMistController.EnterSceneName));
								Utils.Logger.Debug((object)("EnterDoorName: " + alwaysMistController.EnterDoorName));
								string targetEntryDoorDir = alwaysMistController.TargetEntryDoorDir;
								if (!(targetEntryDoorDir == "left"))
								{
									if (targetEntryDoorDir == "right")
									{
										alwaysMistController.ChangeTransitionScene("left1", alwaysMistController.EnterSceneName, alwaysMistController.EnterDoorName);
									}
								}
								else
								{
									alwaysMistController.ChangeTransitionScene("right1", alwaysMistController.EnterSceneName, alwaysMistController.EnterDoorName);
								}
							}
						}
					}
					else
					{
						string currentSceneName = alwaysMistController.CurrentSceneName;
						if ((currentSceneName == "Shadow_04" || currentSceneName == "Dust_05") ? true : false)
						{
							alwaysMistController.EnterSceneName = alwaysMistController.CurrentSceneName;
							alwaysMistController.ChangeTransitionScene("left1");
						}
					}
					return false;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		private const string ChangeScene = "Shadow_04";

		private const string ChangeScene2 = "Dust_05";

		public const string LeftTransitionPoint = "left1";

		public const string RightTransitionPoint = "right1";

		internal const string MazeEntranceSceneName = "Dust_Maze_09_entrance";

		internal const string MazeExitSceneName = "Dust_Maze_Last_Hall";

		private const string MazeRestSceneName = "Dust_Maze_crossing";

		private static readonly string[] SceneNames = new string[8] { "Dust_Maze_01", "Dust_Maze_02", "Dust_Maze_03", "Dust_Maze_04", "Dust_Maze_05", "Dust_Maze_06", "Dust_Maze_07", "Dust_Maze_08" };

		public readonly Dictionary<TransitionPoint, string> ChangedTransitionPoint = new Dictionary<TransitionPoint, string>();

		public readonly Dictionary<int, AlwaysMistData> SaveDatas = new Dictionary<int, AlwaysMistData>();

		private Scene _currentScene;

		public static AlwaysMistController? Instance { get; private set; }

		public string CurrentSceneName { get; private set; } = "";


		public string TargetSceneName
		{
			get
			{
				GetSaveData(out AlwaysMistData data);
				return data.TargetSceneName;
			}
			set
			{
				GetSaveData(out AlwaysMistData data);
				data.TargetSceneName = value;
			}
		}

		public string TargetEntryDoorDir
		{
			get
			{
				GetSaveData(out AlwaysMistData data);
				return data.TargetEntryDoorDir;
			}
			set
			{
				GetSaveData(out AlwaysMistData data);
				data.TargetEntryDoorDir = value;
			}
		}

		public string TargetExitDoorDir
		{
			get
			{
				GetSaveData(out AlwaysMistData data);
				return data.TargetExitDoorDir;
			}
			set
			{
				GetSaveData(out AlwaysMistData data);
				data.TargetExitDoorDir = value;
			}
		}

		public string TargetExitDoorName
		{
			get
			{
				GetSaveData(out AlwaysMistData data);
				return data.TargetExitDoorName;
			}
			set
			{
				GetSaveData(out AlwaysMistData data);
				data.TargetExitDoorName = value;
			}
		}

		public string EnterSceneName
		{
			get
			{
				GetSaveData(out AlwaysMistData data);
				return data.EnterSceneName;
			}
			set
			{
				GetSaveData(out AlwaysMistData data);
				data.EnterSceneName = value;
			}
		}

		public string EnterDoorName
		{
			get
			{
				GetSaveData(out AlwaysMistData data);
				return data.EnterDoorName;
			}
			set
			{
				GetSaveData(out AlwaysMistData data);
				data.EnterDoorName = value;
			}
		}

		public bool IsEnteredMaze
		{
			get
			{
				GetSaveData(out AlwaysMistData data);
				return data.IsEnteredMaze;
			}
			set
			{
				GetSaveData(out AlwaysMistData data);
				data.IsEnteredMaze = value;
			}
		}

		public bool IsOutsideMaze
		{
			get
			{
				if (!IsEnteredMaze && CurrentSceneName != "Dust_Maze_Last_Hall" && CurrentSceneName != "Dust_Maze_crossing")
				{
					return !SceneNames.Contains(CurrentSceneName);
				}
				return false;
			}
		}

		public int LastRandomValue
		{
			get
			{
				GetSaveData(out AlwaysMistData data);
				return data.LastRandomValue;
			}
			set
			{
				GetSaveData(out AlwaysMistData data);
				data.LastRandomValue = value;
			}
		}

		private void Awake()
		{
			Instance = this;
			SceneManager.sceneLoaded += OnSceneLoaded;
		}

		private void OnDestroy()
		{
			SceneManager.sceneLoaded -= OnSceneLoaded;
		}

		public void GetSaveData(out AlwaysMistData data)
		{
			GameManager instance = GameManager.instance;
			if (!Object.op_Implicit((Object)(object)instance))
			{
				data = new AlwaysMistData();
				return;
			}
			if (!SaveDatas.ContainsKey(instance.profileID))
			{
				SaveDatas.Add(instance.profileID, new AlwaysMistData());
			}
			data = SaveDatas[instance.profileID];
		}

		private void OnSceneLoaded(Scene scene, LoadSceneMode mode)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			Utils.Logger.Debug((object)("OnSceneLoaded: " + ((Scene)(ref scene)).name));
			CurrentSceneName = ((Scene)(ref scene)).name;
			_currentScene = scene;
			TurnOnRestBench();
			((MonoBehaviour)this).StartCoroutine(OnSceneLoadedDelay());
		}

		[IteratorStateMachine(typeof(<OnSceneLoadedDelay>d__49))]
		private IEnumerator OnSceneLoadedDelay()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <OnSceneLoadedDelay>d__49(0)
			{
				<>4__this = this
			};
		}

		private void TurnOnRestBench()
		{
			if (CurrentSceneName != "Dust_Maze_09_entrance" || (!Configs.RestBenchInMist && !Configs.TrueAlwaysMist))
			{
				return;
			}
			RestBench[] array = Object.FindObjectsByType<RestBench>((FindObjectsInactive)1, (FindObjectsSortMode)0);
			Utils.Logger.Debug((object)$"Find RestBenchs: {array}");
			RestBench[] array2 = array;
			for (int i = 0; i < array2.Length; i++)
			{
				GameObject gameObject = ((Component)array2[i]).gameObject;
				if (!(gameObject.tag != "RespawnPoint"))
				{
					Utils.Logger.Debug((object)$"Got RestBench: {gameObject}");
					if (Object.op_Implicit((Object)(object)gameObject) && !gameObject.activeSelf)
					{
						gameObject.SetActive(true);
					}
				}
			}
		}

		private void EnterMazeHandle()
		{
			if (CurrentSceneName == "Dust_Maze_09_entrance")
			{
				IsEnteredMaze = true;
			}
			else if (IsEnteredMaze && !SceneNames.Contains(CurrentSceneName) && !(CurrentSceneName == "Dust_Maze_09_entrance") && !(CurrentSceneName == "Dust_Maze_Last_Hall") && !(CurrentSceneName == "Dust_Maze_crossing"))
			{
				IsEnteredMaze = false;
				LastRandomValue = -1;
				TargetSceneName = "";
				TargetEntryDoorDir = "";
				TargetExitDoorDir = "";
			}
		}

		private void ChangeTransitionScene(string doorName, string changeScene = "Dust_Maze_09_entrance", string? exitDoorName = null)
		{
			string doorName2 = doorName;
			TransitionPoint val = ((IEnumerable<TransitionPoint>)TransitionPoint.TransitionPoints).FirstOrDefault((Func<TransitionPoint, bool>)((TransitionPoint door) => ((Component)door).gameObject.scene == _currentScene && ((Object)((Component)door).gameObject).name == doorName2));
			if (Object.op_Implicit((Object)(object)val))
			{
				string targetScene = val.targetScene;
				Utils.Logger.Info((object)("Target Scene: " + targetScene));
				if (targetScene != changeScene)
				{
					Utils.Logger.Info((object)("Change target scene to: " + changeScene));
					val.SetTargetScene(changeScene);
				}
				if (!string.IsNullOrEmpty(exitDoorName) && val.entryPoint != exitDoorName)
				{
					val.SetTargetDoor(exitDoorName);
				}
				if (Configs.ResetMazeSaveData || Configs.TrueAlwaysMist)
				{
					MazeController.ResetSaveData();
				}
			}
		}

		private void FixExitTransition()
		{
			TransitionPoint val = ((IEnumerable<TransitionPoint>)TransitionPoint.TransitionPoints).FirstOrDefault((Func<TransitionPoint, bool>)((TransitionPoint door) => ((Component)door).gameObject.scene == _currentScene && door.targetScene == TargetSceneName));
			if (Object.op_Implicit((Object)(object)val))
			{
				val.SetTargetDoor(TargetExitDoorName);
			}
		}

		private void ChangeAllTransitionScene()
		{
			List<TransitionPoint> list = TransitionPoint.TransitionPoints.Where((TransitionPoint door) => ((Component)door).gameObject.scene == _currentScene).ToList();
			if (list.Count < 1)
			{
				return;
			}
			foreach (TransitionPoint item in list)
			{
				string targetScene = item.targetScene;
				Utils.Logger.Info((object)("Target Scene: " + targetScene));
				if ((!(targetScene == "Dust_Maze_09_entrance") && !(targetScene == "Dust_Maze_Last_Hall")) || 1 == 0)
				{
					Utils.Logger.Info((object)"Change target scene to: Dust_Maze_09_entrance");
					item.SetTargetScene("Dust_Maze_09_entrance");
					if (!ChangedTransitionPoint.ContainsKey(item))
					{
						ChangedTransitionPoint.Add(item, targetScene);
					}
				}
			}
			if (Configs.ResetMazeSaveData || Configs.TrueAlwaysMist)
			{
				MazeController.ResetSaveData();
			}
		}
	}
}