using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using System.Text.RegularExpressions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using GlobalEnums;
using HarmonyLib;
using HutongGames.PlayMaker;
using HutongGames.PlayMaker.Actions;
using Microsoft.CodeAnalysis;
using Radiance.Behaviours.Common;
using Radiance.Behaviours.Fixed;
using Radiance.Behaviours.ImmortalLight;
using Radiance.Managers;
using Radiance.Patches;
using Radiance.Tools;
using Satchel;
using Satchel.Futils;
using TeamCherry.Localization;
using UnityEngine;
using UnityEngine.Audio;
using UnityEngine.Events;
using UnityEngine.SceneManagement;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("Radiance")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("0.2.1.0")]
[assembly: AssemblyInformationalVersion("0.2.1+91f3f6a9060da0e21b6ffbce8e7c13bd955dbf9d")]
[assembly: AssemblyProduct("Radiance")]
[assembly: AssemblyTitle("Radiance")]
[assembly: AssemblyMetadata("RepositoryUrl", "https://github.com/xieedechunniunai/Radiance")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.2.1.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

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

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace BepInEx
{
	[AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = false)]
	[Conditional("CodeGeneration")]
	internal sealed class BepInAutoPluginAttribute : Attribute
	{
		public BepInAutoPluginAttribute(string? id = null, string? name = null, string? version = null)
		{
		}
	}
}
namespace BepInEx.Preloader.Core.Patching
{
	[AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = false)]
	[Conditional("CodeGeneration")]
	internal sealed class PatcherAutoPluginAttribute : Attribute
	{
		public PatcherAutoPluginAttribute(string? id = null, string? name = null, string? version = null)
		{
		}
	}
}
namespace Satchel
{
	public static class FsmUtil
	{
		public static bool TryGetState(this PlayMakerFSM fsm, string stateName, out FsmState? state)
		{
			object obj;
			if (fsm == null)
			{
				obj = null;
			}
			else
			{
				Fsm fsm2 = fsm.Fsm;
				obj = ((fsm2 != null) ? fsm2.GetState(stateName) : null);
			}
			state = (FsmState?)obj;
			return state != null;
		}

		public static FsmState GetValidState(this PlayMakerFSM fsm, string stateName)
		{
			if (fsm.TryGetState(stateName, out FsmState state))
			{
				return state;
			}
			throw new ArgumentException("FSM \"" + ((fsm != null) ? fsm.FsmName : null) + "\" does not have state \"" + stateName + "\"");
		}

		public static FsmTransition? GetTransition(this FsmState state, string onEventName)
		{
			if (((state != null) ? state.Transitions : null) == null)
			{
				return null;
			}
			FsmTransition[] transitions = state.Transitions;
			foreach (FsmTransition val in transitions)
			{
				if (((val != null) ? val.EventName : null) == onEventName)
				{
					return val;
				}
			}
			return null;
		}

		public static FsmTransition? GetTransition(this PlayMakerFSM fsm, string fromStateName, string onEventName)
		{
			return fsm.GetValidState(fromStateName).GetTransition(onEventName);
		}

		public static void ChangeTransition(this FsmState state, string onEventName, string toStateName)
		{
			FsmTransition val = state.GetTransition(onEventName) ?? throw new ArgumentException("State \"" + state.Name + "\" does not have transition \"" + onEventName + "\"");
			val.ToState = toStateName;
			val.ToFsmState = state.Fsm.GetState(toStateName);
		}

		public static void ChangeTransition(this PlayMakerFSM fsm, string fromStateName, string onEventName, string toStateName)
		{
			fsm.GetValidState(fromStateName).ChangeTransition(onEventName, toStateName);
		}

		public static void RemoveTransition(this FsmState state, string onEventName)
		{
			string onEventName2 = onEventName;
			if (((state != null) ? state.Transitions : null) != null && state.Transitions.Length != 0)
			{
				state.Transitions = state.Transitions.Where((FsmTransition t) => ((t != null) ? t.EventName : null) != onEventName2).ToArray();
			}
		}

		public static void RemoveTransition(this PlayMakerFSM fsm, string fromStateName, string onEventName)
		{
			fsm.GetValidState(fromStateName).RemoveTransition(onEventName);
		}

		public static FsmStateAction GetAction(this FsmState state, int index)
		{
			return state.Actions[index];
		}

		public static FsmStateAction GetAction(this PlayMakerFSM fsm, string stateName, int index)
		{
			return fsm.GetValidState(stateName).GetAction(index);
		}

		public static T? GetAction<T>(this FsmState state, int index) where T : FsmStateAction
		{
			FsmStateAction action = state.GetAction(index);
			return (T)(object)((action is T) ? action : null);
		}

		public static T? GetAction<T>(this PlayMakerFSM fsm, string stateName, int index) where T : FsmStateAction
		{
			FsmStateAction action = fsm.GetAction(stateName, index);
			return (T)(object)((action is T) ? action : null);
		}

		public static void InsertAction(this FsmState state, FsmStateAction action, int index)
		{
			if (state == null || action == null)
			{
				return;
			}
			FsmStateAction[] array = state.Actions ?? Array.Empty<FsmStateAction>();
			index = Math.Clamp(index, 0, array.Length);
			List<FsmStateAction> list = new List<FsmStateAction>(array.Length + 1);
			for (int i = 0; i < array.Length; i++)
			{
				if (i == index)
				{
					list.Add(action);
				}
				list.Add(array[i]);
			}
			if (index == array.Length)
			{
				list.Add(action);
			}
			state.Actions = list.ToArray();
			action.Init(state);
		}

		public static void InsertAction(this PlayMakerFSM fsm, string stateName, FsmStateAction action, int index)
		{
			fsm.GetValidState(stateName).InsertAction(action, index);
		}

		public static void RemoveAction(this FsmState state, int index)
		{
			if (((state != null) ? state.Actions : null) != null && index >= 0 && index < state.Actions.Length)
			{
				List<FsmStateAction> list = state.Actions.ToList();
				list.RemoveAt(index);
				state.Actions = list.ToArray();
			}
		}

		public static void RemoveAction(this PlayMakerFSM fsm, string stateName, int index)
		{
			fsm.GetValidState(stateName).RemoveAction(index);
		}

		public static void AddCustomAction(this FsmState state, Action method)
		{
			CustomFsmAction action = new CustomFsmAction
			{
				method = method
			};
			FsmStateAction[] actions = state.Actions;
			state.InsertAction((FsmStateAction)(object)action, (actions != null) ? actions.Length : 0);
		}

		public static void AddCustomAction(this PlayMakerFSM fsm, string stateName, Action method)
		{
			fsm.GetValidState(stateName).AddCustomAction(method);
		}

		public static void InsertCustomAction(this FsmState state, Action method, int index)
		{
			state.InsertAction((FsmStateAction)(object)new CustomFsmAction
			{
				method = method
			}, index);
		}

		public static void InsertCustomAction(this PlayMakerFSM fsm, string stateName, Action method, int index)
		{
			fsm.GetValidState(stateName).InsertCustomAction(method, index);
		}

		public static void InsertCustomAction(this FsmState state, Action<FsmState> method, int index)
		{
			Action<FsmState> method2 = method;
			FsmState state2 = state;
			state2.InsertAction((FsmStateAction)(object)new CustomFsmAction
			{
				method = delegate
				{
					method2(state2);
				}
			}, index);
		}

		public static void InsertCustomAction(this PlayMakerFSM fsm, string stateName, Action<PlayMakerFSM> method, int index)
		{
			Action<PlayMakerFSM> method2 = method;
			PlayMakerFSM fsm2 = fsm;
			fsm2.GetValidState(stateName).InsertCustomAction((Action)delegate
			{
				method2(fsm2);
			}, index);
		}
	}
	public static class GameObjectUtils
	{
		public static T GetAddComponent<T>(this GameObject go) where T : Component
		{
			T val = go.GetComponent<T>();
			if ((Object)(object)val == (Object)null)
			{
				val = go.AddComponent<T>();
			}
			return val;
		}

		public static GameObject? FindGameObjectInChildren(this GameObject gameObject, string name, bool useBaseName = false)
		{
			if ((Object)(object)gameObject == (Object)null)
			{
				return null;
			}
			Transform[] componentsInChildren = gameObject.GetComponentsInChildren<Transform>(true);
			foreach (Transform val in componentsInChildren)
			{
				if (val.GetName(useBaseName) == name)
				{
					return ((Component)val).gameObject;
				}
			}
			return null;
		}

		public static void FindAllChildren(this GameObject go, List<GameObject> allGoList)
		{
			if (!((Object)(object)go == (Object)null) && allGoList != null)
			{
				for (int i = 0; i < go.transform.childCount; i++)
				{
					GameObject gameObject = ((Component)go.transform.GetChild(i)).gameObject;
					allGoList.Add(gameObject);
				}
				for (int j = 0; j < go.transform.childCount; j++)
				{
					((Component)go.transform.GetChild(j)).gameObject.FindAllChildren(allGoList);
				}
			}
		}

		public static List<GameObject> GetAllGameObjects(this Scene scene)
		{
			List<GameObject> list = new List<GameObject>();
			GameObject[] rootGameObjects = ((Scene)(ref scene)).GetRootGameObjects();
			foreach (GameObject val in rootGameObjects)
			{
				list.Add(val);
				val.FindAllChildren(list);
			}
			return list;
		}

		public static string GetName(this Transform transform, bool useBaseName = false)
		{
			return ((Component)transform).gameObject.GetName(useBaseName);
		}

		public static string GetName(this GameObject go, bool useBaseName = false)
		{
			string name = ((Object)go).name;
			if (!useBaseName)
			{
				return name;
			}
			name = name.ToLowerInvariant();
			name = name.Replace("(clone)", string.Empty).Trim();
			name = name.Replace("cln", string.Empty).Trim();
			name = Regex.Replace(name, "\\([0-9+]+\\)", string.Empty).Trim();
			name = Regex.Replace(name, "[0-9+]+$", string.Empty).Trim();
			return name.Replace("(clone)", string.Empty).Trim();
		}
	}
	public static class SceneUtils
	{
		public static Scene getCurrentScene()
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			return SceneManager.GetActiveScene();
		}
	}
}
namespace Satchel.Futils
{
	public class CustomFsmAction : FsmStateAction
	{
		public Action? method;

		public CustomFsmAction()
		{
		}

		public CustomFsmAction(Action method)
		{
			this.method = method;
		}

		public override void Reset()
		{
			method = null;
			((FsmStateAction)this).Reset();
		}

		public override void OnEnter()
		{
			method?.Invoke();
			((FsmStateAction)this).Finish();
		}
	}
	public static class FsmVariables
	{
		public static NamedVariable[]? GetVariables<T>(this PlayMakerFSM fsm) where T : NamedVariable, new()
		{
			if ((Object)(object)fsm == (Object)null)
			{
				return null;
			}
			FsmVariables fsmVariables = fsm.FsmVariables;
			Type typeFromHandle = typeof(T);
			if (typeFromHandle == typeof(FsmFloat))
			{
				return (NamedVariable[]?)(object)fsmVariables.FloatVariables;
			}
			if (typeFromHandle == typeof(FsmInt))
			{
				return (NamedVariable[]?)(object)fsmVariables.IntVariables;
			}
			if (typeFromHandle == typeof(FsmBool))
			{
				return (NamedVariable[]?)(object)fsmVariables.BoolVariables;
			}
			if (typeFromHandle == typeof(FsmString))
			{
				return (NamedVariable[]?)(object)fsmVariables.StringVariables;
			}
			if (typeFromHandle == typeof(FsmVector2))
			{
				return (NamedVariable[]?)(object)fsmVariables.Vector2Variables;
			}
			if (typeFromHandle == typeof(FsmVector3))
			{
				return (NamedVariable[]?)(object)fsmVariables.Vector3Variables;
			}
			if (typeFromHandle == typeof(FsmColor))
			{
				return (NamedVariable[]?)(object)fsmVariables.ColorVariables;
			}
			if (typeFromHandle == typeof(FsmRect))
			{
				return (NamedVariable[]?)(object)fsmVariables.RectVariables;
			}
			if (typeFromHandle == typeof(FsmQuaternion))
			{
				return (NamedVariable[]?)(object)fsmVariables.QuaternionVariables;
			}
			if (typeFromHandle == typeof(FsmGameObject))
			{
				return (NamedVariable[]?)(object)fsmVariables.GameObjectVariables;
			}
			if (typeFromHandle == typeof(FsmObject))
			{
				return (NamedVariable[]?)(object)fsmVariables.ObjectVariables;
			}
			return null;
		}

