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 BepInEx;
using GlobalEnums;
using HKSilksong_Randomizer;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using NativeUIMaker;
using SilksongItemRandomizer;
using SkillTriggerMod;
using StartingAbilityPicker;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.SceneManagement;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyVersion("0.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.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace MenuChanger
{
	[BepInPlugin("YourName.MenuChanger", "Menu Changer", "1.0.0")]
	public class MenuChangerMod : BaseUnityPlugin
	{
		[CompilerGenerated]
		private sealed class <ApplyPendingNextFrame>d__7 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public MenuChangerMod <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = null;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<>4__this.ApplyPendingSettings();
					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();
			}
		}

		[CompilerGenerated]
		private sealed class <DelayedInit>d__8 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public MenuChangerMod <>4__this;

			private UIManager <ui>5__1;

			private string <configPath>5__2;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<ui>5__1 = null;
				<configPath>5__2 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<ui>5__1 = null;
					goto IL_0085;
				case 1:
					<>1__state = -1;
					goto IL_0085;
				case 2:
					<>1__state = -1;
					goto IL_00ae;
				case 3:
					<>1__state = -1;
					PrefabMenuObjects.Initialize();
					<>2__current = null;
					<>1__state = 4;
					return true;
				case 4:
					<>1__state = -1;
					NativeConfigPanel.Instance.Initialize();
					<>2__current = null;
					<>1__state = 5;
					return true;
				case 5:
					<>1__state = -1;
					<configPath>5__2 = Path.Combine(Path.GetDirectoryName(((BaseUnityPlugin)<>4__this).Info.Location), "NativeUIMaker_Config.json");
					if (!File.Exists(<configPath>5__2))
					{
						<configPath>5__2 = Path.Combine(Path.GetDirectoryName(((BaseUnityPlugin)<>4__this).Info.Location), "PageConfigs", "NativeUIMaker_Config.json");
					}
					UIManagerEx.InitializeUI(<configPath>5__2);
					<>2__current = null;
					<>1__state = 6;
					return true;
				case 6:
					<>1__state = -1;
					break;
				case 7:
					{
						<>1__state = -1;
						break;
					}
					IL_00ae:
					if ((Object)(object)<ui>5__1.UICanvas == (Object)null)
					{
						<>2__current = null;
						<>1__state = 2;
						return true;
					}
					<>2__current = null;
					<>1__state = 3;
					return true;
					IL_0085:
					if ((Object)(object)<ui>5__1 == (Object)null)
					{
						<ui>5__1 = Object.FindObjectOfType<UIManager>();
						<>2__current = null;
						<>1__state = 1;
						return true;
					}
					goto IL_00ae;
				}
				if (!UIManagerEx.IsUIReady)
				{
					<>2__current = null;
					<>1__state = 7;
					return true;
				}
				NativeConfigPanel.Instance.RefreshPageList();
				NativeConfigPanel.Instance.BindModeSelectButtons();
				NativeConfigPanel.Instance.RefreshAllValues();
				Canvas.ForceUpdateCanvases();
				Debug.Log((object)"[MenuChanger] 初始化完成");
				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 bool _pendingApplied = false;

		internal static MenuChangerMod Instance { get; private set; }

		private void Awake()
		{
			Instance = this;
			Harmony.CreateAndPatchAll(typeof(PlayModeMenuPatch), (string)null);
			Harmony.CreateAndPatchAll(typeof(SkipToFirstAct), (string)null);
			SceneManager.sceneLoaded += OnSceneLoaded;
			((MonoBehaviour)this).StartCoroutine(DelayedInit());
		}

		private void OnSceneLoaded(Scene scene, LoadSceneMode mode)
		{
			if (!_pendingApplied && !(((Scene)(ref scene)).name == "Menu_Title") && !(((Scene)(ref scene)).name == "Menu") && !(((Scene)(ref scene)).name == "Loading"))
			{
				_pendingApplied = true;
				if (PendingSettingsStore.HasPending)
				{
					((MonoBehaviour)this).StartCoroutine(ApplyPendingNextFrame());
				}
			}
		}

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

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

		public static void HideAllMenuPages()
		{
			if (NativeConfigPanel.Instance != null && NativeConfigPanel.Instance.IsShowing)
			{
				NativeConfigPanel.Instance.Hide();
			}
		}

		private void Update()
		{
			if (NativeConfigPanel.Instance != null && Input.GetKeyDown((KeyCode)289))
			{
				if (NativeConfigPanel.Instance.IsShowing)
				{
					NativeConfigPanel.Instance.Hide();
				}
				else
				{
					NativeConfigPanel.Instance.Show();
				}
			}
		}

		private void ApplyPendingSettings()
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//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_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: 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_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: 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_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Expected O, but got Unknown
			//IL_0128: Expected O, but got Unknown
			try
			{
				int result;
				StartingSettings val = new StartingSettings
				{
					AllowUpward = PendingSettingsStore.allowUpward,
					AllowLeft = PendingSettingsStore.allowLeft,
					AllowRight = PendingSettingsStore.allowRight,
					UseTypeMode = PendingSettingsStore.skillMode,
					SkillTotal = PendingSettingsStore.skillTotal,
					SkillVertical = PendingSettingsStore.skillV,
					SkillHorizontal = PendingSettingsStore.skillH,
					SkillSpecial = PendingSettingsStore.skillS,
					SkillAttack = PendingSettingsStore.skillA,
					StartingItemCount = PendingSettingsStore.itemCount,
					Seed = (int.TryParse(PendingSettingsStore.seedInput, out result) ? result : 0),
					ResetSeedWorld = PendingSettingsStore.resetPickups,
					FullRandomMode = PendingSettingsStore.fullRandomMode,
					CrestCurseEnabled = PendingSettingsStore.crestCurseEnabled,
					ForceCompletionDisplay = PendingSettingsStore.forceCompletionDisplay,
					MovementPermissions = new DirectionPermissions
					{
						DashLeft = PendingSettingsStore.allowDashLeft,
						DashRight = PendingSettingsStore.allowDashRight,
						HarpoonLeft = PendingSettingsStore.allowHarpoonLeft,
						HarpoonRight = PendingSettingsStore.allowHarpoonRight,
						FloatLeft = PendingSettingsStore.allowFloatLeft,
						FloatRight = PendingSettingsStore.allowFloatRight,
						WallJumpLeft = PendingSettingsStore.allowWallJumpLeft,
						WallJumpRight = PendingSettingsStore.allowWallJumpRight,
						AllowHeal = PendingSettingsStore.allowHeal
					}
				};
				StartingAbilityPickerAPI.ApplySettingsNow(val);
				SilksongItemRandomizerAPI.SetEnabled(PendingSettingsStore.itemRandomEnabled);
				SilksongItemRandomizerAPI.SetCrestRandomEnabled(PendingSettingsStore.crestRandomEnabled);
				SilksongItemRandomizerAPI.SetSkillItemRandomEnabled(PendingSettingsStore.skillItemRandomEnabled);
				SilksongItemRandomizerAPI.SetRelicRandomEnabled(PendingSettingsStore.relicRandomEnabled);
				SilksongItemRandomizerAPI.SetTrapEnabled(PendingSettingsStore.trapEnabled);
				SilksongItemRandomizerAPI.SetTrapMovementEnabled(PendingSettingsStore.trapMovementEnabled);
				SilksongItemRandomizerAPI.SetTrapDifficulty(PendingSettingsStore.trapDifficulty);
				SilksongItemRandomizerAPI.SetCurrencyThresholds(PendingSettingsStore.currencyFirstThreshold, PendingSettingsStore.currencySecondThreshold);
				SilksongItemRandomizerAPI.SetSilkSpearPityCount(PendingSettingsStore.silkSpearPityCount);
				SilksongItemRandomizerAPI.ApplyNow();
				HKSilksong_RandomizerAPI.SetEnabled(PendingSettingsStore.sceneRandomEnabled);
				HKSilksong_RandomizerAPI.SetShowSceneLabel(PendingSettingsStore.showSceneLabel);
				HKSilksong_RandomizerAPI.SetShowSeedOnScreen(PendingSettingsStore.showSeedLabel);
				if (PendingSettingsStore.roomSeed != 0)
				{
					HKSilksong_RandomizerAPI.RegenerateWithSeed(PendingSettingsStore.roomSeed);
				}
				HKSilksong_RandomizerAPI.ApplyPending();
				SkillTriggerAPI.SetEnabled(PendingSettingsStore.skillTriggerEnabled);
				SkillTriggerAPI.ApplyNow();
				PropertyInfo propertyInfo = Type.GetType("SilksongItemRandomizer.EnemyRandoAdjuster, SilksongItemRandomizer")?.GetProperty("Enabled", BindingFlags.Static | BindingFlags.Public);
				if (propertyInfo != null)
				{
					propertyInfo.SetValue(null, PendingSettingsStore.enemyRandomEnabled);
				}
				PendingSettingsStore.Clear();
				Debug.Log((object)"[MenuChanger] 所有设置已应用完成（包含技能/物品给予）");
			}
			catch (Exception arg)
			{
				Debug.LogError((object)$"[MenuChanger] 应用设置失败: {arg}");
			}
		}

		private void OnDestroy()
		{
			SceneManager.sceneLoaded -= OnSceneLoaded;
		}
	}
	[HarmonyPatch(typeof(UIManager))]
	public static class PlayModeMenuPatch
	{
		[CompilerGenerated]
		private sealed class <ShowModeSelect>d__1 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public UIManager ui;

			private MethodInfo <setMenuState>5__1;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0031: Unknown result type (might be due to invalid IL or missing references)
				//IL_0037: Invalid comparison between Unknown and I4
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					ManagerSingleton<InputHandler>.Instance.StopUIInput();
					if ((int)ui.menuState == 6)
					{
						<>2__current = ui.HideSaveProfileMenu(true);
						<>1__state = 1;
						return true;
					}
					break;
				case 1:
					<>1__state = -1;
					break;
				}
				UIManagerEx.ShowPage("ModeSelect");
				ManagerSingleton<InputHandler>.Instance.StartUIInput();
				<setMenuState>5__1 = typeof(UIManager).GetMethod("SetMenuState", BindingFlags.Instance | BindingFlags.NonPublic);
				<setMenuState>5__1?.Invoke(ui, new object[1] { (object)(MainMenuState)18 });
				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();
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch("UIGoToPlayModeMenu")]
		public static bool Prefix(UIManager __instance)
		{
			if (!UIManagerEx.IsUIReady)
			{
				return true;
			}
			((MonoBehaviour)__instance).StartCoroutine(ShowModeSelect(__instance));
			return false;
		}

		[IteratorStateMachine(typeof(<ShowModeSelect>d__1))]
		private static IEnumerator ShowModeSelect(UIManager ui)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <ShowModeSelect>d__1(0)
			{
				ui = ui
			};
		}
	}
	public class NativeConfigPanel
	{
		[CompilerGenerated]
		private sealed class <FadeIn>d__38 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public NativeConfigPanel <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>4__this.canvasGroup.alpha = 0f;
					<>4__this.canvasGroup.interactable = true;
					<>4__this.canvasGroup.blocksRaycasts = true;
					break;
				case 1:
					<>1__state = -1;
					break;
				}
				if (<>4__this.canvasGroup.alpha < 1f)
				{
					CanvasGroup canvasGroup = <>4__this.canvasGroup;
					canvasGroup.alpha += Time.unscaledDeltaTime * 3f;
					<>2__current = null;
					<>1__state = 1;
					return true;
				}
				<>4__this.canvasGroup.alpha = 1f;
				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();
			}
		}

		[CompilerGenerated]
		private sealed class <FadeOut>d__39 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public NativeConfigPanel <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>4__this.canvasGroup.interactable = false;
					<>4__this.canvasGroup.blocksRaycasts = false;
					break;
				case 1:
					<>1__state = -1;
					break;
				}
				if (<>4__this.canvasGroup.alpha > 0f)
				{
					CanvasGroup canvasGroup = <>4__this.canvasGroup;
					canvasGroup.alpha -= Time.unscaledDeltaTime * 3f;
					<>2__current = null;
					<>1__state = 1;
					return true;
				}
				<>4__this.canvasGroup.alpha = 0f;
				if ((Object)(object)<>4__this.root != (Object)null)
				{
					<>4__this.root.SetActive(false);
				}
				if (<>4__this.parentPage != null)
				{
					<>4__this.parentPage.Show(true);
				}
				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 static NativeConfigPanel _instance;

		private GameObject root;

		private CanvasGroup canvasGroup;

		private UIManager uiManager;

		private NativePage parentPage;

		private NativeLabel pageIndicator;

		private List<string> pageOrder = new List<string>();

		private List<NativeInput> _repeatLimitInputs = new List<NativeInput>();

		public static NativeConfigPanel Instance => _instance ?? (_instance = new NativeConfigPanel());

		public bool IsShowing => (Object)(object)root != (Object)null && root.activeSelf;

		private NativeConfigPanel()
		{
		}

		public void Initialize()
		{
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Expected O, but got Unknown
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Expected O, but got Unknown
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: Unknown result type (might be due to invalid IL or missing references)
			//IL_016c: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)root != (Object)null))
			{
				PrefabMenuObjects.Initialize();
				uiManager = UIManager.instance;
				if (!((Object)(object)uiManager == (Object)null))
				{
					root = new GameObject("NativeConfigPanel");
					root.transform.SetParent(((Component)uiManager.UICanvas).transform, false);
					canvasGroup = root.AddComponent<CanvasGroup>();
					canvasGroup.alpha = 0f;
					canvasGroup.interactable = false;
					canvasGroup.blocksRaycasts = false;
					root.SetActive(false);
					GameObject val = new GameObject("Panel");
					val.transform.SetParent(root.transform, false);
					RectTransform val2 = val.AddComponent<RectTransform>();
					val2.sizeDelta = new Vector2(1200f, 800f);
					val2.anchorMin = Vector2.zero;
					val2.anchorMax = Vector2.one;
					val2.pivot = new Vector2(0.5f, 0.5f);
					val2.anchoredPosition = Vector2.zero;
					pageIndicator = NativeLabel.Create(val2);
					pageIndicator.SetText("1/1");
					pageIndicator.SetFontSize(32);
					pageIndicator.SetPosition(new Vector2(0f, -420f));
					pageIndicator.SetSize(200f, 60f);
					pageIndicator.SetAlignment((TextAnchor)4);
					pageIndicator.gameObject.SetActive(false);
					SubscribeToGlobalEvents();
					BindRepeatLimitInputs();
				}
			}
		}

		private void BindRepeatLimitInputs()
		{
			NativePage val = ((IEnumerable<NativePage>)NativePage.AllInstances).FirstOrDefault((Func<NativePage, bool>)((NativePage p) => ((Object)p.gameObject).name == "RepeatLimitPage"));
			if (val == null)
			{
				return;
			}
			_repeatLimitInputs = val.gameObject.GetComponentsInChildren<NativeInput>(true).ToList();
			if (_repeatLimitInputs.Count == 0)
			{
				Debug.LogWarning((object)"[NativeConfigPanel] RepeatLimitPage 下没有找到任何 NativeInput 控件");
				return;
			}
			Dictionary<string, Action<int>> dictionary = new Dictionary<string, Action<int>>
			{
				{
					"Input_LimitSkillItem",
					delegate(int v)
					{
						ItemLimitConfig.LimitSkillItem = v;
					}
				},
				{
					"Input_LimitRelic",
					delegate(int v)
					{
						ItemLimitConfig.LimitRelic = v;
					}
				},
				{
					"Input_LimitOtherItem",
					delegate(int v)
					{
						ItemLimitConfig.LimitOtherItem = v;
					}
				},
				{
					"Input_LimitUpSlash",
					delegate(int v)
					{
						ItemLimitConfig.LimitUpSlash = v;
					}
				},
				{
					"Input_LimitLeftSlash",
					delegate(int v)
					{
						ItemLimitConfig.LimitLeftSlash = v;
					}
				},
				{
					"Input_LimitRightSlash",
					delegate(int v)
					{
						ItemLimitConfig.LimitRightSlash = v;
					}
				},
				{
					"Input_LimitDashLeft",
					delegate(int v)
					{
						ItemLimitConfig.LimitDashLeft = v;
					}
				},
				{
					"Input_LimitDashRight",
					delegate(int v)
					{
						ItemLimitConfig.LimitDashRight = v;
					}
				},
				{
					"Input_LimitHarpoonLeft",
					delegate(int v)
					{
						ItemLimitConfig.LimitHarpoonLeft = v;
					}
				},
				{
					"Input_LimitHarpoonRight",
					delegate(int v)
					{
						ItemLimitConfig.LimitHarpoonRight = v;
					}
				},
				{
					"Input_LimitFloatLeft",
					delegate(int v)
					{
						ItemLimitConfig.LimitFloatLeft = v;
					}
				},
				{
					"Input_LimitFloatRight",
					delegate(int v)
					{
						ItemLimitConfig.LimitFloatRight = v;
					}
				},
				{
					"Input_LimitWallJumpLeft",
					delegate(int v)
					{
						ItemLimitConfig.LimitWallJumpLeft = v;
					}
				},
				{
					"Input_LimitWallJumpRight",
					delegate(int v)
					{
						ItemLimitConfig.LimitWallJumpRight = v;
					}
				},
				{
					"Input_LimitHeal",
					delegate(int v)
					{
						ItemLimitConfig.LimitHeal = v;
					}
				},
				{
					"Input_LimitNeedleThrow",
					delegate(int v)
					{
						ItemLimitConfig.LimitNeedleThrow = v;
					}
				},
				{
					"Input_LimitThreadSphere",
					delegate(int v)
					{
						ItemLimitConfig.LimitThreadSphere = v;
					}
				},
				{
					"Input_LimitHarpoonDash",
					delegate(int v)
					{
						ItemLimitConfig.LimitHarpoonDash = v;
					}
				},
				{
					"Input_LimitSilkCharge",
					delegate(int v)
					{
						ItemLimitConfig.LimitSilkCharge = v;
					}
				},
				{
					"Input_LimitSilkBomb",
					delegate(int v)
					{
						ItemLimitConfig.LimitSilkBomb = v;
					}
				},
				{
					"Input_LimitSilkBossNeedle",
					delegate(int v)
					{
						ItemLimitConfig.LimitSilkBossNeedle = v;
					}
				},
				{
					"Input_LimitNeedolin",
					delegate(int v)
					{
						ItemLimitConfig.LimitNeedolin = v;
					}
				},
				{
					"Input_LimitParry",
					delegate(int v)
					{
						ItemLimitConfig.LimitParry = v;
					}
				},
				{
					"Input_LimitNeedolinMemory",
					delegate(int v)
					{
						ItemLimitConfig.LimitNeedolinMemory = v;
					}
				},
				{
					"Input_LimitFastTravel",
					delegate(int v)
					{
						ItemLimitConfig.LimitFastTravel = v;
					}
				},
				{
					"Input_LimitEvaHeal",
					delegate(int v)
					{
						ItemLimitConfig.LimitEvaHeal = v;
					}
				},
				{
					"Input_LimitDash",
					delegate(int v)
					{
						ItemLimitConfig.LimitDash = v;
					}
				},
				{
					"Input_LimitBrolly",
					delegate(int v)
					{
						ItemLimitConfig.LimitBrolly = v;
					}
				},
				{
					"Input_LimitDoubleJump",
					delegate(int v)
					{
						ItemLimitConfig.LimitDoubleJump = v;
					}
				},
				{
					"Input_LimitSuperJump",
					delegate(int v)
					{
						ItemLimitConfig.LimitSuperJump = v;
					}
				},
				{
					"Input_LimitWallJump",
					delegate(int v)
					{
						ItemLimitConfig.LimitWallJump = v;
					}
				},
				{
					"Input_LimitChargeSlash",
					delegate(int v)
					{
						ItemLimitConfig.LimitChargeSlash = v;
					}
				},
				{
					"Input_LimitHeartPiece",
					delegate(int v)
					{
						ItemLimitConfig.LimitHeartPiece = v;
					}
				},
				{
					"Input_LimitSpoolPart",
					delegate(int v)
					{
						ItemLimitConfig.LimitSpoolPart = v;
					}
				},
				{
					"Input_LimitMaxSilkRegenUp",
					delegate(int v)
					{
						ItemLimitConfig.LimitMaxSilkRegenUp = v;
					}
				},
				{
					"Input_LimitUnlockCrestSlot",
					delegate(int v)
					{
						ItemLimitConfig.LimitUnlockCrestSlot = v;
					}
				}
			};
			foreach (NativeInput repeatLimitInput in _repeatLimitInputs)
			{
				if (!dictionary.TryGetValue(((Object)repeatLimitInput.gameObject).name, out var setter))
				{
					continue;
				}
				repeatLimitInput.SetText(GetLimitValue(((Object)repeatLimitInput.gameObject).name).ToString());
				repeatLimitInput.AddTextChangedListener((Action<string>)delegate(string text)
				{
					if (int.TryParse(text, out var result))
					{
						setter(result);
					}
				});
			}
		}

		private int GetLimitValue(string inputName)
		{
			return inputName switch
			{
				"Input_LimitSkillItem" => ItemLimitConfig.LimitSkillItem, 
				"Input_LimitRelic" => ItemLimitConfig.LimitRelic, 
				"Input_LimitOtherItem" => ItemLimitConfig.LimitOtherItem, 
				"Input_LimitUpSlash" => ItemLimitConfig.LimitUpSlash, 
				"Input_LimitLeftSlash" => ItemLimitConfig.LimitLeftSlash, 
				"Input_LimitRightSlash" => ItemLimitConfig.LimitRightSlash, 
				"Input_LimitDashLeft" => ItemLimitConfig.LimitDashLeft, 
				"Input_LimitDashRight" => ItemLimitConfig.LimitDashRight, 
				"Input_LimitHarpoonLeft" => ItemLimitConfig.LimitHarpoonLeft, 
				"Input_LimitHarpoonRight" => ItemLimitConfig.LimitHarpoonRight, 
				"Input_LimitFloatLeft" => ItemLimitConfig.LimitFloatLeft, 
				"Input_LimitFloatRight" => ItemLimitConfig.LimitFloatRight, 
				"Input_LimitWallJumpLeft" => ItemLimitConfig.LimitWallJumpLeft, 
				"Input_LimitWallJumpRight" => ItemLimitConfig.LimitWallJumpRight, 
				"Input_LimitHeal" => ItemLimitConfig.LimitHeal, 
				"Input_LimitNeedleThrow" => ItemLimitConfig.LimitNeedleThrow, 
				"Input_LimitThreadSphere" => ItemLimitConfig.LimitThreadSphere, 
				"Input_LimitHarpoonDash" => ItemLimitConfig.LimitHarpoonDash, 
				"Input_LimitSilkCharge" => ItemLimitConfig.LimitSilkCharge, 
				"Input_LimitSilkBomb" => ItemLimitConfig.LimitSilkBomb, 
				"Input_LimitSilkBossNeedle" => ItemLimitConfig.LimitSilkBossNeedle, 
				"Input_LimitNeedolin" => ItemLimitConfig.LimitNeedolin, 
				"Input_LimitParry" => ItemLimitConfig.LimitParry, 
				"Input_LimitNeedolinMemory" => ItemLimitConfig.LimitNeedolinMemory, 
				"Input_LimitFastTravel" => ItemLimitConfig.LimitFastTravel, 
				"Input_LimitEvaHeal" => ItemLimitConfig.LimitEvaHeal, 
				"Input_LimitDash" => ItemLimitConfig.LimitDash, 
				"Input_LimitBrolly" => ItemLimitConfig.LimitBrolly, 
				"Input_LimitDoubleJump" => ItemLimitConfig.LimitDoubleJump, 
				"Input_LimitSuperJump" => ItemLimitConfig.LimitSuperJump, 
				"Input_LimitWallJump" => ItemLimitConfig.LimitWallJump, 
				"Input_LimitChargeSlash" => ItemLimitConfig.LimitChargeSlash, 
				"Input_LimitHeartPiece" => ItemLimitConfig.LimitHeartPiece, 
				"Input_LimitSpoolPart" => ItemLimitConfig.LimitSpoolPart, 
				"Input_LimitMaxSilkRegenUp" => ItemLimitConfig.LimitMaxSilkRegenUp, 
				"Input_LimitUnlockCrestSlot" => ItemLimitConfig.LimitUnlockCrestSlot, 
				_ => 0, 
			};
		}

		private void RefreshRepeatLimitInputs()
		{
			foreach (NativeInput repeatLimitInput in _repeatLimitInputs)
			{
				repeatLimitInput.SetText(GetLimitValue(((Object)repeatLimitInput.gameObject).name).ToString());
			}
		}

		private void SubscribeToGlobalEvents()
		{
			NativeUIEventDispatcher.OnNativeUIEvent += delegate(object sender, NativeUIEventArgs args)
			{
				//IL_0026: Unknown result type (might be due to invalid IL or missing references)
				//IL_002c: Invalid comparison between Unknown and I4
				//IL_0067: Unknown result type (might be due to invalid IL or missing references)
				//IL_006d: Invalid comparison between Unknown and I4
				//IL_02ed: Unknown result type (might be due to invalid IL or missing references)
				//IL_02f3: Invalid comparison between Unknown and I4
				//IL_0096: Unknown result type (might be due to invalid IL or missing references)
				//IL_009c: Invalid comparison between Unknown and I4
				//IL_0a7e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0a84: Invalid comparison between Unknown and I4
				//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ef: Invalid comparison between Unknown and I4
				//IL_0d72: Unknown result type (might be due to invalid IL or missing references)
				//IL_0d78: Invalid comparison between Unknown and I4
				//IL_011b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0121: Invalid comparison between Unknown and I4
				//IL_0df0: Unknown result type (might be due to invalid IL or missing references)
				//IL_0df6: Invalid comparison between Unknown and I4
				//IL_0150: Unknown result type (might be due to invalid IL or missing references)
				//IL_0156: Invalid comparison between Unknown and I4
				//IL_0eb7: Unknown result type (might be due to invalid IL or missing references)
				//IL_0ebd: Invalid comparison between Unknown and I4
				//IL_0185: Unknown result type (might be due to invalid IL or missing references)
				//IL_018b: Invalid comparison between Unknown and I4
				//IL_01ba: Unknown result type (might be due to invalid IL or missing references)
				//IL_01c0: Invalid comparison between Unknown and I4
				//IL_01ef: Unknown result type (might be due to invalid IL or missing references)
				//IL_01f5: Invalid comparison between Unknown and I4
				//IL_0224: Unknown result type (might be due to invalid IL or missing references)
				//IL_022a: Invalid comparison between Unknown and I4
				//IL_0259: Unknown result type (might be due to invalid IL or missing references)
				//IL_025f: Invalid comparison between Unknown and I4
				//IL_028b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0291: Invalid comparison between Unknown and I4
				//IL_02bd: Unknown result type (might be due to invalid IL or missing references)
				//IL_02c3: Invalid comparison between Unknown and I4
				if ((args.ControlName == "LeftArrow" || args.ControlName.StartsWith("LeftArrow_")) && (int)args.EventType == 0)
				{
					SwitchPage(-1);
				}
				else if ((args.ControlName == "RightArrow" || args.ControlName.StartsWith("RightArrow_")) && (int)args.EventType == 0)
				{
					SwitchPage(1);
				}
				else if (args.ControlName == "RandomModeBtn" && (int)args.EventType == 0)
				{
					ShowPage(pageOrder.Contains("Main") ? "Main" : pageOrder[0]);
				}
				else if (args.ControlName == "DetailBtn" && (int)args.EventType == 0)
				{
					UIManagerEx.ShowPage("Detail0");
				}
				else if (args.ControlName == "BackToMainBtn" && (int)args.EventType == 0)
				{
					ShowPage("Main");
				}
				else if (args.ControlName == "BackToModeSelectBtn" && (int)args.EventType == 0)
				{
					ShowPage("ModeSelect");
				}
				else if (args.ControlName == "ItemPoolBtn" && (int)args.EventType == 0)
				{
					ShowPage("ItemPoolPage");
				}
				else if (args.ControlName == "StartLocationBtn" && (int)args.EventType == 0)
				{
					ShowPage("StartLocationPage");
				}
				else if (args.ControlName == "CurseBtn" && (int)args.EventType == 0)
				{
					ShowPage("Detail2");
				}
				else if (args.ControlName == "RepeatBtn" && (int)args.EventType == 0)
				{
					ShowPage("RepeatLimitPage");
				}
				else if (args.ControlName == "BackToMainBtn_ItemPool" && (int)args.EventType == 0)
				{
					ShowPage("Main");
				}
				else if (args.ControlName == "BackToMainBtn_Repeat" && (int)args.EventType == 0)
				{
					ShowPage("Main");
				}
				else if (args.ControlName == "BackToMainBtn_StartLoc" && (int)args.EventType == 0)
				{
					ShowPage("Main");
				}
				if (args.ControlType == "Button" && (int)args.EventType == 0)
				{
					object source = args.Source;
					NativeButton val = (NativeButton)((source is NativeButton) ? source : null);
					if (val == null)
					{
						return;
					}
					switch (args.ControlName)
					{
					case "RoomBtn":
					{
						bool flag7 = (PendingSettingsStore.sceneRandomEnabled = !PendingSettingsStore.sceneRandomEnabled);
						StartingAbilityPickerAPI.SetSceneRandomEnabled(flag7);
						val.SetToggleIndex(flag7 ? 1 : 0);
						break;
					}
					case "ItemBtn":
					{
						bool flag6 = (PendingSettingsStore.itemRandomEnabled = !PendingSettingsStore.itemRandomEnabled);
						StartingAbilityPickerAPI.SetItemRandomEnabled(flag6);
						val.SetToggleIndex(flag6 ? 1 : 0);
						break;
					}
					case "TrapBtn":
					{
						bool flag8 = (PendingSettingsStore.trapEnabled = !PendingSettingsStore.trapEnabled);
						StartingAbilityPickerAPI.SetTrapRandomEnabled(flag8);
						val.SetToggleIndex(flag8 ? 1 : 0);
						break;
					}
					case "EnemyBtn":
					{
						bool flag5 = (PendingSettingsStore.enemyRandomEnabled = !PendingSettingsStore.enemyRandomEnabled);
						StartingAbilityPickerAPI.SetEnemyRandomEnabled(flag5);
						val.SetToggleIndex(flag5 ? 1 : 0);
						break;
					}
					default:
					{
						bool flag = val.GetTitle() == "开";
						switch (args.ControlName)
						{
						case "CrestCurseBtn":
							StartingAbilityPickerAPI.SetCrestCurseEnabled(flag);
							break;
						case "FullRandomBtn":
							StartingAbilityPickerAPI.SetFullRandomMode(flag);
							UpdateFullRandomUI();
							break;
						case "TrapMovementBtn":
							SilksongItemRandomizerAPI.SetTrapMovementEnabled(flag);
							break;
						case "EnemyScaleRandomBtn":
							(Type.GetType("SilksongItemRandomizer.EnemyRandoAdjuster, SilksongItemRandomizer")?.GetProperty("ScaleRandomEnabled", BindingFlags.Static | BindingFlags.Public))?.SetValue(null, flag);
							break;
						case "UpBtn":
						{
							(bool, bool, bool) attackPermissions = StartingAbilityPickerAPI.GetAttackPermissions();
							StartingAbilityPickerAPI.SetAttackPermissions(flag, attackPermissions.Item2, attackPermissions.Item3);
							UpdateCategoryButtonStates();
							break;
						}
						case "LeftBtn":
						{
							(bool, bool, bool) attackPermissions = StartingAbilityPickerAPI.GetAttackPermissions();
							StartingAbilityPickerAPI.SetAttackPermissions(attackPermissions.Item1, flag, attackPermissions.Item3);
							UpdateCategoryButtonStates();
							break;
						}
						case "RightBtn":
						{
							(bool, bool, bool) attackPermissions = StartingAbilityPickerAPI.GetAttackPermissions();
							StartingAbilityPickerAPI.SetAttackPermissions(attackPermissions.Item1, attackPermissions.Item2, flag);
							UpdateCategoryButtonStates();
							break;
						}
						case "ShowRoomNameBtn":
							HKSilksong_RandomizerAPI.SetShowSceneLabel(flag);
							break;
						case "ShowRoomSeedBtn":
							HKSilksong_RandomizerAPI.SetShowSeedOnScreen(flag);
							break;
						case "SilkHeartBtn":
							RoomRandomMode.Toggle();
							break;
						case "CompletionBtn":
							StartingAbilityPickerAPI.SetForceCompletionDisplay(flag);
							break;
						case "TrapDifficultyBtn":
						{
							string title = val.GetTitle();
							int trapDifficulty = ((!(title == "初猎")) ? ((title == "专注") ? 1 : 2) : 0);
							SilksongItemRandomizerAPI.SetTrapDifficulty(trapDifficulty);
							if (SilksongItemRandomizerAPI.IsTrapEnabled())
							{
								SilksongItemRandomizerAPI.RegenerateTrapsNow();
							}
							break;
						}
						case "CategoryBtn1":
							if (StartingAbilityPickerAPI.GetFullRandomMode())
							{
								DirectionPermissions movementPermissions5 = StartingAbilityPickerAPI.GetMovementPermissions();
								movementPermissions5.DashLeft = flag;
								movementPermissions5.DashRight = flag;
								StartingAbilityPickerAPI.SetMovementPermissions(movementPermissions5);
							}
							break;
						case "CategoryBtn2":
							if (StartingAbilityPickerAPI.GetFullRandomMode())
							{
								DirectionPermissions movementPermissions4 = StartingAbilityPickerAPI.GetMovementPermissions();
								movementPermissions4.HarpoonLeft = flag;
								movementPermissions4.HarpoonRight = flag;
								StartingAbilityPickerAPI.SetMovementPermissions(movementPermissions4);
							}
							break;
						case "CategoryBtn3":
							if (StartingAbilityPickerAPI.GetFullRandomMode())
							{
								DirectionPermissions movementPermissions3 = StartingAbilityPickerAPI.GetMovementPermissions();
								movementPermissions3.FloatLeft = flag;
								movementPermissions3.FloatRight = flag;
								StartingAbilityPickerAPI.SetMovementPermissions(movementPermissions3);
							}
							break;
						case "CategoryBtn4":
							if (StartingAbilityPickerAPI.GetFullRandomMode())
							{
								DirectionPermissions movementPermissions2 = StartingAbilityPickerAPI.GetMovementPermissions();
								movementPermissions2.WallJumpLeft = flag;
								movementPermissions2.WallJumpRight = flag;
								StartingAbilityPickerAPI.SetMovementPermissions(movementPermissions2);
							}
							break;
						case "CategoryBtn5":
							if (StartingAbilityPickerAPI.GetFullRandomMode())
							{
								DirectionPermissions movementPermissions = StartingAbilityPickerAPI.GetMovementPermissions();
								movementPermissions.AllowHeal = flag;
								StartingAbilityPickerAPI.SetMovementPermissions(movementPermissions);
							}
							break;
						case "CategoryBtn6":
							if (StartingAbilityPickerAPI.GetFullRandomMode())
							{
								StartingAbilityPickerAPI.SetAttackPermissions(!flag, !flag, !flag);
							}
							break;
						case "CrestTypeBtn":
						{
							bool flag4 = !SilksongItemRandomizerAPI.IsCrestRandomEnabled();
							SilksongItemRandomizerAPI.SetCrestRandomEnabled(flag4);
							UpdateTypeButtonColor(val, flag4);
							break;
						}
						case "SkillTypeBtn":
						{
							bool flag3 = !SilksongItemRandomizerAPI.IsSkillItemRandomEnabled();
							SilksongItemRandomizerAPI.SetSkillItemRandomEnabled(flag3);
							UpdateTypeButtonColor(val, flag3);
							break;
						}
						case "RelicTypeBtn":
						{
							bool flag2 = !SilksongItemRandomizerAPI.IsRelicRandomEnabled();
							SilksongItemRandomizerAPI.SetRelicRandomEnabled(flag2);
							UpdateTypeButtonColor(val, flag2);
							break;
						}
						}
						break;
					}
					}
				}
				if (args.ControlType == "Slider" && (int)args.EventType == 1)
				{
					float num = (float)args.Value;
					switch (args.ControlName)
					{
					case "ItemCountSlider":
						StartingAbilityPickerAPI.SetStartingItemCount((int)num);
						break;
					case "TotalSkillSlider":
					{
						(int, int, int, int, int) skillCounts = StartingAbilityPickerAPI.GetSkillCounts();
						StartingAbilityPickerAPI.SetSkillCounts((int)num, skillCounts.Item2, skillCounts.Item3, skillCounts.Item4, skillCounts.Item5);
						break;
					}
					case "VSlider":
					{
						(int, int, int, int, int) skillCounts = StartingAbilityPickerAPI.GetSkillCounts();
						StartingAbilityPickerAPI.SetSkillCounts(skillCounts.Item1, (int)num, skillCounts.Item3, skillCounts.Item4, skillCounts.Item5);
						break;
					}
					case "HSlider":
					{
						(int, int, int, int, int) skillCounts = StartingAbilityPickerAPI.GetSkillCounts();
						StartingAbilityPickerAPI.SetSkillCounts(skillCounts.Item1, skillCounts.Item2, (int)num, skillCounts.Item4, skillCounts.Item5);
						break;
					}
					case "SSlider":
					{
						(int, int, int, int, int) skillCounts = StartingAbilityPickerAPI.GetSkillCounts();
						StartingAbilityPickerAPI.SetSkillCounts(skillCounts.Item1, skillCounts.Item2, skillCounts.Item3, (int)num, skillCounts.Item5);
						break;
					}
					case "ASlider":
					{
						(int, int, int, int, int) skillCounts = StartingAbilityPickerAPI.GetSkillCounts();
						StartingAbilityPickerAPI.SetSkillCounts(skillCounts.Item1, skillCounts.Item2, skillCounts.Item3, skillCounts.Item4, (int)num);
						break;
					}
					case "EnemyScaleMinSlider":
						(Type.GetType("SilksongItemRandomizer.EnemyRandoAdjuster, SilksongItemRandomizer")?.GetProperty("ScaleMin", BindingFlags.Static | BindingFlags.Public))?.SetValue(null, num);
						break;
					case "EnemyScaleMaxSlider":
						(Type.GetType("SilksongItemRandomizer.EnemyRandoAdjuster, SilksongItemRandomizer")?.GetProperty("ScaleMax", BindingFlags.Static | BindingFlags.Public))?.SetValue(null, num);
						break;
					}
				}
				if (args.ControlType == "Option" && (int)args.EventType == 2)
				{
					int num2 = (int)args.Value;
					string controlName = args.ControlName;
					string text = controlName;
					if (!(text == "SkillModeOption"))
					{
						if (text == "ResetOption")
						{
							StartingAbilityPickerAPI.SetResetSeedWorld(num2 == 1);
						}
					}
					else
					{
						StartingAbilityPickerAPI.SetSkillRandomMode(num2 == 1);
						UpdateSlidersVisibility();
					}
				}
				if (args.ControlType == "Input" && (int)args.EventType == 1)
				{
					string s = (string)args.Value;
					switch (args.ControlName)
					{
					case "CurrencyFirstThresholdInput":
					{
						if (int.TryParse(s, out var result2))
						{
							(int, int) currencyThresholds = SilksongItemRandomizerAPI.GetCurrencyThresholds();
							SilksongItemRandomizerAPI.SetCurrencyThresholds(result2, currencyThresholds.Item2);
						}
						break;
					}
					case "CurrencySecondThresholdInput":
					{
						if (int.TryParse(s, out var result3))
						{
							SilksongItemRandomizerAPI.SetCurrencyThresholds(SilksongItemRandomizerAPI.GetCurrencyThresholds().Item1, result3);
						}
						break;
					}
					case "SilkSpearPityInput":
					{
						if (int.TryParse(s, out var result))
						{
							SilksongItemRandomizerAPI.SetSilkSpearPityCount(result);
						}
						break;
					}
					}
				}
				if ((int)args.EventType == 0)
				{
					switch (args.ControlName)
					{
					case "ConfirmBtn":
						Confirm();
						break;
					case "ResetShopBtn":
						SilksongItemRandomizerAPI.ResetAllData();
						break;
					case "ResetPickupBtn":
						Type.GetType("SilksongItemRandomizer.Extracurrencypickup, SilksongItemRandomizer")?.GetMethod("ResetAll", BindingFlags.Static | BindingFlags.Public)?.Invoke(null, null);
						break;
					case "ResetFrostBlacklistBtn":
						Type.GetType("SilksongItemRandomizer.TrapRandomizer, SilksongItemRandomizer")?.GetMethod("ResetFrostBannedScenes", BindingFlags.Static | BindingFlags.Public)?.Invoke(null, null);
						break;
					case "ApplyRoomSeedBtn":
						ApplyRoomSeed();
						break;
					}
				}
			};
		}

		private bool IsFullRandomEnabled()
		{
			return StartingAbilityPickerAPI.GetFullRandomMode();
		}

		private void UpdateFullRandomUI()
		{
			bool flag = IsFullRandomEnabled();
			string[] array = new string[6] { "CategoryBtn1", "CategoryBtn2", "CategoryBtn3", "CategoryBtn4", "CategoryBtn5", "CategoryBtn6" };
			string[] array2 = array;
			foreach (string name in array2)
			{
				NativeButton val = ((IEnumerable<NativeButton>)NativeButton.AllInstances).FirstOrDefault((Func<NativeButton, bool>)((NativeButton b) => ((Object)b.gameObject).name == name));
				if (val != null && (Object)(object)val.menuButton != (Object)null)
				{
					((Selectable)val.menuButton).interactable = flag;
				}
			}
			NativeButton val2 = ((IEnumerable<NativeButton>)NativeButton.AllInstances).FirstOrDefault((Func<NativeButton, bool>)((NativeButton b) => ((Object)b.gameObject).name == "UpBtn"));
			NativeButton val3 = ((IEnumerable<NativeButton>)NativeButton.AllInstances).FirstOrDefault((Func<NativeButton, bool>)((NativeButton b) => ((Object)b.gameObject).name == "LeftBtn"));
			NativeButton val4 = ((IEnumerable<NativeButton>)NativeButton.AllInstances).FirstOrDefault((Func<NativeButton, bool>)((NativeButton b) => ((Object)b.gameObject).name == "RightBtn"));
			if (val2 != null && (Object)(object)val2.menuButton != (Object)null)
			{
				((Selectable)val2.menuButton).interactable = !flag;
			}
			if (val3 != null && (Object)(object)val3.menuButton != (Object)null)
			{
				((Selectable)val3.menuButton).interactable = !flag;
			}
			if (val4 != null && (Object)(object)val4.menuButton != (Object)null)
			{
				((Selectable)val4.menuButton).interactable = !flag;
			}
		}

		private void UpdateCategoryButtonStates()
		{
			if (IsFullRandomEnabled())
			{
				DirectionPermissions movementPermissions = StartingAbilityPickerAPI.GetMovementPermissions();
				NativeButton val = ((IEnumerable<NativeButton>)NativeButton.AllInstances).FirstOrDefault((Func<NativeButton, bool>)((NativeButton b) => ((Object)b.gameObject).name == "CategoryBtn1"));
				if (val != null)
				{
					val.SetToggleIndex((movementPermissions.DashLeft && movementPermissions.DashRight) ? 1 : 0);
				}
				NativeButton val2 = ((IEnumerable<NativeButton>)NativeButton.AllInstances).FirstOrDefault((Func<NativeButton, bool>)((NativeButton b) => ((Object)b.gameObject).name == "CategoryBtn2"));
				if (val2 != null)
				{
					val2.SetToggleIndex((movementPermissions.HarpoonLeft && movementPermissions.HarpoonRight) ? 1 : 0);
				}
				NativeButton val3 = ((IEnumerable<NativeButton>)NativeButton.AllInstances).FirstOrDefault((Func<NativeButton, bool>)((NativeButton b) => ((Object)b.gameObject).name == "CategoryBtn3"));
				if (val3 != null)
				{
					val3.SetToggleIndex((movementPermissions.FloatLeft && movementPermissions.FloatRight) ? 1 : 0);
				}
				NativeButton val4 = ((IEnumerable<NativeButton>)NativeButton.AllInstances).FirstOrDefault((Func<NativeButton, bool>)((NativeButton b) => ((Object)b.gameObject).name == "CategoryBtn4"));
				if (val4 != null)
				{
					val4.SetToggleIndex((movementPermissions.WallJumpLeft && movementPermissions.WallJumpRight) ? 1 : 0);
				}
				NativeButton val5 = ((IEnumerable<NativeButton>)NativeButton.AllInstances).FirstOrDefault((Func<NativeButton, bool>)((NativeButton b) => ((Object)b.gameObject).name == "CategoryBtn5"));
				if (val5 != null)
				{
					val5.SetToggleIndex(movementPermissions.AllowHeal ? 1 : 0);
				}
				(bool, bool, bool) attackPermissions = StartingAbilityPickerAPI.GetAttackPermissions();
				NativeButton val6 = ((IEnumerable<NativeButton>)NativeButton.AllInstances).FirstOrDefault((Func<NativeButton, bool>)((NativeButton b) => ((Object)b.gameObject).name == "CategoryBtn6"));
				if (val6 != null)
				{
					val6.SetToggleIndex((attackPermissions.Item1 && attackPermissions.Item2 && attackPermissions.Item3) ? 1 : 0);
				}
			}
		}

		private void UpdateTypeButtonColor(NativeButton btn, bool isEnabled)
		{
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			if (btn != null)
			{
				Text componentInChildren = btn.gameObject.GetComponentInChildren<Text>();
				if ((Object)(object)componentInChildren != (Object)null)
				{
					((Graphic)componentInChildren).color = (Color)(isEnabled ? Color.white : new Color(0.8f, 0.8f, 0.8f));
					((Graphic)componentInChildren).SetVerticesDirty();
				}
				Canvas.ForceUpdateCanvases();
			}
		}

		private void ApplyRoomSeed()
		{
			NativeInput val = ((IEnumerable<NativeInput>)NativeInput.AllInstances).FirstOrDefault((Func<NativeInput, bool>)((NativeInput i) => ((Object)i.gameObject).name == "RoomSeedInput"));
			if (val != null && int.TryParse(val.GetText(), out var result))
			{
				HKSilksong_RandomizerAPI.RegenerateWithSeed(result);
			}
		}

		private void CollectCurrentSettingsToStore()
		{
			NativeButton val = ((IEnumerable<NativeButton>)NativeButton.AllInstances).FirstOrDefault((Func<NativeButton, bool>)((NativeButton b) => ((Object)b.gameObject).name == "UpBtn"));
			NativeButton val2 = ((IEnumerable<NativeButton>)NativeButton.AllInstances).FirstOrDefault((Func<NativeButton, bool>)((NativeButton b) => ((Object)b.gameObject).name == "LeftBtn"));
			NativeButton val3 = ((IEnumerable<NativeButton>)NativeButton.AllInstances).FirstOrDefault((Func<NativeButton, bool>)((NativeButton b) => ((Object)b.gameObject).name == "RightBtn"));
			PendingSettingsStore.allowUpward = ((val != null) ? val.GetTitle() : null) == "开";
			PendingSettingsStore.allowLeft = ((val2 != null) ? val2.GetTitle() : null) == "开";
			PendingSettingsStore.allowRight = ((val3 != null) ? val3.GetTitle() : null) == "开";
			NativeOption val4 = ((IEnumerable<NativeOption>)NativeOption.AllInstances).FirstOrDefault((Func<NativeOption, bool>)((NativeOption o) => ((Object)o.gameObject).name == "SkillModeOption"));
			PendingSettingsStore.skillMode = ((val4 != null) ? val4.GetCurrentValue() : null) == "分类随机";
			NativeSlider val5 = ((IEnumerable<NativeSlider>)NativeSlider.AllInstances).FirstOrDefault((Func<NativeSlider, bool>)((NativeSlider s) => ((Object)s.gameObject).name == "TotalSkillSlider"));
			if (val5 != null)
			{
				PendingSettingsStore.skillTotal = (int)val5.Value;
			}
			NativeSlider val6 = ((IEnumerable<NativeSlider>)NativeSlider.AllInstances).FirstOrDefault((Func<NativeSlider, bool>)((NativeSlider s) => ((Object)s.gameObject).name == "VSlider"));
			if (val6 != null)
			{
				PendingSettingsStore.skillV = (int)val6.Value;
			}
			NativeSlider val7 = ((IEnumerable<NativeSlider>)NativeSlider.AllInstances).FirstOrDefault((Func<NativeSlider, bool>)((NativeSlider s) => ((Object)s.gameObject).name == "HSlider"));
			if (val7 != null)
			{
				PendingSettingsStore.skillH = (int)val7.Value;
			}
			NativeSlider val8 = ((IEnumerable<NativeSlider>)NativeSlider.AllInstances).FirstOrDefault((Func<NativeSlider, bool>)((NativeSlider s) => ((Object)s.gameObject).name == "SSlider"));
			if (val8 != null)
			{
				PendingSettingsStore.skillS = (int)val8.Value;
			}
			NativeSlider val9 = ((IEnumerable<NativeSlider>)NativeSlider.AllInstances).FirstOrDefault((Func<NativeSlider, bool>)((NativeSlider s) => ((Object)s.gameObject).name == "ASlider"));
			if (val9 != null)
			{
				PendingSettingsStore.skillA = (int)val9.Value;
			}
			NativeSlider val10 = ((IEnumerable<NativeSlider>)NativeSlider.AllInstances).FirstOrDefault((Func<NativeSlider, bool>)((NativeSlider s) => ((Object)s.gameObject).name == "ItemCountSlider"));
			if (val10 != null)
			{
				PendingSettingsStore.itemCount = (int)val10.Value;
			}
			NativeInput val11 = ((IEnumerable<NativeInput>)NativeInput.AllInstances).FirstOrDefault((Func<NativeInput, bool>)((NativeInput i) => ((Object)i.gameObject).name == "SeedInput"));
			if (val11 != null)
			{
				PendingSettingsStore.seedInput = val11.GetText();
			}
			NativeOption val12 = ((IEnumerable<NativeOption>)NativeOption.AllInstances).FirstOrDefault((Func<NativeOption, bool>)((NativeOption o) => ((Object)o.gameObject).name == "ResetOption"));
			PendingSettingsStore.resetPickups = ((val12 != null) ? val12.GetCurrentValue() : null) == "是";
			PendingSettingsStore.fullRandomMode = IsFullRandomEnabled();
			PendingSettingsStore.roomRandomMode = RoomRandomMode.IsPending;
			PendingSettingsStore.crestCurseEnabled = StartingAbilityPickerAPI.GetCrestCurseEnabled();
			PendingSettingsStore.forceCompletionDisplay = StartingAbilityPickerAPI.GetForceCompletionDisplay();
			NativeButton val13 = ((IEnumerable<NativeButton>)NativeButton.AllInstances).FirstOrDefault((Func<NativeButton, bool>)((NativeButton b) => ((Object)b.gameObject).name == "CategoryBtn1"));
			if (val13 != null)
			{
				PendingSettingsStore.allowDashRight = (PendingSettingsStore.allowDashLeft = val13.GetTitle() == "开");
			}
			NativeButton val14 = ((IEnumerable<NativeButton>)NativeButton.AllInstances).FirstOrDefault((Func<NativeButton, bool>)((NativeButton b) => ((Object)b.gameObject).name == "CategoryBtn2"));
			if (val14 != null)
			{
				PendingSettingsStore.allowHarpoonRight = (PendingSettingsStore.allowHarpoonLeft = val14.GetTitle() == "开");
			}
			NativeButton val15 = ((IEnumerable<NativeButton>)NativeButton.AllInstances).FirstOrDefault((Func<NativeButton, bool>)((NativeButton b) => ((Object)b.gameObject).name == "CategoryBtn3"));
			if (val15 != null)
			{
				PendingSettingsStore.allowFloatRight = (PendingSettingsStore.allowFloatLeft = val15.GetTitle() == "开");
			}
			NativeButton val16 = ((IEnumerable<NativeButton>)NativeButton.AllInstances).FirstOrDefault((Func<NativeButton, bool>)((NativeButton b) => ((Object)b.gameObject).name == "CategoryBtn4"));
			if (val16 != null)
			{
				PendingSettingsStore.allowWallJumpRight = (PendingSettingsStore.allowWallJumpLeft = val16.GetTitle() == "开");
			}
			NativeButton val17 = ((IEnumerable<NativeButton>)NativeButton.AllInstances).FirstOrDefault((Func<NativeButton, bool>)((NativeButton b) => ((Object)b.gameObject).name == "CategoryBtn5"));
			if (val17 != null)
			{
				PendingSettingsStore.allowHeal = val17.GetTitle() == "开";
			}
			NativeButton val18 = ((IEnumerable<NativeButton>)NativeButton.AllInstances).FirstOrDefault((Func<NativeButton, bool>)((NativeButton b) => ((Object)b.gameObject).name == "CrestTypeBtn"));
			PendingSettingsStore.crestRandomEnabled = ((val18 != null) ? val18.GetTitle() : null) == "开";
			NativeButton val19 = ((IEnumerable<NativeButton>)NativeButton.AllInstances).FirstOrDefault((Func<NativeButton, bool>)((NativeButton b) => ((Object)b.gameObject).name == "SkillTypeBtn"));
			PendingSettingsStore.skillItemRandomEnabled = ((val19 != null) ? val19.GetTitle() : null) == "开";
			NativeButton val20 = ((IEnumerable<NativeButton>)NativeButton.AllInstances).FirstOrDefault((Func<NativeButton, bool>)((NativeButton b) => ((Object)b.gameObject).name == "RelicTypeBtn"));
			PendingSettingsStore.relicRandomEnabled = ((val20 != null) ? val20.GetTitle() : null) == "开";
			NativeButton val21 = ((IEnumerable<NativeButton>)NativeButton.AllInstances).FirstOrDefault((Func<NativeButton, bool>)((NativeButton b) => ((Object)b.gameObject).name == "TrapBtn"));
			PendingSettingsStore.trapEnabled = ((val21 != null) ? val21.GetTitle() : null) == "开";
			NativeButton val22 = ((IEnumerable<NativeButton>)NativeButton.AllInstances).FirstOrDefault((Func<NativeButton, bool>)((NativeButton b) => ((Object)b.gameObject).name == "TrapMovementBtn"));
			PendingSettingsStore.trapMovementEnabled = ((val22 != null) ? val22.GetTitle() : null) == "开";
			NativeButton val23 = ((IEnumerable<NativeButton>)NativeButton.AllInstances).FirstOrDefault((Func<NativeButton, bool>)((NativeButton b) => ((Object)b.gameObject).name == "TrapDifficultyBtn"));
			if (val23 != null)
			{
				string title = val23.GetTitle();
				PendingSettingsStore.trapDifficulty = ((!(title == "初猎")) ? ((title == "专注") ? 1 : 2) : 0);
			}
			NativeButton val24 = ((IEnumerable<NativeButton>)NativeButton.AllInstances).FirstOrDefault((Func<NativeButton, bool>)((NativeButton b) => ((Object)b.gameObject).name == "RoomBtn"));
			PendingSettingsStore.sceneRandomEnabled = ((val24 != null) ? val24.GetTitle() : null) == "开";
			NativeButton val25 = ((IEnumerable<NativeButton>)NativeButton.AllInstances).FirstOrDefault((Func<NativeButton, bool>)((NativeButton b) => ((Object)b.gameObject).name == "ShowRoomNameBtn"));
			PendingSettingsStore.showSceneLabel = ((val25 != null) ? val25.GetTitle() : null) == "开";
			NativeButton val26 = ((IEnumerable<NativeButton>)NativeButton.AllInstances).FirstOrDefault((Func<NativeButton, bool>)((NativeButton b) => ((Object)b.gameObject).name == "ShowRoomSeedBtn"));
			PendingSettingsStore.showSeedLabel = ((val26 != null) ? val26.GetTitle() : null) == "开";
			NativeInput val27 = ((IEnumerable<NativeInput>)NativeInput.AllInstances).FirstOrDefault((Func<NativeInput, bool>)((NativeInput i) => ((Object)i.gameObject).name == "RoomSeedInput"));
			if (val27 != null && int.TryParse(val27.GetText(), out var result))
			{
				PendingSettingsStore.roomSeed = result;
			}
			NativeInput val28 = ((IEnumerable<NativeInput>)NativeInput.AllInstances).FirstOrDefault((Func<NativeInput, bool>)((NativeInput i) => ((Object)i.gameObject).name == "CurrencyFirstThresholdInput"));
			if (val28 != null && int.TryParse(val28.GetText(), out var result2))
			{
				PendingSettingsStore.currencyFirstThreshold = result2;
			}
			NativeInput val29 = ((IEnumerable<NativeInput>)NativeInput.AllInstances).FirstOrDefault((Func<NativeInput, bool>)((NativeInput i) => ((Object)i.gameObject).name == "CurrencySecondThresholdInput"));
			if (val29 != null && int.TryParse(val29.GetText(), out var result3))
			{
				PendingSettingsStore.currencySecondThreshold = result3;
			}
			NativeInput val30 = ((IEnumerable<NativeInput>)NativeInput.AllInstances).FirstOrDefault((Func<NativeInput, bool>)((NativeInput i) => ((Object)i.gameObject).name == "SilkSpearPityInput"));
			if (val30 != null && int.TryParse(val30.GetText(), out var result4))
			{
				PendingSettingsStore.silkSpearPityCount = result4;
			}
			NativeButton val31 = ((IEnumerable<NativeButton>)NativeButton.AllInstances).FirstOrDefault((Func<NativeButton, bool>)((NativeButton b) => ((Object)b.gameObject).name == "ItemBtn"));
			PendingSettingsStore.itemRandomEnabled = ((val31 != null) ? val31.GetTitle() : null) == "开";
			PendingSettingsStore.MarkAsStored();
		}

		private void Confirm()
		{
			CollectCurrentSettingsToStore();
			SkipToFirstAct.EnableSkip();
			UIManager.instance.StartNewGame(false, false);
			Hide();
		}

		private void StartGame(bool permaDeath)
		{
			CollectCurrentSettingsToStore();
			SkipToFirstAct.EnableSkip();
			UIManager.instance.StartNewGame(permaDeath, false);
			Hide();
		}

		private void UpdateSlidersVisibility()
		{
			bool flag = !StartingAbilityPickerAPI.GetSkillRandomMode();
			NativeSlider val = ((IEnumerable<NativeSlider>)NativeSlider.AllInstances).FirstOrDefault((Func<NativeSlider, bool>)((NativeSlider s) => ((Object)s.gameObject).name == "TotalSkillSlider"));
			if (val != null)
			{
				val.gameObject.SetActive(flag);
			}
			NativeSlider val2 = ((IEnumerable<NativeSlider>)NativeSlider.AllInstances).FirstOrDefault((Func<NativeSlider, bool>)((NativeSlider s) => ((Object)s.gameObject).name == "VSlider"));
			NativeSlider val3 = ((IEnumerable<NativeSlider>)NativeSlider.AllInstances).FirstOrDefault((Func<NativeSlider, bool>)((NativeSlider s) => ((Object)s.gameObject).name == "HSlider"));
			NativeSlider val4 = ((IEnumerable<NativeSlider>)NativeSlider.AllInstances).FirstOrDefault((Func<NativeSlider, bool>)((NativeSlider s) => ((Object)s.gameObject).name == "SSlider"));
			NativeSlider val5 = ((IEnumerable<NativeSlider>)NativeSlider.AllInstances).FirstOrDefault((Func<NativeSlider, bool>)((NativeSlider s) => ((Object)s.gameObject).name == "ASlider"));
			bool active = !flag;
			if (val2 != null)
			{
				val2.gameObject.SetActive(active);
			}
			if (val3 != null)
			{
				val3.gameObject.SetActive(active);
			}
			if (val4 != null)
			{
				val4.gameObject.SetActive(active);
			}
			if (val5 != null)
			{
				val5.gameObject.SetActive(active);
			}
		}

		private void SetSliderValue(string sliderName, Func<float> getter)
		{
			NativeSlider val = ((IEnumerable<NativeSlider>)NativeSlider.AllInstances).FirstOrDefault((Func<NativeSlider, bool>)((NativeSlider s) => ((Object)s.gameObject).name == sliderName));
			if (val != null)
			{
				val.Value = getter();
			}
		}

		private void SetOptionValue(string optName, Func<int> getter)
		{
			NativeOption val = ((IEnumerable<NativeOption>)NativeOption.AllInstances).FirstOrDefault((Func<NativeOption, bool>)((NativeOption o) => ((Object)o.gameObject).name == optName));
			if (val != null)
			{
				val.SetValueWithoutNotify(getter());
			}
		}

		private void SyncButtonState(string buttonName, bool isEnabled)
		{
			NativeButton val = ((IEnumerable<NativeButton>)NativeButton.AllInstances).FirstOrDefault((Func<NativeButton, bool>)((NativeButton b) => ((Object)b.gameObject).name == buttonName));
			if (val != null)
			{
				val.SetToggleIndex(isEnabled ? 1 : 0);
			}
		}

		public void RefreshAllValues()
		{
			SyncButtonState("RoomBtn", HKSilksong_RandomizerAPI.IsSceneRandomEnabled());
			SyncButtonState("ItemBtn", SilksongItemRandomizerAPI.IsEnabled());
			SyncButtonState("TrapBtn", SilksongItemRandomizerAPI.IsTrapEnabled());
			SyncButtonState("CrestCurseBtn", StartingAbilityPickerAPI.GetCrestCurseEnabled());
			SyncButtonState("FullRandomBtn", StartingAbilityPickerAPI.GetFullRandomMode());
			SyncButtonState("TrapMovementBtn", SilksongItemRandomizerAPI.IsTrapMovementEnabled());
			SyncButtonState("EnemyScaleRandomBtn", (bool)(Type.GetType("SilksongItemRandomizer.EnemyRandoAdjuster, SilksongItemRandomizer")?.GetProperty("ScaleRandomEnabled", BindingFlags.Static | BindingFlags.Public)?.GetValue(null) ?? ((object)false)));
			SyncButtonState("ShowRoomNameBtn", HKSilksong_RandomizerAPI.GetShowSceneLabel());
			SyncButtonState("ShowRoomSeedBtn", HKSilksong_RandomizerAPI.GetShowSeedOnScreen());
			SyncButtonState("CompletionBtn", StartingAbilityPickerAPI.GetForceCompletionDisplay());
			SyncButtonState("CrestTypeBtn", SilksongItemRandomizerAPI.IsCrestRandomEnabled());
			SyncButtonState("SkillTypeBtn", SilksongItemRandomizerAPI.IsSkillItemRandomEnabled());
			SyncButtonState("RelicTypeBtn", SilksongItemRandomizerAPI.IsRelicRandomEnabled());
			(bool, bool, bool) attackPermissions = StartingAbilityPickerAPI.GetAttackPermissions();
			NativeButton val = ((IEnumerable<NativeButton>)NativeButton.AllInstances).FirstOrDefault((Func<NativeButton, bool>)((NativeButton b) => ((Object)b.gameObject).name == "UpBtn"));
			if (val != null)
			{
				val.SetToggleIndex(attackPermissions.Item1 ? 1 : 0);
			}
			NativeButton val2 = ((IEnumerable<NativeButton>)NativeButton.AllInstances).FirstOrDefault((Func<NativeButton, bool>)((NativeButton b) => ((Object)b.gameObject).name == "LeftBtn"));
			if (val2 != null)
			{
				val2.SetToggleIndex(attackPermissions.Item2 ? 1 : 0);
			}
			NativeButton val3 = ((IEnumerable<NativeButton>)NativeButton.AllInstances).FirstOrDefault((Func<NativeButton, bool>)((NativeButton b) => ((Object)b.gameObject).name == "RightBtn"));
			if (val3 != null)
			{
				val3.SetToggleIndex(attackPermissions.Item3 ? 1 : 0);
			}
			NativeButton val4 = ((IEnumerable<NativeButton>)NativeButton.AllInstances).FirstOrDefault((Func<NativeButton, bool>)((NativeButton b) => ((Object)b.gameObject).name == "SilkHeartBtn"));
			if (val4 != null)
			{
				val4.SetToggleIndex(RoomRandomMode.IsPending ? 1 : 0);
			}
			SetSliderValue("ItemCountSlider", () => StartingAbilityPickerAPI.GetStartingItemCount());
			(int total, int v, int h, int s, int a) counts = StartingAbilityPickerAPI.GetSkillCounts();
			SetSliderValue("TotalSkillSlider", () => counts.total);
			SetSliderValue("VSlider", () => counts.v);
			SetSliderValue("HSlider", () => counts.h);
			SetSliderValue("SSlider", () => counts.s);
			SetSliderValue("ASlider", () => counts.a);
			SetOptionValue("SkillModeOption", () => StartingAbilityPickerAPI.GetSkillRandomMode() ? 1 : 0);
			SetOptionValue("ResetOption", () => StartingAbilityPickerAPI.GetResetSeedWorld() ? 1 : 0);
			NativeInput val5 = ((IEnumerable<NativeInput>)NativeInput.AllInstances).FirstOrDefault((Func<NativeInput, bool>)((NativeInput i) => ((Object)i.gameObject).name == "SeedInput"));
			if (val5 != null)
			{
				val5.SetText(StartingAbilityPickerAPI.GetSeed().ToString());
			}
			NativeInput val6 = ((IEnumerable<NativeInput>)NativeInput.AllInstances).FirstOrDefault((Func<NativeInput, bool>)((NativeInput i) => ((Object)i.gameObject).name == "RoomSeedInput"));
			if (val6 != null)
			{
				val6.SetText(HKSilksong_RandomizerAPI.GetCurrentRoomSeed().ToString());
			}
			(int, int) currencyThresholds = SilksongItemRandomizerAPI.GetCurrencyThresholds();
			NativeInput val7 = ((IEnumerable<NativeInput>)NativeInput.AllInstances).FirstOrDefault((Func<NativeInput, bool>)((NativeInput i) => ((Object)i.gameObject).name == "CurrencyFirstThresholdInput"));
			if (val7 != null)
			{
				val7.SetText(currencyThresholds.Item1.ToString());
			}
			NativeInput val8 = ((IEnumerable<NativeInput>)NativeInput.AllInstances).FirstOrDefault((Func<NativeInput, bool>)((NativeInput i) => ((Object)i.gameObject).name == "CurrencySecondThresholdInput"));
			if (val8 != null)
			{
				val8.SetText(currencyThresholds.Item2.ToString());
			}
			NativeInput val9 = ((IEnumerable<NativeInput>)NativeInput.AllInstances).FirstOrDefault((Func<NativeInput, bool>)((NativeInput i) => ((Object)i.gameObject).name == "SilkSpearPityInput"));
			if (val9 != null)
			{
				val9.SetText(SilksongItemRandomizerAPI.GetSilkSpearPityCount().ToString());
			}
			NativeLabel val10 = ((IEnumerable<NativeLabel>)NativeLabel.AllInstances).FirstOrDefault((Func<NativeLabel, bool>)((NativeLabel l) => ((Object)l.gameObject).name == "CurrentSeedValue"));
			if (val10 != null)
			{
				val10.SetText(SilksongItemRandomizerAPI.GetSeed().ToString());
			}
			NativeButton val11 = ((IEnumerable<NativeButton>)NativeButton.AllInstances).FirstOrDefault((Func<NativeButton, bool>)((NativeButton b) => ((Object)b.gameObject).name == "TrapDifficultyBtn"));
			if (val11 != null)
			{
				int trapDifficulty = SilksongItemRandomizerAPI.GetTrapDifficulty();
				string[] array = new string[3] { "初猎", "专注", "满溢" };
				if (trapDifficulty >= 0 && trapDifficulty < array.Length)
				{
					val11.SetTitle(array[trapDifficulty]);
				}
			}
			RefreshRepeatLimitInputs();
			UpdateFullRandomUI();
			UpdateCategoryButtonStates();
			UpdateSlidersVisibility();
		}

		public void RefreshPageList()
		{
			pageOrder = NativePage.AllInstances.Select((NativePage p) => ((Object)p.gameObject).name).ToList();
			Debug.Log((object)("[NativeConfigPanel] 页面列表刷新: " + string.Join(", ", pageOrder)));
		}

		public void ShowPage(string pageName)
		{
			if (!string.IsNullOrEmpty(pageName))
			{
				UIManagerEx.ShowPage(pageName);
				UpdatePageIndicator();
				Canvas.ForceUpdateCanvases();
			}
		}

		public void UpdatePageIndicator()
		{
			if (pageIndicator == null)
			{
				return;
			}
			NativePage? obj = ((IEnumerable<NativePage>)NativePage.AllInstances).FirstOrDefault((Func<NativePage, bool>)((NativePage p) => p.isShowing));
			string text = ((obj != null) ? ((Object)obj.gameObject).name : null);
			if (!string.IsNullOrEmpty(text) && pageOrder.Count != 0)
			{
				int num = pageOrder.IndexOf(text);
				if (num >= 0)
				{
					pageIndicator.SetText($"{num + 1}/{pageOrder.Count}");
					pageIndicator.gameObject.SetActive(pageOrder.Count > 1);
				}
			}
		}

		public void SwitchPage(int delta)
		{
			if (pageOrder.Count != 0)
			{
				NativePage? obj = ((IEnumerable<NativePage>)NativePage.AllInstances).FirstOrDefault((Func<NativePage, bool>)((NativePage p) => p.isShowing));
				string text = ((obj != null) ? ((Object)obj.gameObject).name : null);
				if (!string.IsNullOrEmpty(text))
				{
					int num = pageOrder.IndexOf(text);
					int index = (num + delta + pageOrder.Count) % pageOrder.Count;
					ShowPage(pageOrder[index]);
				}
			}
		}

		public void BindModeSelectButtons()
		{
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Expected O, but got Unknown
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Expected O, but got Unknown
			NativePage val = ((IEnumerable<NativePage>)NativePage.AllInstances).FirstOrDefault((Func<NativePage, bool>)((NativePage p) => ((Object)p.gameObject).name == "ModeSelect"));
			if (val == null)
			{
				return;
			}
			Transform transform = val.gameObject.transform;
			Transform obj = transform.Find("ClassicModeBtn");
			NativeButton val2 = ((obj != null) ? ((Component)obj).GetComponent<NativeButton>() : null);
			Transform obj2 = transform.Find("SteelModeBtn");
			NativeButton val3 = ((obj2 != null) ? ((Component)obj2).GetComponent<NativeButton>() : null);
			if (val2 != null)
			{
				val2.AddClickListener((UnityAction)delegate
				{
					StartGame(permaDeath: false);
				});
			}
			if (val3 != null)
			{
				val3.AddClickListener((UnityAction)delegate
				{
					StartGame(permaDeath: true);
				});
			}
		}

		public void Show(NativePage fromPage = null)
		{
			parentPage = fromPage;
			RefreshAllValues();
			root.SetActive(true);
			((MonoBehaviour)uiManager).StartCoroutine(FadeIn());
			if (pageOrder.Contains("Main"))
			{
				ShowPage("Main");
			}
			else if (pageOrder.Count > 0)
			{
				ShowPage(pageOrder[0]);
			}
		}

		public void Hide()
		{
			((MonoBehaviour)uiManager).StartCoroutine(FadeOut());
		}

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

		[IteratorStateMachine(typeof(<FadeOut>d__39))]
		private IEnumerator FadeOut()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <FadeOut>d__39(0)
			{
				<>4__this = this
			};
		}
	}
	public static class PendingSettingsStore
	{
		public static bool allowUpward;

		public static bool allowLeft;

		public static bool allowRight;

		public static bool skillMode;

		public static int skillTotal;

		public static int skillV;

		public static int skillH;

		public static int skillS;

		public static int skillA;

		public static int itemCount;

		public static string seedInput;

		public static bool resetPickups;

		public static bool fullRandomMode;

		public static bool roomRandomMode;

		public static bool crestCurseEnabled;

		public static bool forceCompletionDisplay;

		public static bool allowDashLeft;

		public static bool allowDashRight;

		public static bool allowHarpoonLeft;

		public static bool allowHarpoonRight;

		public static bool allowFloatLeft;

		public static bool allowFloatRight;

		public static bool allowWallJumpLeft;

		public static bool allowWallJumpRight;

		public static bool allowHeal;

		public static bool itemRandomEnabled;

		public static bool crestRandomEnabled;

		public static bool skillItemRandomEnabled;

		public static bool relicRandomEnabled;

		public static bool trapEnabled;

		public static bool trapMovementEnabled;

		public static int trapDifficulty;

		public static int currencyFirstThreshold;

		public static int currencySecondThreshold;

		public static int silkSpearPityCount;

		public static bool sceneRandomEnabled;

		public static bool showSceneLabel;

		public static bool showSeedLabel;

		public static int roomSeed;

		public static bool enemyRandomEnabled;

		public static bool skillTriggerEnabled;

		private static bool _hasPending;

		public static bool HasPending => _hasPending;

		public static void Clear()
		{
			_hasPending = false;
		}

		public static void MarkAsStored()
		{
			_hasPending = true;
		}
	}
	[HarmonyPatch]
	public static class SkipToFirstAct
	{
		[CompilerGenerated]
		private sealed class <SkipCutscenes>d__6 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			private GameManager <gm>5__1;

			private int <i>5__2;

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

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

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

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

			private bool MoveNext()
			{
				//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b1: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = null;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<gm>5__1 = GameManager.instance;
					if ((Object)(object)<gm>5__1 == (Object)null)
					{
						Debug.LogError((object)"[SkipToFirstAct] GameManager 不可用");
						return false;
					}
					<i>5__2 = 0;
					break;
				case 2:
					<>1__state = -1;
					<i>5__2++;
					break;
				}
				if (<i>5__2 < 5)
				{
					<gm>5__1.SkipCutscene();
					Debug.Log((object)$"[SkipToFirstAct] 第 {<i>5__2 + 1} 次 SkipCutscene");
					<>2__current = (object)new WaitForSeconds(0.2f);
					<>1__state = 2;
					return true;
				}
				Debug.Log((object)"[SkipToFirstAct] 跳过完成");
				if (!string.IsNullOrEmpty(_targetScene))
				{
					Debug.Log((object)("[SkipToFirstAct] 传送到 " + _targetScene));
					HKSilksong_RandomizerAPI.TeleportToScene(_targetScene, (string)null);
				}
				else
				{
					Debug.Log((object)"[SkipToFirstAct] 未指定目标场景，使用默认开局");
				}
				SceneManager.sceneLoaded -= OnSceneLoaded;
				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 static bool _shouldSkip;

		private static bool _skipTriggered;

		private static string _targetScene;

		public static void EnableSkip()
		{
			if (!_shouldSkip)
			{
				_shouldSkip = true;
				_skipTriggered = false;
				SceneManager.sceneLoaded += OnSceneLoaded;
				Debug.Log((object)"[SkipToFirstAct] 已启用跳过开场模式");
			}
		}

		public static void SetTargetScene(string sceneName)
		{
			_targetScene = sceneName;
			Debug.Log((object)("[SkipToFirstAct] 目标场景已设置为: " + _targetScene));
		}

		private static void OnSceneLoaded(Scene scene, LoadSceneMode mode)
		{
			if (_shouldSkip && !_skipTriggered && ((Scene)(ref scene)).name == "Opening_Sequence")
			{
				_skipTriggered = true;
				Debug.Log((object)"[SkipToFirstAct] 检测到开场动画，开始跳过...");
				((MonoBehaviour)GameManager.instance).StartCoroutine(SkipCutscenes());
			}
		}

		[IteratorStateMachine(typeof(<SkipCutscenes>d__6))]
		private static IEnumerator SkipCutscenes()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <SkipCutscenes>d__6(0);
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(GameManager), "SkipCutscene")]
		private static void Prefix_SkipCutscene()
		{
			Debug.Log((object)"[SkipToFirstAct] 原生 SkipCutscene 被调用");
		}
	}
}