		public static void SetVariables<T>(this PlayMakerFSM fsm, NamedVariable[] namedVariables) where T : NamedVariable, new()
		{
			if ((Object)(object)fsm == (Object)null || namedVariables == null)
			{
				return;
			}
			FsmVariables fsmVariables = fsm.FsmVariables;
			Type typeFromHandle = typeof(T);
			if (typeFromHandle == typeof(FsmFloat))
			{
				fsmVariables.FloatVariables = Array.ConvertAll(namedVariables, (Converter<NamedVariable, FsmFloat>)((NamedVariable v) => (FsmFloat)v));
			}
			else if (typeFromHandle == typeof(FsmInt))
			{
				fsmVariables.IntVariables = Array.ConvertAll(namedVariables, (Converter<NamedVariable, FsmInt>)((NamedVariable v) => (FsmInt)v));
			}
			else if (typeFromHandle == typeof(FsmBool))
			{
				fsmVariables.BoolVariables = Array.ConvertAll(namedVariables, (Converter<NamedVariable, FsmBool>)((NamedVariable v) => (FsmBool)v));
			}
			else if (typeFromHandle == typeof(FsmString))
			{
				fsmVariables.StringVariables = Array.ConvertAll(namedVariables, (Converter<NamedVariable, FsmString>)((NamedVariable v) => (FsmString)v));
			}
			else if (typeFromHandle == typeof(FsmVector2))
			{
				fsmVariables.Vector2Variables = Array.ConvertAll(namedVariables, (Converter<NamedVariable, FsmVector2>)((NamedVariable v) => (FsmVector2)v));
			}
			else if (typeFromHandle == typeof(FsmVector3))
			{
				fsmVariables.Vector3Variables = Array.ConvertAll(namedVariables, (Converter<NamedVariable, FsmVector3>)((NamedVariable v) => (FsmVector3)v));
			}
			else if (typeFromHandle == typeof(FsmColor))
			{
				fsmVariables.ColorVariables = Array.ConvertAll(namedVariables, (Converter<NamedVariable, FsmColor>)((NamedVariable v) => (FsmColor)v));
			}
			else if (typeFromHandle == typeof(FsmRect))
			{
				fsmVariables.RectVariables = Array.ConvertAll(namedVariables, (Converter<NamedVariable, FsmRect>)((NamedVariable v) => (FsmRect)v));
			}
			else if (typeFromHandle == typeof(FsmQuaternion))
			{
				fsmVariables.QuaternionVariables = Array.ConvertAll(namedVariables, (Converter<NamedVariable, FsmQuaternion>)((NamedVariable v) => (FsmQuaternion)v));
			}
			else if (typeFromHandle == typeof(FsmGameObject))
			{
				fsmVariables.GameObjectVariables = Array.ConvertAll(namedVariables, (Converter<NamedVariable, FsmGameObject>)((NamedVariable v) => (FsmGameObject)v));
			}
			else if (typeFromHandle == typeof(FsmObject))
			{
				fsmVariables.ObjectVariables = Array.ConvertAll(namedVariables, (Converter<NamedVariable, FsmObject>)((NamedVariable v) => (FsmObject)v));
			}
		}

		public static void AddVariable<T>(this PlayMakerFSM fsm, string name) where T : NamedVariable, new()
		{
			fsm.AddGetVariable<T>(name);
		}

		public static T? AddGetVariable<T>(this PlayMakerFSM fsm, string name) where T : NamedVariable, new()
		{
			NamedVariable[] variables = fsm.GetVariables<T>();
			if (variables == null)
			{
				return default(T);
			}
			List<T> list = new List<T>(Array.ConvertAll(variables, (NamedVariable v) => (T)(object)v));
			T val = new T();
			((NamedVariable)val).Name = name;
			T val2 = val;
			list.Add(val2);
			fsm.SetVariables<T>(Array.ConvertAll(list.ToArray(), (T v) => (NamedVariable)(object)v));
			return val2;
		}

		public static T? GetVariable<T>(this PlayMakerFSM fsm, string name) where T : NamedVariable, new()
		{
			NamedVariable[] variables = fsm.GetVariables<T>();
			if (variables == null)
			{
				return default(T);
			}
			NamedVariable[] array = variables;
			foreach (NamedVariable val in array)
			{
				T val2 = (T)(object)((val is T) ? val : null);
				if (val2 != null && ((NamedVariable)val2).Name == name)
				{
					return val2;
				}
			}
			return default(T);
		}
	}
}
namespace Radiance
{
	[BepInPlugin("io.github.xieedechunniunai.radiance", "Radiance", "0.2.1")]
	public class RadiancePlugin : BaseUnityPlugin
	{
		private Harmony? _harmony;

		private GameObject? _radianceManager;

		public const string Id = "io.github.xieedechunniunai.radiance";

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

		public static string Name => "Radiance";

		public static string Version => "0.2.1";

		private void Awake()
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Expected O, but got Unknown
			Instance = this;
			Log.Init(((BaseUnityPlugin)this).Logger);
			Configuration.Init(((BaseUnityPlugin)this).Config);
			_harmony = new Harmony("io.github.xieedechunniunai.radiance");
			_harmony.PatchAll(typeof(FsmFixPatches));
			_harmony.PatchAll(typeof(GodfinderIconPatches));
			_harmony.PatchAll(typeof(RadiancePatches));
			_harmony.PatchAll(typeof(MemoryScenePatches));
			_harmony.PatchAll(typeof(SceneTransitionPatches));
			_harmony.PatchAll(typeof(Tk2dCollectionPatches));
			_harmony.PatchAll(typeof(RadiantOrbFixPatches));
			Log.Info("Harmony patches applied");
			Configuration.EnableMod.SettingChanged += OnRuntimeFeatureSettingChanged;
			Configuration.EnableImmortalLight.SettingChanged += OnRuntimeFeatureSettingChanged;
			Configuration.EnableVanillaRadianceFix.SettingChanged += OnRuntimeFeatureSettingChanged;
			SceneManager.activeSceneChanged += OnSceneChange;
			Log.InfoAlways("Plugin " + Name + " (io.github.xieedechunniunai.radiance) has loaded!");
		}

		private void OnRuntimeFeatureSettingChanged(object sender, EventArgs e)
		{
			RadiancePatches.RefreshFeatureBehavioursInScene();
		}

		private void OnSceneChange(Scene oldScene, Scene newScene)
		{
			if (((Scene)(ref oldScene)).name == "Menu_Title")
			{
				CreateManager();
			}
		}

		private void CreateManager()
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Expected O, but got Unknown
			_radianceManager = GameObject.Find("RadianceManager");
			if ((Object)(object)_radianceManager == (Object)null)
			{
				_radianceManager = new GameObject("RadianceManager");
				Object.DontDestroyOnLoad((Object)(object)_radianceManager);
				AssetManager assetManager = _radianceManager.AddComponent<AssetManager>();
				_radianceManager.AddComponent<RadianceSceneManager>();
				_radianceManager.AddComponent<ConfigUI>();
				Log.Info("Created persistent RadianceManager");
				((MonoBehaviour)this).StartCoroutine(assetManager.PreloadAllAssets());
			}
			else
			{
				Log.Info("Found existing persistent RadianceManager");
			}
		}

		private void OnDestroy()
		{
			if (Configuration.IsInitialized)
			{
				Configuration.EnableMod.SettingChanged -= OnRuntimeFeatureSettingChanged;
				Configuration.EnableImmortalLight.SettingChanged -= OnRuntimeFeatureSettingChanged;
				Configuration.EnableVanillaRadianceFix.SettingChanged -= OnRuntimeFeatureSettingChanged;
			}
			SceneManager.activeSceneChanged -= OnSceneChange;
		}
	}
	internal sealed class ConfigUI : MonoBehaviour
	{
		private bool _showGui;

		private Vector2 _scrollPosition;

		private Rect _windowRect = new Rect(20f, 20f, 480f, 420f);

		private readonly Dictionary<string, string> _texts = new Dictionary<string, string>
		{
			{ "window_title_cn", "Radiance 配置面板" },
			{ "window_title_en", "Radiance Config Panel" },
			{ "language_cn", "语言" },
			{ "language_en", "Language" },
			{ "enable_mod_cn", "模组总开关" },
			{ "enable_mod_en", "Enable Mod" },
			{ "enable_mod_desc_cn", "启用或禁用整个 Radiance 模组" },
			{ "enable_mod_desc_en", "Enable or disable the entire Radiance mod" },
			{ "enable_immortal_cn", "启用永恒之光" },
			{ "enable_immortal_en", "Enable ImmortalLight" },
			{ "enable_immortal_desc_cn", "一个强大的辐光mod" },
			{ "enable_immortal_desc_en", "A powerful Radiance mod" },
			{ "enable_vanilla_fix_cn", "修复原版辐光" },
			{ "enable_vanilla_fix_en", "Fix Vanilla Radiance" },
			{ "enable_vanilla_fix_desc_cn", "光球消散后仍造成伤害、P4动画过渡期受伤BUG修复" },
			{ "enable_vanilla_fix_desc_en", "Orb damage after dissipate, hit during Final Impact transition, etc." },
			{ "enable_shader_compat_cn", "Shader 兼容" },
			{ "enable_shader_compat_en", "Shader Compatibility" },
			{ "enable_shader_compat_desc_cn", "HK1 资源运行时 shader 修复，关闭 Mac 可能失效" },
			{ "enable_shader_compat_desc_en", "Runtime fix for HK1 shaders. Off may break on Mac" },
			{ "enable_collection_namespace_cn", "图集命名空间" },
			{ "enable_collection_namespace_en", "Collection Namespace" },
			{ "enable_collection_namespace_desc_cn", "为 Patchwork 皮肤 mod 隔离 tk2d 图集" },
			{ "enable_collection_namespace_desc_en", "Isolate tk2d collections for Patchwork skin mod" },
			{ "enable_compat_diagnostics_cn", "兼容诊断日志" },
			{ "enable_compat_diagnostics_en", "Compatibility Diagnostics" },
			{ "enable_compat_diagnostics_desc_cn", "输出 shader/皮肤兼容详细日志（调试用）" },
			{ "enable_compat_diagnostics_desc_en", "Verbose logs for shader/skin compatibility (debug)" },
			{ "apply_cn", "应用并保存" },
			{ "apply_en", "Apply & Save" },
			{ "reset_cn", "恢复默认值" },
			{ "reset_en", "Reset Defaults" },
			{ "close_cn", "关闭面板" },
			{ "close_en", "Close Panel" },
			{ "tip_cn", "打开/关闭配置面板" },
			{ "tip_en", "Open/close config panel" },
			{ "config_key_cn", "快捷键" },
			{ "config_key_en", "Hotkey" }
		};

		private void Update()
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			if (Configuration.IsInitialized && Input.GetKeyDown(Configuration.GetConfigPanelKeyCode()))
			{
				_showGui = !_showGui;
			}
		}

		private void OnGUI()
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Expected O, but got Unknown
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			if (_showGui && Configuration.IsInitialized)
			{
				_windowRect = GUI.Window(((Object)this).GetInstanceID(), _windowRect, new WindowFunction(DrawWindow), GetText("window_title"));
			}
		}

		private void DrawWindow(int windowId)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f0: Unknown result type (might be due to invalid IL or missing references)
			_scrollPosition = GUILayout.BeginScrollView(_scrollPosition, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(300f) });
			DrawLanguageSwitch();
			GUILayout.Space(8f);
			DrawToggleRow(GetText("enable_mod"), GetText("enable_mod_desc"), Configuration.EnableMod);
			DrawToggleRow(GetText("enable_immortal"), GetText("enable_immortal_desc"), Configuration.EnableImmortalLight);
			DrawToggleRow(GetText("enable_vanilla_fix"), GetText("enable_vanilla_fix_desc"), Configuration.EnableVanillaRadianceFix);
			DrawToggleRow(GetText("enable_shader_compat"), GetText("enable_shader_compat_desc"), Configuration.EnableShaderCompatFix);
			DrawToggleRow(GetText("enable_collection_namespace"), GetText("enable_collection_namespace_desc"), Configuration.EnableCollectionNamespace);
			DrawToggleRow(GetText("enable_compat_diagnostics"), GetText("enable_compat_diagnostics_desc"), Configuration.EnableCompatDiagnostics);
			GUILayout.Space(8f);
			DrawConfigKeyRow();
			GUILayout.Space(10f);
			GUILayout.Label(GetText("tip") + ": " + (Configuration.ConfigPanelKey?.Value ?? "F6"), Array.Empty<GUILayoutOption>());
			GUILayout.EndScrollView();
			GUILayout.Space(8f);
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			if (GUILayout.Button(GetText("apply"), Array.Empty<GUILayoutOption>()))
			{
				ApplyAndSave();
			}
			if (GUILayout.Button(GetText("reset"), Array.Empty<GUILayoutOption>()))
			{
				ResetToDefaults();
			}
			if (GUILayout.Button(GetText("close"), Array.Empty<GUILayoutOption>()))
			{
				_showGui = false;
			}
			GUILayout.EndHorizontal();
			GUI.DragWindow(new Rect(0f, 0f, 10000f, 24f));
		}

		private void DrawLanguageSwitch()
		{
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			GUILayout.Label(GetText("language"), (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(80f) });
			bool value = Configuration.UseEnglish.Value;
			if (GUILayout.Button("中文", value ? GUI.skin.button : GUI.skin.box, Array.Empty<GUILayoutOption>()))
			{
				Configuration.UseEnglish.Value = false;
			}
			if (GUILayout.Button("ENGLISH", value ? GUI.skin.box : GUI.skin.button, Array.Empty<GUILayoutOption>()))
			{
				Configuration.UseEnglish.Value = true;
			}
			GUILayout.EndHorizontal();
		}

		private static void DrawToggleRow(string label, string? description, ConfigEntry<bool> entry)
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			bool flag = GUILayout.Toggle(entry.Value, label, Array.Empty<GUILayoutOption>());
			if (flag != entry.Value)
			{
				entry.Value = flag;
			}
			if (!string.IsNullOrEmpty(description))
			{
				Color color = GUI.color;
				GUI.color = new Color(0.7f, 0.7f, 0.7f);
				GUILayout.Label(description, GUI.skin.label, Array.Empty<GUILayoutOption>());
				GUI.color = color;
			}
		}

		private void DrawConfigKeyRow()
		{
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			GUILayout.Label(GetText("config_key"), (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(80f) });
			string text = GUILayout.TextField(Configuration.ConfigPanelKey?.Value ?? "F6", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(80f) });
			if (!string.IsNullOrWhiteSpace(text) && !string.Equals(text, Configuration.ConfigPanelKey?.Value, StringComparison.Ordinal))
			{
				Configuration.ConfigPanelKey.Value = text.Trim();
			}
			GUILayout.EndHorizontal();
		}

		private void ApplyAndSave()
		{
			try
			{
				RadiancePlugin? instance = RadiancePlugin.Instance;
				if (instance != null)
				{
					((BaseUnityPlugin)instance).Config.Save();
				}
				Log.InfoAlways("[ConfigUI] Applied and saved configuration.");
			}
			catch (Exception ex)
			{
				Log.Error("[ConfigUI] Failed to apply config: " + ex.Message);
			}
		}

		private void ResetToDefaults()
		{
			try
			{
				Configuration.ResetToDefaults();
				RadiancePlugin? instance = RadiancePlugin.Instance;
				if (instance != null)
				{
					((BaseUnityPlugin)instance).Config.Save();
				}
				Log.InfoAlways("[ConfigUI] Reset configuration to defaults.");
			}
			catch (Exception ex)
			{
				Log.Error("[ConfigUI] Failed to reset config: " + ex.Message);
			}
		}

		private string GetText(string key)
		{
			string text = (Configuration.UseEnglish.Value ? "_en" : "_cn");
			string value;
			return _texts.TryGetValue(key + text, out value) ? value : key;
		}
	}
	internal static class Configuration
	{
		public static bool IsInitialized { get; private set; }

		public static ConfigEntry<bool> EnableMod { get; private set; }

		public static ConfigEntry<bool> UseEnglish { get; private set; }

		public static ConfigEntry<bool> EnableImmortalLight { get; private set; }

		public static ConfigEntry<bool> EnableVanillaRadianceFix { get; private set; }

		public static ConfigEntry<bool> EnableShaderCompatFix { get; private set; }

		public static ConfigEntry<bool> EnableCollectionNamespace { get; private set; }

		public static ConfigEntry<bool> EnableCompatDiagnostics { get; private set; }

		public static ConfigEntry<string> ConfigPanelKey { get; private set; }

		public static bool IsModEnabled => IsInitialized && EnableMod.Value;

		public static bool IsImmortalLightEnabled => IsModEnabled && EnableImmortalLight.Value;

		public static bool IsVanillaRadianceFixEnabled => IsModEnabled && EnableVanillaRadianceFix.Value;

		public static bool IsShaderCompatEnabled => IsModEnabled && EnableShaderCompatFix.Value;

		public static bool IsCollectionNamespaceEnabled => IsModEnabled && EnableCollectionNamespace.Value;

		public static bool IsCompatDiagnosticsEnabled => IsModEnabled && EnableCompatDiagnostics.Value;

		public static void Init(ConfigFile config)
		{
			if (!IsInitialized)
			{
				EnableMod = config.Bind<bool>("General", "EnableMod", true, "[EN] Master switch: enable or disable the entire Radiance mod.\n[中] 模组总开关：启用或禁用整个 Radiance 模组。");
				EnableImmortalLight = config.Bind<bool>("Features", "EnableImmortalLight", false, "[EN] Enable ImmortalLight content: Belltown entry point and custom GG_Radiance story flow.\n[中] 永恒之光内容：从 Belltown 进入入口及自定义剧情流程。");
				EnableVanillaRadianceFix = config.Bind<bool>("Features", "EnableVanillaRadianceFix", true, "[EN] Fix vanilla Absolute Radiance bugs: orphan orb damage after dissipate, getting hit during Death Ready→Final Impact transition.\n[中] 修复原版无上辐光 bug：Orb 消散后仍造成伤害、Death Ready 到 Final Impact 过渡期受伤等。");
				EnableShaderCompatFix = config.Bind<bool>("Compatibility", "EnableShaderCompatFix", true, "[EN] Runtime shader compatibility for HK1 assets. Disable to use original shaders (may break on Mac).\n[中] HK1 资源的运行时 shader 兼容。关闭则使用原版 shader（Mac 可能失效）。");
				EnableCollectionNamespace = config.Bind<bool>("Compatibility", "EnableCollectionNamespace", true, "[EN] Rename tk2d collections with (HK1) suffix for Patchwork skin mod compatibility.\n[中] 为 tk2d 图集添加 (HK1) 后缀，以兼容 Patchwork 皮肤 mod。");
				EnableCompatDiagnostics = config.Bind<bool>("Compatibility", "EnableCompatDiagnostics", false, "[EN] Emit verbose logs for shader and skin compatibility (for debugging).\n[中] 输出 shader/皮肤兼容相关的详细日志（用于调试）。");
				ConfigPanelKey = config.Bind<string>("UI", "ConfigPanelKey", "F6", "[EN] Hotkey to open/close the in-game config panel.\n[中] 打开/关闭配置面板的快捷键。");
				UseEnglish = config.Bind<bool>("UI", "UseEnglish", false, "[EN] Use English in the in-game config panel.\n[中] 配置面板使用英文显示。");
				IsInitialized = true;
			}
		}

		public static void ResetToDefaults()
		{
			if (IsInitialized)
			{
				EnableMod.Value = (bool)((ConfigEntryBase)EnableMod).DefaultValue;
				UseEnglish.Value = (bool)((ConfigEntryBase)UseEnglish).DefaultValue;
				EnableImmortalLight.Value = (bool)((ConfigEntryBase)EnableImmortalLight).DefaultValue;
				EnableVanillaRadianceFix.Value = (bool)((ConfigEntryBase)EnableVanillaRadianceFix).DefaultValue;
				EnableShaderCompatFix.Value = (bool)((ConfigEntryBase)EnableShaderCompatFix).DefaultValue;
				EnableCollectionNamespace.Value = (bool)((ConfigEntryBase)EnableCollectionNamespace).DefaultValue;
				EnableCompatDiagnostics.Value = (bool)((ConfigEntryBase)EnableCompatDiagnostics).DefaultValue;
				ConfigPanelKey.Value = (string)((ConfigEntryBase)ConfigPanelKey).DefaultValue;
			}
		}

		public static KeyCode GetConfigPanelKeyCode()
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			if (!IsInitialized || string.IsNullOrWhiteSpace(ConfigPanelKey.Value))
			{
				return (KeyCode)287;
			}
			if (Enum.TryParse<KeyCode>(ConfigPanelKey.Value.Trim(), ignoreCase: true, out KeyCode result))
			{
				return result;
			}
			return (KeyCode)287;
		}
	}
}
namespace Radiance.Tools
{
	public static class FsmAnalyzer
	{
		private static readonly string DefaultOutputDir = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "BepInEx", "plugins", "Radiance", "temp");

		public static void AnalyzeAllFsms(GameObject gameObject, string? outputDir = null)
		{
			if ((Object)(object)gameObject == (Object)null)
			{
				Log.Error("[FsmAnalyzer] GameObject 为空");
				return;
			}
			string text = outputDir ?? DefaultOutputDir;
			Directory.CreateDirectory(text);
			PlayMakerFSM[] components = gameObject.GetComponents<PlayMakerFSM>();
			Log.Info($"[FsmAnalyzer] 开始分析 {((Object)gameObject).name} 的 {components.Length} 个 FSM");
			string text2 = DateTime.Now.ToString("yyyy-MM-dd_HH-mm-ss");
			string text3 = SanitizeFileName(((Object)gameObject).name);
			PlayMakerFSM[] array = components;
			foreach (PlayMakerFSM val in array)
			{
				string text4 = SanitizeFileName(val.FsmName);
				string text5 = text3 + "_" + text4 + "_" + text2 + ".txt";
				string outputPath = Path.Combine(text, text5);
				WriteFsmReport(val, outputPath);
				Log.Info("[FsmAnalyzer] 已输出: " + text5);
			}
			string outputPath2 = Path.Combine(text, text3 + "_Summary_" + text2 + ".txt");
			WriteSummaryReport(gameObject, components, outputPath2);
			Log.Info("[FsmAnalyzer] 已输出汇总: " + text3 + "_Summary_" + text2 + ".txt");
		}

		public static void WriteFsmReport(PlayMakerFSM fsm, string outputPath)
		{
			//IL_06a6: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)fsm == (Object)null)
			{
				return;
			}
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.AppendLine("================================================================================");
			stringBuilder.AppendLine("FSM 报告: " + fsm.FsmName);
			stringBuilder.AppendLine("GameObject: " + ((Object)((Component)fsm).gameObject).name);
			stringBuilder.AppendLine("路径: " + GetGameObjectPath(((Component)fsm).gameObject));
			stringBuilder.AppendLine($"生成时间: {DateTime.Now:yyyy-MM-dd HH:mm:ss}");
			stringBuilder.AppendLine("================================================================================");
			stringBuilder.AppendLine("当前状态: " + fsm.ActiveStateName);
			stringBuilder.AppendLine("起始状态: " + fsm.Fsm.StartState);
			FsmState[] fsmStates = fsm.FsmStates;
			stringBuilder.AppendLine($"\n--- 所有状态 ({fsmStates.Length}个) ---");
			FsmState[] array = fsmStates;
			foreach (FsmState val in array)
			{
				stringBuilder.AppendLine("  - " + val.Name);
			}
			FsmEvent[] fsmEvents = fsm.FsmEvents;
			stringBuilder.AppendLine($"\n--- 所有事件 ({fsmEvents.Length}个) ---");
			FsmEvent[] array2 = fsmEvents;
			foreach (FsmEvent val2 in array2)
			{
				stringBuilder.AppendLine($"  - {val2.Name} (IsGlobal: {val2.IsGlobal})");
			}
			FsmTransition[] fsmGlobalTransitions = fsm.FsmGlobalTransitions;
			stringBuilder.AppendLine($"\n--- 全局转换 ({fsmGlobalTransitions.Length}个) ---");
			FsmTransition[] array3 = fsmGlobalTransitions;
			foreach (FsmTransition val3 in array3)
			{
				FsmEvent fsmEvent = val3.FsmEvent;
				stringBuilder.AppendLine("  " + ((fsmEvent != null) ? fsmEvent.Name : null) + " -> " + val3.toState);
			}
			stringBuilder.AppendLine("\n================================================================================");
			stringBuilder.AppendLine("各状态详情");
			stringBuilder.AppendLine("================================================================================");
			FsmState[] array4 = fsmStates;
			foreach (FsmState val4 in array4)
			{
				stringBuilder.AppendLine("\n【状态: " + val4.Name + "】");
				stringBuilder.AppendLine("  转换:");
				if (val4.Transitions != null && val4.Transitions.Length != 0)
				{
					FsmTransition[] transitions = val4.Transitions;
					foreach (FsmTransition val5 in transitions)
					{
						FsmEvent fsmEvent2 = val5.FsmEvent;
						stringBuilder.AppendLine("    " + (((fsmEvent2 != null) ? fsmEvent2.Name : null) ?? "(null)") + " -> " + val5.toState);
					}
				}
				else
				{
					stringBuilder.AppendLine("    (无转换)");
				}
				FsmStateAction[] actions = val4.Actions;
				stringBuilder.AppendLine($"  动作 ({((actions != null) ? actions.Length : 0)}个):");
				if (val4.Actions != null && val4.Actions.Length != 0)
				{
					for (int n = 0; n < val4.Actions.Length; n++)
					{
						FsmStateAction val6 = val4.Actions[n];
						if (val6 == null)
						{
							stringBuilder.AppendLine($"    [{n}] (null)");
							continue;
						}
						stringBuilder.AppendLine($"    [{n}] {((object)val6).GetType().Name}");
						AnalyzeActionVariables(stringBuilder, val6, n);
					}
				}
				else
				{
					stringBuilder.AppendLine("    (无动作)");
				}
			}
			FsmVariables fsmVariables = fsm.FsmVariables;
			stringBuilder.AppendLine("\n================================================================================");
			stringBuilder.AppendLine("FSM 变量");
			stringBuilder.AppendLine("================================================================================");
			stringBuilder.AppendLine($"Bool: {fsmVariables.BoolVariables.Length}, Int: {fsmVariables.IntVariables.Length}, Float: {fsmVariables.FloatVariables.Length}, String: {fsmVariables.StringVariables.Length}");
			stringBuilder.AppendLine($"GameObject: {fsmVariables.GameObjectVariables.Length}, Object: {fsmVariables.ObjectVariables.Length}, Vector3: {fsmVariables.Vector3Variables.Length}");
			stringBuilder.AppendLine("\n  Float 变量:");
			FsmFloat[] floatVariables = fsmVariables.FloatVariables;
			foreach (FsmFloat val7 in floatVariables)
			{
				stringBuilder.AppendLine($"    {((NamedVariable)val7).Name} = {val7.Value}");
			}
			stringBuilder.AppendLine("\n  Bool 变量:");
			FsmBool[] boolVariables = fsmVariables.BoolVariables;
			foreach (FsmBool val8 in boolVariables)
			{
				stringBuilder.AppendLine($"    {((NamedVariable)val8).Name} = {val8.Value}");
			}
			stringBuilder.AppendLine("\n  Int 变量:");
			FsmInt[] intVariables = fsmVariables.IntVariables;
			foreach (FsmInt val9 in intVariables)
			{
				stringBuilder.AppendLine($"    {((NamedVariable)val9).Name} = {val9.Value}");
			}
			stringBuilder.AppendLine("\n  String 变量:");
			FsmString[] stringVariables = fsmVariables.StringVariables;
			foreach (FsmString val10 in stringVariables)
			{
				stringBuilder.AppendLine("    " + ((NamedVariable)val10).Name + " = \"" + val10.Value + "\"");
			}
			stringBuilder.AppendLine("\n  GameObject 变量:");
			FsmGameObject[] gameObjectVariables = fsmVariables.GameObjectVariables;
			foreach (FsmGameObject val11 in gameObjectVariables)
			{
				string text = (((Object)(object)val11.Value != (Object)null) ? ((Object)val11.Value).name : "(null)");
				stringBuilder.AppendLine("    " + ((NamedVariable)val11).Name + " = " + text);
			}
			stringBuilder.AppendLine("\n  Vector3 变量:");
			FsmVector3[] vector3Variables = fsmVariables.Vector3Variables;
			foreach (FsmVector3 val12 in vector3Variables)
			{
				stringBuilder.AppendLine($"    {((NamedVariable)val12).Name} = {val12.Value}");
			}
			Directory.CreateDirectory(Path.GetDirectoryName(outputPath) ?? ".");
			File.WriteAllText(outputPath, stringBuilder.ToString(), Encoding.UTF8);
		}

		private static void WriteSummaryReport(GameObject gameObject, PlayMakerFSM[] fsms, string outputPath)
		{
			GameObject gameObject2 = gameObject;
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.AppendLine("================================================================================");
			stringBuilder.AppendLine("FSM 汇总报告: " + ((Object)gameObject2).name);
			stringBuilder.AppendLine("路径: " + GetGameObjectPath(gameObject2));
			stringBuilder.AppendLine($"生成时间: {DateTime.Now:yyyy-MM-dd HH:mm:ss}");
			stringBuilder.AppendLine($"FSM 数量: {fsms.Length}");
			stringBuilder.AppendLine("================================================================================");
			foreach (PlayMakerFSM val in fsms)
			{
				stringBuilder.AppendLine("\n【" + val.FsmName + "】");
				stringBuilder.AppendLine($"  状态数: {val.FsmStates.Length}");
				stringBuilder.AppendLine($"  事件数: {val.FsmEvents.Length}");
				stringBuilder.AppendLine("  起始状态: " + val.Fsm.StartState);
				stringBuilder.AppendLine("  状态列表:");
				FsmState[] fsmStates = val.FsmStates;
				foreach (FsmState val2 in fsmStates)
				{
					FsmStateAction[] actions = val2.Actions;
					int num = ((actions != null) ? actions.Length : 0);
					FsmTransition[] transitions = val2.Transitions;
					int num2 = ((transitions != null) ? transitions.Length : 0);
					stringBuilder.AppendLine($"    - {val2.Name} ({num} actions, {num2} transitions)");
				}
			}
			stringBuilder.AppendLine("\n================================================================================");
			stringBuilder.AppendLine("子对象 FSM");
			stringBuilder.AppendLine("================================================================================");
			PlayMakerFSM[] componentsInChildren = gameObject2.GetComponentsInChildren<PlayMakerFSM>(true);
			PlayMakerFSM[] array = componentsInChildren.Where((PlayMakerFSM f) => (Object)(object)((Component)f).gameObject != (Object)(object)gameObject2).ToArray();
			stringBuilder.AppendLine($"子对象 FSM 数量: {array.Length}");
			PlayMakerFSM[] array2 = array;
			foreach (PlayMakerFSM val3 in array2)
			{
				stringBuilder.AppendLine($"  {GetGameObjectPath(((Component)val3).gameObject)} -> {val3.FsmName} ({val3.FsmStates.Length} states)");
			}
			Directory.CreateDirectory(Path.GetDirectoryName(outputPath) ?? ".");
			File.WriteAllText(outputPath, stringBuilder.ToString(), Encoding.UTF8);
		}

		private static void AnalyzeActionVariables(StringBuilder sb, FsmStateAction action, int actionIndex)
		{
			try
			{
				Type type = ((object)action).GetType();
				FieldInfo[] fields = type.GetFields(BindingFlags.Instance | BindingFlags.Public);
				FieldInfo[] array = fields;
				foreach (FieldInfo fieldInfo in array)
				{
					object value = fieldInfo.GetValue(action);
					if (value != null)
					{
						string text = FormatValue(value, action);
						sb.AppendLine("        " + fieldInfo.Name + ": " + text);
					}
				}
			}
			catch (Exception ex)
			{
				sb.AppendLine("        (分析变量时出错: " + ex.Message + ")");
			}
		}

		private static string FormatValue(object value, FsmStateAction action)
		{
			//IL_023b: Unknown result type (might be due to invalid IL or missing references)
			//IL_024f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0263: Unknown result type (might be due to invalid IL or missing references)
			//IL_0277: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_02df: Unknown result type (might be due to invalid IL or missing references)
			if (1 == 0)
			{
			}
			FsmFloat val = (FsmFloat)((value is FsmFloat) ? value : null);
			string result;
			if (val == null)
			{
				FsmInt val2 = (FsmInt)((value is FsmInt) ? value : null);
				if (val2 == null)
				{
					FsmBool val3 = (FsmBool)((value is FsmBool) ? value : null);
					if (val3 == null)
					{
						FsmString val4 = (FsmString)((value is FsmString) ? value : null);
						if (val4 == null)
						{
							FsmEvent val5 = (FsmEvent)((value is FsmEvent) ? value : null);
							if (val5 == null)
							{
								FsmGameObject val6 = (FsmGameObject)((value is FsmGameObject) ? value : null);
								if (val6 == null)
								{
									FsmOwnerDefault val7 = (FsmOwnerDefault)((value is FsmOwnerDefault) ? value : null);
									if (val7 == null)
									{
										FsmColor val8 = (FsmColor)((value is FsmColor) ? value : null);
										if (val8 == null)
										{
											FsmVector3 val9 = (FsmVector3)((value is FsmVector3) ? value : null);
											if (val9 == null)
											{
												FsmObject val10 = (FsmObject)((value is FsmObject) ? value : null);
												if (val10 == null)
												{
													GameObject val11 = (GameObject)((value is GameObject) ? value : null);
													result = ((val11 == null) ? $"{value} ({value.GetType().Name})" : ("GO:" + ((Object)val11).name));
												}
												else
												{
													result = (((NamedVariable)val10).UseVariable ? ("[Obj变量:" + ((NamedVariable)val10).Name + "]") : ("Obj:" + (((object)val10.Value)?.GetType().Name ?? "(null)")));
												}
											}
											else
											{
												result = (((NamedVariable)val9).UseVariable ? ("[V3变量:" + ((NamedVariable)val9).Name + "]") : $"({val9.Value.x:F2},{val9.Value.y:F2},{val9.Value.z:F2})");
											}
										}
										else
										{
											result = (((NamedVariable)val8).UseVariable ? ("[Color变量:" + ((NamedVariable)val8).Name + "]") : $"RGBA({val8.Value.r:F2},{val8.Value.g:F2},{val8.Value.b:F2},{val8.Value.a:F2})");
										}
									}
									else
									{
										result = FormatOwnerDefault(val7, action);
									}
								}
								else
								{
									result = (((NamedVariable)val6).UseVariable ? ("[GO变量:" + ((NamedVariable)val6).Name + "]") : (((Object)(object)val6.Value != (Object)null) ? ("GO:" + ((Object)val6.Value).name) : "GO:(null)"));
								}
							}
							else
							{
								result = "[Event:" + val5.Name + "]";
							}
						}
						else
						{
							result = (((NamedVariable)val4).UseVariable ? ("[String变量:" + ((NamedVariable)val4).Name + "]") : ("\"" + val4.Value + "\""));
						}
					}
					else
					{
						result = (((NamedVariable)val3).UseVariable ? ("[Bool变量:" + ((NamedVariable)val3).Name + "]") : $"{val3.Value}");
					}
				}
				else
				{
					result = (((NamedVariable)val2).UseVariable ? ("[Int变量:" + ((NamedVariable)val2).Name + "]") : $"{val2.Value}");
				}
			}
			else
			{
				result = (((NamedVariable)val).UseVariable ? ("[Float变量:" + ((NamedVariable)val).Name + "]") : $"{val.Value}");
			}
			if (1 == 0)
			{
			}
			return result;
		}

		private static string FormatOwnerDefault(FsmOwnerDefault od, FsmStateAction action)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Invalid comparison between Unknown and I4
			try
			{
				OwnerDefaultOption ownerOption = od.OwnerOption;
				if ((int)ownerOption == 0)
				{
					return "[Owner]";
				}
				if (od.GameObject != null && (Object)(object)od.GameObject.Value != (Object)null)
				{
					return "GO:" + ((Object)od.GameObject.Value).name;
				}
				if (od.GameObject != null && ((NamedVariable)od.GameObject).UseVariable)
				{
					return "[GO变量:" + ((NamedVariable)od.GameObject).Name + "]";
				}
			}
			catch
			{
			}
			return "[OwnerDefault]";
		}

		private static string GetGameObjectPath(GameObject obj)
		{
			if ((Object)(object)obj == (Object)null)
			{
				return "(null)";
			}
			string text = ((Object)obj).name;
			Transform parent = obj.transform.parent;
			while ((Object)(object)parent != (Object)null)
			{
				text = ((Object)parent).name + "/" + text;
				parent = parent.parent;
			}
			return text;
		}

		private static string SanitizeFileName(string name)
		{
			char[] invalidFileNameChars = Path.GetInvalidFileNameChars();
			return string.Join("_", name.Split(invalidFileNameChars, StringSplitOptions.RemoveEmptyEntries));
		}
	}
	public static class FsmStateBuilder
	{
		public struct StateDefinition
		{
			public string Name;

			public string Description;

			public StateDefinition(string name, string description = "")
			{
				Name = name;
				Description = description;
			}
		}

		public static FsmState CreateState(Fsm fsm, string name, string description = "")
		{
			//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_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Expected O, but got Unknown
			return new FsmState(fsm)
			{
				Name = name,
				Description = description
			};
		}

		public static FsmState CreateState(PlayMakerFSM pmFsm, string name, string description = "")
		{
			return CreateState(pmFsm.Fsm, name, description);
		}

		public static FsmState CreateAndAddState(PlayMakerFSM pmFsm, string name, string description = "")
		{
			FsmState val = CreateState(pmFsm.Fsm, name, description);
			AddStateToFsm(pmFsm, val);
			return val;
		}

		public static void AddStateToFsm(PlayMakerFSM pmFsm, FsmState state)
		{
			List<FsmState> list = pmFsm.Fsm.States.ToList();
			list.Add(state);
			pmFsm.Fsm.States = list.ToArray();
		}

		public static void AddStatesToFsm(PlayMakerFSM pmFsm, params FsmState[] statesToAdd)
		{
			List<FsmState> list = pmFsm.Fsm.States.ToList();
			list.AddRange(statesToAdd);
			pmFsm.Fsm.States = list.ToArray();
		}

		public static FsmState[] CreateStates(Fsm fsm, params StateDefinition[] definitions)
		{
			FsmState[] array = (FsmState[])(object)new FsmState[definitions.Length];
			for (int i = 0; i < definitions.Length; i++)
			{
				array[i] = CreateState(fsm, definitions[i].Name, definitions[i].Description);
			}
			return array;
		}

		public static FsmState[] CreateStates(Fsm fsm, params (string name, string description)[] definitions)
		{
			FsmState[] array = (FsmState[])(object)new FsmState[definitions.Length];
			for (int i = 0; i < definitions.Length; i++)
			{
				array[i] = CreateState(fsm, definitions[i].name, definitions[i].description);
			}
			return array;
		}

		public static FsmState[] CreateAndAddStates(PlayMakerFSM pmFsm, params (string name, string description)[] definitions)
		{
			FsmState[] array = CreateStates(pmFsm.Fsm, definitions);
			AddStatesToFsm(pmFsm, array);
			return array;
		}

		public static FsmState? FindState(PlayMakerFSM pmFsm, string stateName)
		{
			string stateName2 = stateName;
			return ((IEnumerable<FsmState>)pmFsm.FsmStates).FirstOrDefault((Func<FsmState, bool>)((FsmState s) => s.Name == stateName2));
		}

		public static bool StateExists(PlayMakerFSM pmFsm, string stateName)
		{
			string stateName2 = stateName;
			return pmFsm.FsmStates.Any((FsmState s) => s.Name == stateName2);
		}

		public static FsmState GetOrCreateState(PlayMakerFSM pmFsm, string name, string description = "")
		{
			FsmState val = FindState(pmFsm, name);
			if (val != null)
			{
				return val;
			}
			return CreateAndAddState(pmFsm, name, description);
		}

		public static FsmTransition CreateFinishedTransition(FsmState targetState)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Expected O, but got Unknown
			return new FsmTransition
			{
				FsmEvent = FsmEvent.Finished,
				toState = targetState.Name,
				toFsmState = targetState
			};
		}

		public static FsmTransition CreateTransition(FsmEvent fsmEvent, FsmState targetState)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Expected O, but got Unknown
			return new FsmTransition
			{
				FsmEvent = fsmEvent,
				toState = targetState.Name,
				toFsmState = targetState
			};
		}

		public static void SetFinishedTransition(FsmState state, FsmState targetState)
		{
			state.Transitions = (FsmTransition[])(object)new FsmTransition[1] { CreateFinishedTransition(targetState) };
		}

		public static int ForceSetTransition(PlayMakerFSM pmFsm, string fromStateName, string eventName, string targetStateName)
		{
			FsmState val = FindState(pmFsm, fromStateName);
			FsmState val2 = FindState(pmFsm, targetStateName);
			if (val == null || val2 == null || val.Transitions == null)
			{
				return 0;
			}
			FsmTransition[] transitions = val.Transitions;
			foreach (FsmTransition val3 in transitions)
			{
				object obj;
				if (val3 == null)
				{
					obj = null;
				}
				else
				{
					FsmEvent fsmEvent = val3.FsmEvent;
					obj = ((fsmEvent != null) ? fsmEvent.Name : null);
				}
				if (!((string?)obj != eventName))
				{
					val3.toState = val2.Name;
					val3.toFsmState = val2;
					return 1;
				}
			}
			return 0;
		}

		public static void AddTransition(FsmState state, FsmTransition transition)
		{
			List<FsmTransition> list = state.Transitions?.ToList() ?? new List<FsmTransition>();
			list.Add(transition);
			state.Transitions = list.ToArray();
		}

		public static FsmEvent GetOrCreateEvent(PlayMakerFSM pmFsm, string eventName)
		{
			FsmEvent fsmEvent = FsmEvent.GetFsmEvent(eventName);
			List<FsmEvent> list = pmFsm.Fsm.Events.ToList();
			if (!list.Contains(fsmEvent))
			{
				list.Add(fsmEvent);
				pmFsm.Fsm.Events = list.ToArray();
			}
			return fsmEvent;
		}

		public static FsmEvent[] RegisterEvents(PlayMakerFSM pmFsm, params string[] eventNames)
		{
			List<FsmEvent> list = pmFsm.Fsm.Events.ToList();
			FsmEvent[] array = (FsmEvent[])(object)new FsmEvent[eventNames.Length];
			for (int i = 0; i < eventNames.Length; i++)
			{
				array[i] = FsmEvent.GetFsmEvent(eventNames[i]);
				if (!list.Contains(array[i]))
				{
					list.Add(array[i]);
				}
			}
			pmFsm.Fsm.Events = list.ToArray();
			return array;
		}

		public static void ReinitializeFsm(PlayMakerFSM pmFsm)
		{
		}

		public static void ReinitializeFsmVariables(PlayMakerFSM pmFsm)
		{
			pmFsm.FsmVariables.Init();
		}
	}
	internal static class Log
	{
		private static ManualLogSource? _logSource;

		private static string LogPrefix => $"[{Assembly.GetExecutingAssembly().GetName().Version}] ";

		internal static void Init(ManualLogSource logSource)
		{
			_logSource = logSource;
		}

		internal static void Debug(object debug)
		{
			ManualLogSource? logSource = _logSource;
			if (logSource != null)
			{
				logSource.LogDebug((object)(LogPrefix + debug));
			}
		}

		internal static void Info(object info)
		{
			if (Configuration.IsInitialized && Configuration.IsCompatDiagnosticsEnabled)
			{
				ManualLogSource? logSource = _logSource;
				if (logSource != null)
				{
					logSource.LogInfo((object)(LogPrefix + info));
				}
			}
		}

		internal static void InfoAlways(object info)
		{
			ManualLogSource? logSource = _logSource;
			if (logSource != null)
			{
				logSource.LogInfo((object)(LogPrefix + info));
			}
		}

		internal static void Warn(object warning)
		{
			ManualLogSource? logSource = _logSource;
			if (logSource != null)
			{
				logSource.LogWarning((object)(LogPrefix + warning));
			}
		}

		internal static void Error(object error)
		{
			ManualLogSource? logSource = _logSource;
			if (logSource != null)
			{
				logSource.LogError((object)(LogPrefix + error));
			}
		}
	}
}
namespace Radiance.Patches
{
	[HarmonyPatch]
	internal static class FsmFixPatches
	{
		[HarmonyPostfix]
		[HarmonyPatch(typeof(PlayMakerFSM), "OnEnable")]
		private static void FixFsmEventHandlersOnEnable(PlayMakerFSM __instance)
		{
			if (!Configuration.IsModEnabled || (Object)(object)__instance == (Object)null)
			{
				return;
			}
			try
			{
				Fsm fsm = __instance.Fsm;
				if (fsm == null || fsm.States == null)
				{
					return;
				}
				FsmState[] states = fsm.States;
				foreach (FsmState val in states)
				{
					if (((val != null) ? val.Actions : null) == null)
					{
						continue;
					}
					FsmStateAction[] actions = val.Actions;
					foreach (FsmStateAction val2 in actions)
					{
						if (val2 != null)
						{
							try
							{
								val2.OnPreprocess();
							}
							catch
							{
							}
						}
					}
				}
				__instance.AddEventHandlerComponents();
			}
			catch (Exception ex)
			{
				Log.Debug("[FsmFixPatch] 修复 FSM 事件处理组件失败: " + ((Object)((Component)__instance).gameObject).name + "/" + __instance.FsmName + " - " + ex.Message);
			}
		}
	}
	[HarmonyPatch]
	internal static class GodfinderIconPatches
	{
		[HarmonyPrefix]
		[HarmonyPatch(typeof(ShowGodfinderIcon), "OnEnter")]
		private static bool SkipShowGodfinderIcon()
		{
			if (!Configuration.IsModEnabled)
			{
				return true;
			}
			return !RadianceSceneManager.IsInCustomScene;
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(GodfinderIcon), "Show")]
		private static bool SkipHideGodfinderIcon()
		{
			if (!Configuration.IsModEnabled)
			{
				return true;
			}
			return !RadianceSceneManager.IsInCustomScene;
		}
	}
	[HarmonyPatch]
	internal static class MemoryScenePatches
	{
		[HarmonyPostfix]
		[HarmonyPatch(typeof(GameManager), "IsMemoryScene", new Type[] { })]
		private static void ForceMemoryInCustomScene(ref bool __result)
		{
			if (Configuration.IsModEnabled && RadianceSceneManager.IsInCustomScene)
			{
				__result = true;
			}
		}
	}
	[HarmonyPatch]
	internal static class RadiancePatches
	{
		public delegate void FsmHandler(PlayMakerFSM fsm);

		private const string TargetGameObjectName = "Absolute Radiance";

		private const string TargetControlFsmName = "Control";

		private static readonly Dictionary<string, FsmHandler> FsmHandlers = new Dictionary<string, FsmHandler> { { "Control", HandleControlFsm } };

		[HarmonyPrefix]
		[HarmonyPatch(typeof(PlayMakerFSM), "Start")]
		private static void MountRadianceBehaviours(PlayMakerFSM __instance)
		{
			if (!Configuration.IsModEnabled || (Object)(object)__instance == (Object)null || ((Object)((Component)__instance).gameObject).name != "Absolute Radiance" || !FsmHandlers.TryGetValue(__instance.FsmName, out FsmHandler value))
			{
				return;
			}
			Log.Info("[RadiancePatch] 发现目标 FSM: Absolute Radiance/" + __instance.FsmName);
			try
			{
				value(__instance);
			}
			catch (Exception ex)
			{
				Log.Error("[RadiancePatch] 处理 FSM [" + __instance.FsmName + "] 失败: " + ex.Message);
			}
		}

		private static void HandleControlFsm(PlayMakerFSM fsm)
		{
			PlayMakerFSM fsm2 = fsm;
			SyncImmortalLightBehaviour(fsm2);
			SyncVanillaRadianceFixBehaviour(fsm2);
			MountBehaviour(fsm2, delegate(RadianceReturnOnDialogueBehavior b)
			{
				b.Initialize(fsm2);
			});
		}

		private static T MountBehaviour<T>(PlayMakerFSM fsm, Action<T>? initializer = null) where T : MonoBehaviour
		{
			T val = ((Component)fsm).gameObject.GetComponent<T>();
			if ((Object)(object)val == (Object)null)
			{
				val = ((Component)fsm).gameObject.AddComponent<T>();
				Log.Info("[RadiancePatch] 已挂载 " + typeof(T).Name + " 组件");
			}
			initializer?.Invoke(val);
			return val;
		}

		private static void UnmountBehaviour<T>(PlayMakerFSM fsm) where T : MonoBehaviour
		{
			T component = ((Component)fsm).gameObject.GetComponent<T>();
			if (!((Object)(object)component == (Object)null))
			{
				Object.Destroy((Object)(object)component);
				Log.Info("[RadiancePatch] 已卸载 " + typeof(T).Name + " 组件");
			}
		}

		private static void SyncImmortalLightBehaviour(PlayMakerFSM fsm)
		{
			PlayMakerFSM fsm2 = fsm;
			if (Configuration.IsImmortalLightEnabled)
			{
				MountBehaviour(fsm2, delegate(RadianceImmortalLightBehavior b)
				{
					b.Initialize(fsm2);
				});
			}
			else
			{
				UnmountBehaviour<RadianceImmortalLightBehavior>(fsm2);
			}
		}

		private static void SyncVanillaRadianceFixBehaviour(PlayMakerFSM fsm)
		{
			PlayMakerFSM fsm2 = fsm;
			if (Configuration.IsModEnabled && Configuration.EnableVanillaRadianceFix.Value)
			{
				MountBehaviour(fsm2, delegate(RadianceVanillaFixBehavior b)
				{
					b.Initialize(fsm2);
				});
			}
			else
			{
				UnmountBehaviour<RadianceVanillaFixBehavior>(fsm2);
			}
		}

		public static void RefreshFeatureBehavioursInScene()
		{
			PlayMakerFSM[] array = Object.FindObjectsByType<PlayMakerFSM>((FindObjectsInactive)1, (FindObjectsSortMode)0);
			PlayMakerFSM[] array2 = array;
			foreach (PlayMakerFSM val in array2)
			{
				if (!((Object)(object)val == (Object)null) && !(((Object)((Component)val).gameObject).name != "Absolute Radiance") && !(val.FsmName != "Control"))
				{
					SyncImmortalLightBehaviour(val);
					SyncVanillaRadianceFixBehaviour(val);
				}
			}
		}

		public static void RefreshImmortalLightBehavioursInScene()
		{
			RefreshFeatureBehavioursInScene();
		}

		public static void RegisterFsmHandler(string fsmName, FsmHandler handler)
		{
			if (FsmHandlers.ContainsKey(fsmName))
			{
				Log.Warn("[RadiancePatch] FSM 处理器 [" + fsmName + "] 已存在，将被覆盖");
			}
			FsmHandlers[fsmName] = handler;
			Log.Info("[RadiancePatch] 已注册 FSM 处理器: " + fsmName);
		}

		public static void UnregisterFsmHandler(string fsmName)
		{
			if (FsmHandlers.Remove(fsmName))
			{
				Log.Info("[RadiancePatch] 已注销 FSM 处理器: " + fsmName);
			}
		}
	}
	[HarmonyPatch]
	internal static class RadiantOrbFixPatches
	{
		private const string RadiantOrbName = "Radiant Orb";

		[HarmonyPostfix]
		[HarmonyPatch(typeof(SpawnObjectFromGlobalPool), "OnEnter")]
		private static void OnRadiantOrbSpawned(SpawnObjectFromGlobalPool __instance)
		{
			if (Configuration.IsVanillaRadianceFixEnabled)
			{
				FsmGameObject storeObject = __instance.storeObject;
				GameObject val = ((storeObject != null) ? storeObject.Value : null);
				if (!((Object)(object)val == (Object)null) && ((Object)val).name.Contains("Radiant Orb") && !((Object)(object)val.GetComponent<RadiantOrbDissipateFixBehavior>() != (Object)null))
				{
					val.AddComponent<RadiantOrbDissipateFixBehavior>();
				}
			}
		}
	}
	[HarmonyPatch]
	internal static class SceneTransitionPatches
	{
		[HarmonyPrefix]
		[HarmonyPatch(typeof(GameManager), "BeginSceneTransition")]
		private static bool InterceptSceneTransition(SceneLoadInfo info)
		{
			if (!Configuration.IsModEnabled)
			{
				return true;
			}
			if (!RadianceSceneManager.IsInCustomScene && info.SceneName == "GG_Radiance")
			{
				RadianceSceneManager instance = RadianceSceneManager.Instance;
				if ((Object)(object)instance != (Object)null)
				{
					Log.Info("[SceneTransitionPatch] 拦截 TransitionPoint 入场: GG_Radiance，转为 AssetBundle 加载");
					instance.EnterViaTransitionPoint();
					return false;
				}
			}
			if (RadianceSceneManager.IsInCustomScene)
			{
				RadianceSceneManager instance2 = RadianceSceneManager.Instance;
				if ((Object)(object)instance2 != (Object)null)
				{
					Log.Info("[SceneTransitionPatch] 自定义场景内场景转换: " + info.SceneName + "，执行清理");
					instance2.CleanupCustomScene();
				}
			}
			return true;
		}
	}
	[HarmonyPatch]
	internal static class Tk2dCollectionPatches
	{
		[HarmonyPrefix]
		[HarmonyPriority(800)]
		[HarmonyPatch(typeof(tk2dSpriteCollectionData), "Init")]
		private static void NamespaceBeforeInit(tk2dSpriteCollectionData __instance)
		{
			if (Configuration.IsModEnabled)
			{
				SkinCompatibilityService.TryNamespaceBeforeCollectionInit(__instance, "tk2d.Init.Prefix");
			}
		}
	}
}
namespace Radiance.Managers
{
	internal sealed class AssetManager : MonoBehaviour
	{
		[CompilerGenerated]
		private sealed class <EnsureBundleLoadedAsync>d__15 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public AssetManager <>4__this;

			private AssetBundleCreateRequest <req>5__1;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if ((Object)(object)<>4__this._bundle != (Object)null)
					{
						if (string.IsNullOrEmpty(<>4__this._scenePathInBundle))
						{
							<>4__this.ResolveScenePath();
						}
						return false;
					}
					if (<>4__this._bundleBytes == null)
					{
						<>4__this._bundleBytes = <>4__this.GetEmbeddedBundleBytes();
					}
					if (<>4__this._bundleBytes == null)
					{
						Log.Error("[AssetManager] 无法获取嵌入的 radiance.bundle 字节数据");
						return false;
					}
					<req>5__1 = AssetBundle.LoadFromMemoryAsync(<>4__this._bundleBytes);
					<>2__current = <req>5__1;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<>4__this._bundle = <req>5__1.assetBundle;
					if ((Object)(object)<>4__this._bundle == (Object)null)
					{
						Log.Error("[AssetManager] AssetBundle.LoadFromMemoryAsync 失败");
						return false;
					}
					<>4__this.ResolveScenePath();
					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 <LoadRadianceSceneSingleAsync>d__13 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public AssetManager <>4__this;

			private AsyncOperation <op>5__1;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = <>4__this.EnsureBundleLoadedAsync();
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					if (string.IsNullOrEmpty(<>4__this._scenePathInBundle))
					{
						Log.Error("[AssetManager] scenePath 为空，无法加载 GG_Radiance 场景");
						return false;
					}
					Log.Info("[AssetManager] 加载场景（Single）：" + <>4__this._scenePathInBundle);
					<op>5__1 = SceneManager.LoadSceneAsync(<>4__this._scenePathInBundle, (LoadSceneMode)0);
					if (<op>5__1 == null)
					{
						Log.Error("[AssetManager] SceneManager.LoadSceneAsync 返回 null");
						return false;
					}
					<>2__current = <op>5__1;
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					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 <PreloadAllAssets>d__12 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public AssetManager <>4__this;

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

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

			[DebuggerHidden]
			public <PreloadAllAssets>d__12(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;
					if (<>4__this._isPreloaded || <>4__this._isPreloading)
					{
						goto IL_0064;
					}
					<>4__this._isPreloading = true;
					<>2__current = <>4__this.EnsureBundleLoadedAsync();
					<>1__state = 2;
					return true;
				case 1:
					<>1__state = -1;
					goto IL_0064;
				case 2:
					{
						<>1__state = -1;
						<>4__this._isPreloaded = true;
						<>4__this._isPreloading = false;
						Log.Info("[AssetManager] 预加载完成");
						return false;
					}
					IL_0064:
					if (<>4__this._isPreloading)
					{
						<>2__current = null;
						<>1__state = 1;
						return 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 const string EmbeddedBundleName = "Radiance.Asset.radiance.bundle";

		private const string EmbeddedBundleSuffix = ".radiance.bundle";

		private byte[]? _bundleBytes;

		private AssetBundle? _bundle;

		private string? _scenePathInBundle;

		private bool _isPreloaded;

		private bool _isPreloading;

		public bool IsBundleLoaded => (Object)(object)_bundle != (Object)null;

		public bool IsPreloaded => _isPreloaded;

		private void Awake()
		{
			Log.Info("[AssetManager] 已初始化（Scene bundle 模式）");
		}

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

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

		public void UnloadBundleKeepLoadedAssets()
		{
			if (!((Object)(object)_bundle == (Object)null))
			{
				_bundle.Unload(false);
				Resources.UnloadUnusedAssets();
				_bundle = null;
			}
		}

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

		private void ResolveScenePath()
		{
			if ((Object)(object)_bundle == (Object)null)
			{
				return;
			}
			string[] allScenePaths = _bundle.GetAllScenePaths();
			if (allScenePaths == null || allScenePaths.Length == 0)
			{
				Log.Error("[AssetManager] radiance.bundle 内没有 Scene。请确认打包的是 Scene bundle（包含 GG_Radiance.unity）");
				return;
			}
			_scenePathInBundle = allScenePaths.FirstOrDefault((string p) => p.IndexOf("gg_radiance", StringComparison.OrdinalIgnoreCase) >= 0) ?? allScenePaths[0];
			Log.Info("[AssetManager] ScenePaths: " + string.Join(", ", allScenePaths));
			Log.Info("[AssetManager] 选用 scenePath: " + _scenePathInBundle);
		}

		private byte[]? GetEmbeddedBundleBytes()
		{
			try
			{
				Assembly executingAssembly = Assembly.GetExecutingAssembly();
				Stream manifestResourceStream = executingAssembly.GetManifestResourceStream("Radiance.Asset.radiance.bundle");
				if (manifestResourceStream == null)
				{
					string[] manifestResourceNames = executingAssembly.GetManifestResourceNames();
					string text = manifestResourceNames.FirstOrDefault((string n) => n.EndsWith(".radiance.bundle", StringComparison.OrdinalIgnoreCase));
					if (string.IsNullOrEmpty(text))
					{
						Log.Error("[AssetManager] 未找到嵌入资源：Radiance.Asset.radiance.bundle（也没有匹配 .radiance.bundle 的资源）");
						Log.Debug("[AssetManager] 可用嵌入资源：" + string.Join(", ", manifestResourceNames));
						return null;
					}
					manifestResourceStream = executingAssembly.GetManifestResourceStream(text);
					Log.Warn("[AssetManager] EmbeddedBundleName 不匹配，使用兜底资源名：" + text);
				}
				using (manifestResourceStream)
				{
					using MemoryStream memoryStream = new MemoryStream();
					manifestResourceStream.CopyTo(memoryStream);
					return memoryStream.ToArray();
				}
			}
			catch (Exception ex)
			{
				Log.Error("[AssetManager] 读取嵌入 bundle 失败：" + ex.Message);
				return null;
			}
		}

		private void OnDestroy()
		{
			if ((Object)(object)_bundle != (Object)null)
			{
				_bundle.Unload(false);
				_bundle = null;
			}
			_bundleBytes = null;
		}
	}
	public class RadianceSceneManager : MonoBehaviour, IWorldRumblePreventer
	{
		[CompilerGenerated]
		private sealed class <EnsureCustomSceneAudioState>d__55 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public RadianceSceneManager <>4__this;

			private GameManager <gm>5__1;

			private CustomSceneManager <sm>5__2;

			private CameraController <cameraController>5__3;

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

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

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

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

			private bool MoveNext()
			{
				//IL_008f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0099: Expected O, but got Unknown
				//IL_0161: Unknown result type (might be due to invalid IL or missing references)
				//IL_016b: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
				{
					<>1__state = -1;
					<gm>5__1 = GameManager._instance;
					GameManager obj = <gm>5__1;
					<sm>5__2 = ((obj != null) ? obj.sm : null);
					<cameraController>5__3 = GameCameras.instance?.cameraController;
					if ((Object)(object)<cameraController>5__3 != (Object)null)
					{
						<cameraController>5__3.PositionToHero(true);
						<>2__current = (object)new WaitForSecondsRealtime(0.15f);
						<>1__state = 1;
						return true;
					}
					goto IL_00aa;
				}
				case 1:
					<>1__state = -1;
					goto IL_00aa;
				case 2:
					{
						<>1__state = -1;
						break;
					}
					IL_00aa:
					if ((Object)(object)<gm>5__1 == (Object)null || (Object)(object)<sm>5__2 == (Object)null || (Object)(object)<gm>5__1.AudioManager == (Object)null)
					{
						return false;
					}
					if (<sm>5__2.IsAudioSnapshotsApplied)
					{
						return false;
					}
					if (!HasCustomSceneAudioConfig(<sm>5__2))
					{
						<gm>5__1.AudioManager.StopAndClearMusic();
						<gm>5__1.AudioManager.StopAndClearAtmos();
						AudioManager.CustomSceneManagerReady();
						Log.Info("[RadianceSceneManager] 未检测到场景音频配置，已清理旧场景音乐/氛围");
						return false;
					}
					if ((Object)(object)<cameraController>5__3 != (Object)null)
					{
						<cameraController>5__3.PositionToHero(true);
						<>2__current = (object)new WaitForSecondsRealtime(0.15f);
						<>1__state = 2;
						return true;
					}
					break;
				}
				if (!<sm>5__2.IsAudioSnapshotsApplied)
				{
					AudioManager.CustomSceneManagerReady();
					Log.Warn("[RadianceSceneManager] 场景音频回调未触发，已执行 Ready 兜底");
				}
				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 <EnterCustomSceneRoutine>d__41 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public string customSceneName;

			public Vector3 spawnPosition;

			public string targetSceneName;

			public RadianceSceneManager <>4__this;

			private HeroController <hero>5__1;

			private AssetManager <assetManager>5__2;

			private Exception <ex>5__3;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<hero>5__1 = null;
				<assetManager>5__2 = null;
				<ex>5__3 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0193: Unknown result type (might be due to invalid IL or missing references)
				//IL_019d: Expected O, but got Unknown
				//IL_01ed: Unknown result type (might be due to invalid IL or missing references)
				//IL_01f2: Unknown result type (might be due to invalid IL or missing references)
				//IL_0203: Unknown result type (might be due to invalid IL or missing references)
				//IL_020e: Unknown result type (might be due to invalid IL or missing references)
				//IL_021a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0225: Unknown result type (might be due to invalid IL or missing references)
				//IL_022c: Unknown result type (might be due to invalid IL or missing references)
				//IL_022e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0233: Unknown result type (might be due to invalid IL or missing references)
				//IL_023f: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					Log.Info("[RadianceSceneManager] 开始进入自定义场景: " + customSceneName);
					<hero>5__1 = HeroController.instance;
					if ((Object)(object)<hero>5__1 == (Object)null || (Object)(object)GameManager._instance == (Object)null)
					{
						Log.Error("[RadianceSceneManager] HeroController 或 GameManager 为空");
						return false;
					}
					<>4__this._targetSceneName = (string.IsNullOrEmpty(targetSceneName) ? "GG_Radiance" : targetSceneName);
					<>4__this.SaveReturnInfo();
					<>4__this.DisablePlayerControl();
					<>2__current = <>4__this.PlayEnterAnimation(<hero>5__1);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<>4__this._pendingCustomSceneName = customSceneName;
					if (<>4__this._targetSceneName == "GG_Radiance")
					{
						<assetManager>5__2 = ((Component)<>4__this).GetComponent<AssetManager>();
						if ((Object)(object)<assetManager>5__2 == (Object)null)
						{
							Log.Error("[RadianceSceneManager] AssetManager 未找到");
							<>4__this._pendingCustomSceneName = null;
							<>4__this.EnablePlayerControl();
							return false;
						}
						try
						{
							GameManager instance = GameManager._instance;
							if (instance != null)
							{
								PlayMakerFSM screenFader_fsm = instance.screenFader_fsm;
								if (screenFader_fsm != null)
								{
									screenFader_fsm.SendEvent("SCENE FADE OUT");
								}
							}
						}
						catch
						{
						}
						<>2__current = (object)new WaitForSeconds(0.5f);
						<>1__state = 2;
						return true;
					}
					try
					{
						GameManager._instance.BeginSceneTransition(new SceneLoadInfo
						{
							SceneName = <>4__this._targetSceneName,
							EntryGateName = "",
							HeroLeaveDirection = (GatePosition)5,
							EntryDelay = 0f,
							WaitForSceneTransitionCameraFade = true,
							Visualization = (SceneLoadVisualizations)0,
							AlwaysUnloadUnusedAssets = false
						});
						Log.Info("[RadianceSceneManager] 传送到: " + <>4__this._targetSceneName);
					}
					catch (Exception ex)
					{
						<ex>5__3 = ex;
						Log.Error("[RadianceSceneManager] 传送失败: " + <ex>5__3.Message);
						<>4__this._pendingCustomSceneName = null;
						<>4__this._targetSceneName = "";
						<>4__this.EnablePlayerControl();
					}
					break;
				case 2:
					<>1__state = -1;
					<>2__current = <assetManager>5__2.LoadRadianceSceneSingleAsync();
					<>1__state = 3;
					return true;
				case 3:
					<>1__state = -1;
					Log.Info("[RadianceSceneManager] 加载 GG_Radiance 成功");
					<assetManager>5__2 = null;
					break;
				}
				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 <LoadFromTransitionPointRoutine>d__43 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public RadianceSceneManager <>4__this;

			private AssetManager <assetManager>5__1;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<assetManager>5__1 = ((Component)<>4__this).GetComponent<AssetManager>();
					if ((Object)(object)<assetManager>5__1 == (Object)null)
					{
						Log.Error("[RadianceSceneManager] AssetManager 未找到");
						<>4__this._pendingCustomSceneName = null;
						<>4__this._targetSceneName = "";
						<>4__this.EnablePlayerControl();
						return false;
					}
					if (!<assetManager>5__1.IsPreloaded)
					{
						Log.Info("[RadianceSceneManager] 等待资源预加载...");
						goto IL_00c4;
					}
					goto IL_0130;
				case 1:
					<>1__state = -1;
					goto IL_00c4;
				case 2:
					{
						<>1__state = -1;
						Log.Info("[RadianceSceneManager] TransitionPoint 触发: GG_Radiance 加载成功");
						return false;
					}
					IL_00c4:
					if ((Object)(object)<assetManager>5__1 != (Object)null && !<assetManager>5__1.IsPreloaded)
					{
						<>2__current = null;
						<>1__state = 1;
						return true;
					}
					if ((Object)(object)<assetManager>5__1 == (Object)null)
					{
						Log.Error("[RadianceSceneManager] AssetManager 在等待预加载期间被销毁");
						<>4__this._pendingCustomSceneName = null;
						<>4__this._targetSceneName = "";
						<>4__this.EnablePlayerControl();
						return false;
					}
					goto IL_0130;
					IL_0130:
					<>2__current = <assetManager>5__1.LoadRadianceSceneSingleAsync();
					<>1__state = 2;
					return true;
				}
			}

			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 <OnEnterTargetScene>d__46 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public RadianceSceneManager <>4__this;

			private TransitionPoint <existingTP>5__1;

			private Exception <ex>5__2;

			private PlayerData <pd>5__3;

			private Exception <ex>5__4;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<existingTP>5__1 = null;
				<ex>5__2 = null;
				<pd>5__3 = null;
				<ex>5__4 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_017b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0185: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					ShaderCompatibilityService.ResetSession();
					SkinCompatibilityService.ResetSession();
					<>4__this.CapSilkForRadianceScene();
					<>4__this.HandleProblematicComponents();
					<>4__this.RemapAudioMixerGroups();
					<>4__this.CreateMinimalSceneManager();
					<>4__this.RefreshCustomSceneVisualState();
					<>4__this.SavePreMemoryState();
					<existingTP>5__1 = Object.FindAnyObjectByType<TransitionPoint>();
					if ((Object)(object)<existingTP>5__1 != (Object)null)
					{
						<existingTP>5__1.isInactive = true;
						((InteractableBase)<existingTP>5__1).Deactivate(false);
						Log.Info("[RadianceSceneManager] 已禁用 TransitionPoint 交互: " + ((Object)((Component)<existingTP>5__1).gameObject).name);
					}
					<>4__this.DisableInterferingRenderers();
					<>4__this.InitializeHeroAndCameraForCustomEntry();
					<>2__current = null;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<>4__this.FixHK1LocalizationTexts();
					<>4__this.RunCompatibilityPass("pass1");
					<>4__this.RefreshCustomSceneVisualState();
					<>2__current = <>4__this.EnsureCustomSceneAudioState();
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					<>4__this.ForceApplyInitialCameraLocks();
					<>4__this.FadeSceneIn();
					<>2__current = (object)new WaitForSeconds(0.5f);
					<>1__state = 3;
					return true;
				case 3:
					<>1__state = -1;
					<>4__this.RunCompatibilityPass("pass2");
					<>4__this.EnablePlayerControl();
					((MonoBehaviour)<>4__this).StartCoroutine(<>4__this.RunDeferredCompatibilityPass());
					try
					{
						GameManager instance = GameManager._instance;
						if (instance != null)
						{
							instance.FinishedEnteringScene();
						}
					}
					catch (Exception ex)
					{
						<ex>5__2 = ex;
						Log.Warn("[RadianceSceneManager] FinishedEnteringScene 失败: " + <ex>5__2.Message);
					}
					try
					{
						<pd>5__3 = PlayerData.instance;
						if (<pd>5__3 != null)
						{
							<pd>5__3.disablePause = false;
							<pd>5__3.isInvincible = false;
						}
						<pd>5__3 = null;
					}
					catch (Exception ex)
					{
						<ex>5__4 = ex;
						Log.Warn("[RadianceSceneManager] 重置 PlayerData 状态失败: " + <ex>5__4.Message);
					}
					Log.Info("[RadianceSceneManager] 自定义场景设置完成");
					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 <OnReturnToOriginalScene>d__58 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public RadianceSceneManager <>4__this;

			private GameManager <gm>5__1;

			private float <timeout>5__2;

			private Exception <ex>5__3;

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

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

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

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

			private bool MoveNext()
			{
				int num = <>1__state;
				if (num != 0)
				{
					if (num != 1)
					{
						return false;
					}
					<>1__state = -1;
				}
				else
				{
					<>1__state = -1;
					<gm>5__1 = GameManager._instance;
					if (!((Object)(object)<gm>5__1 != (Object)null))
					{
						goto IL_0097;
					}
					<timeout>5__2 = 5f;
				}
				if (!<gm>5__1.hasFinishedEnteringScene && <timeout>5__2 > 0f)
				{
					<timeout>5__2 -= Time.deltaTime;
					<>2__current = null;
					<>1__state = 1;
					return true;
				}
				goto IL_0097;
				IL_0097:
				try
				{
					GameCameras instance = GameCameras.instance;
					if (instance != null)
					{
						instance.HUDIn();
					}
				}
				catch (Exception ex)
				{
					<ex>5__3 = ex;
					Log.Warn("[RadianceSceneManager] HUDIn 失败: " + <ex>5__3.Message);
				}
				<>4__this._hasSavedReturnInfo = false;
				Log.Info("[RadianceSceneManager] 已返回原场景");
				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 <PlayEnterAnimation>d__65 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public HeroController hero;

			public RadianceSceneManager <>4__this;

			private tk2dSpriteAnimator <tk2dAnimator>5__1;

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

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

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

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

			private bool MoveNext()
			{
				//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ab: Expected O, but got Unknown
				//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
				//IL_00cf: Expected O, but got Unknown
				//IL_0070: Unknown result type (might be due to invalid IL or missing references)
				//IL_007a: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<tk2dAnimator>5__1 = ((Component)hero).GetComponent<tk2dSpriteAnimator>();
					if ((Object)(object)<tk2dAnimator>5__1 != (Object)null)
					{
						<tk2dAnimator>5__1.Play("Abyss Kneel");
						<>2__current = (object)new WaitForSeconds(0.8f);
						<>1__state = 1;
						return true;
					}
					<>2__current = (object)new WaitForSeconds(1.8f);
					<>1__state = 3;
					return true;
				case 1:
					<>1__state = -1;
					<tk2dAnimator>5__1.Play("Kneel To Prostrate");
					<>2__current = (object)new WaitForSeconds(1f);
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					break;
				case 3:
					<>1__state = -1;
					break;
				}
				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 <RunDeferredCompatibilityPass>d__47 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public RadianceSceneManager <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0026: Unknown result type (might be due to invalid IL or missing references)
				//IL_0030: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForSeconds(2f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					if (!IsInCustomScene)
					{
						return false;
					}
					<>4__this.RunCompatibilityPass("pass_deferred");
					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 string _returnSceneName = "";

		private Vector3 _returnPosition;

		private bool _hasSavedReturnInfo;

		private string _targetSceneName = "";

		private string? _pendingCustomSceneName;

		private readonly List<TransitionPoint> _disabledTransitionPoints = new List<TransitionPoint>();

		private static readonly string[] GlobalRenderersToDisable = new string[1] { "_GameCameras/CameraParent/tk2dCamera/Masker Blackout" };

		private static readonly Dictionary<string, (string zh, string fallback)> HK1TextMapVanilla = new Dictionary<string, (string, string)>
		{
			{
				"!!Titles/ABSOLUTE_RADIANCE_MAIN!!",
				("无上辐光", "Radiance")
			},
			{
				"!!Titles/ABSOLUTE_RADIANCE_SUPER!!",
				("", "Absolute")
			}
		};

		private static readonly Dictionary<string, (string zh, string fallback)> HK1TextMapImmortalLight = new Dictionary<string, (string, string)>
		{
			{
				"!!Titles/ABSOLUTE_RADIANCE_MAIN!!",
				("永恒之光", "ImmortalLight")
			},
			{
				"!!Titles/ABSOLUTE_RADIANCE_SUPER!!",
				("直面", "Confront")
			}
		};

		private static readonly BindingFlags PrivateInstanceFlags = BindingFlags.Instance | BindingFlags.NonPublic;

		private static readonly FieldInfo? MusicCueField = typeof(CustomSceneManager).GetField("musicCue", PrivateInstanceFlags);

		private static readonly FieldInfo? AtmosCueField = typeof(CustomSceneManager).GetField("atmosCue", PrivateInstanceFlags);

		private static readonly FieldInfo? MusicSnapshotField = typeof(CustomSceneManager).GetField("musicSnapshot", PrivateInstanceFlags);

		private static readonly FieldInfo? OverrideColorSettingsField = typeof(CustomSceneManager).GetField("overrideColorSettings", PrivateInstanceFlags);

		private const int RadianceSilkCap = 9;

		private static readonly HashSet<string> BossLeftoverNames = new HashSet<string> { "Radiant Nail Comb(Clone)", "Radiant Beam R(Clone)", "Radiant Beam L(Clone)", "Radiant Nail(Clone)" };

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

		public static bool IsInCustomScene { get; private set; }

		public static string? CurrentCustomSceneName { get; private set; }

		public string ReturnSceneName => _returnSceneName;

		public bool HasReturnInfo => _hasSavedReturnInfo;

		bool IWorldRumblePreventer.AllowRumble => false;

		private void Awake()
		{
			if ((Object)(object)Instance == (Object)null)
			{
				Instance = this;
				SceneManager.activeSceneChanged += OnSceneChanged;
				Log.Info("[RadianceSceneManager] 初始化完成");
			}
			else
			{
				Object.Destroy((Object)(object)this);
			}
		}

		private void OnDestroy()
		{
			SceneManager.activeSceneChanged -= OnSceneChanged;
			Instance = null;
		}

		private void OnSceneChanged(Scene oldScene, Scene newScene)
		{
			if (((Scene)(ref newScene)).name == "Menu_Title" || ((Scene)(ref newScene)).name == "Quit_To_Menu")
			{
				ResetState();
				return;
			}
			if (!string.IsNullOrEmpty(_pendingCustomSceneName) && !string.IsNullOrEmpty(_targetSceneName) && ((Scene)(ref newScene)).name == _targetSceneName)
			{
				IsInCustomScene = true;
				CurrentCustomSceneName = _pendingCustomSceneName;
				_pendingCustomSceneName = null;
				AddWorldRumblePreventer();
				Log.Info("[RadianceSceneManager] 已进入目标场景: " + ((Scene)(ref newScene)).name);
				((MonoBehaviour)this).StartCoroutine(OnEnterTargetScene());
				return;
			}
			if (_hasSavedReturnInfo && ((Scene)(ref newScene)).name == _returnSceneName && !IsInCustomScene)
			{
				Log.Info("[RadianceSceneManager] 返回原场景: " + ((Scene)(ref newScene)).name);
				((MonoBehaviour)this).StartCoroutine(OnReturnToOriginalScene());
			}
			if (((Scene)(ref newScene)).name == "Belltown")
			{
				CreateBelltownTransitionPoint();
			}
		}

		private void AddWorldRumblePreventer()
		{
			WorldRumbleManager val = GameCameras.SilentInstance?.worldRumbleManager;
			if ((Object)(object)val != (Object)null)
			{
				val.AddPreventer((IWorldRumblePreventer)(object)this);
				Log.Info("[RadianceSceneManager] 已添加 WorldRumble 阻止器（GG_Radiance 无怪叫）");
			}
		}

		private void RemoveWorldRumblePreventer()
		{
			WorldRumbleManager val = GameCameras.SilentInstance?.worldRumbleManager;
			if ((Object)(object)val != (Object)null)
			{
				val.RemovePreventer((IWorldRumblePreventer)(object)this);
			}
		}

		private void ResetState()
		{
			RemoveWorldRumblePreventer();
			ShaderCompatibilityService.ResetSession();
			SkinCompatibilityService.ResetSession();
			IsInCustomScene = false;
			CurrentCustomSceneName = null;
			_pendingCustomSceneName = null;
			_hasSavedReturnInfo = false;
			_disabledTransitionPoints.Clear();
			Log.Info("[RadianceSceneManager] 状态已重置");
		}

		private void CreateBelltownTransitionPoint()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Expected O, but got Unknown
			//IL_0091: 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_00e1: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("door_radiance");
			val.SetActive(false);
			val.transform.position = new Vector3(50f, 40.7f, 0f);
			BoxCollider2D val2 = val.AddComponent<BoxCollider2D>();
			val2.size = new Vector2(2.13f, 0.2258f);
			((Collider2D)val2).isTrigger = true;
			TransitionPoint val3 = val.AddComponent<TransitionPoint>();
			val3.isADoor = true;
			val3.targetScene = "GG_Radiance";
			val3.entryPoint = "door_radiance";
			val3.nonHazardGate = true;
			val3.OnDoorEnter = new UnityEvent();
			((InteractableBase)val3).interactLabel = (PromptLabels)8;
			typeof(TransitionPoint).GetField("skipSceneMapCheck", BindingFlags.Instance | BindingFlags.NonPublic)?.SetValue(val3, true);
			SceneManager.MoveGameObjectToScene(val, SceneManager.GetActiveScene());
			val.SetActive(true);
			Log.Info("[RadianceSceneManager] 已在 Belltown 创建传送点 door_radiance");
			((InteractableBase)val3).interactLabel = (PromptLabels)8;
			SetupBelltownTransitionDecor();
		}

		private void SetupBelltownTransitionDecor()
		{
			//IL_005d: Unknown res