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 BBNO_COS;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using ExitGames.Client.Photon;
using Microsoft.CodeAnalysis;
using Photon.Pun;
using Photon.Realtime;
using UnityEngine;
using UnityEngine.Playables;
using UnityEngine.SceneManagement;
using UnityEngine.Timeline;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: AssemblyCompany("BBNO-COS")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("BBNO-COS")]
[assembly: AssemblyTitle("BBNO-COS")]
[assembly: AssemblyVersion("1.0.0.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[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;
		}
	}
}
public class BBNOController : MonoBehaviourPunCallbacks
{
	public bool noOceanFog;

	public GameObject BBNO;

	public GameObject Vanilla;

	public GameObject IronMouse;

	public DayNightProfile[] profiles;

	public static BBNOController instance;

	public double timelineStartTime;

	[SerializeField]
	private bool startedConcert;

	private PlayableDirector director;

	private bool isPaused;

	private void Awake()
	{
		instance = this;
		director = ((Component)this).GetComponent<PlayableDirector>();
		if ((Object)(object)director == (Object)null)
		{
			ManualLogSource log = Plugin.Log;
			if (log != null)
			{
				log.LogWarning((object)"BBNOController loaded without a PlayableDirector.");
			}
		}
		else
		{
			director.Play();
			director.Pause();
			director.stopped += OnStopped;
		}
	}

	private void OnStopped(PlayableDirector stoppedDirector)
	{
		((Component)this).gameObject.SetActive(false);
	}

	public void OnPlayerEnteredRoom(Player newPlayer)
	{
	}

	public void StartConcertNetworked()
	{
		if ((Object)(object)((MonoBehaviourPun)this).photonView != (Object)null)
		{
			((MonoBehaviourPun)this).photonView.RPC("SyncTime", (RpcTarget)0, new object[1] { timelineStartTime });
		}
		else
		{
			SyncTime(timelineStartTime);
		}
	}

	private void Update()
	{
		//IL_0021: Unknown result type (might be due to invalid IL or missing references)
		//IL_0027: Invalid comparison between Unknown and I4
		if (!((Object)(object)director == (Object)null))
		{
			if (Time.timeScale == 0f && (int)director.state == 1 && !isPaused)
			{
				isPaused = true;
				director.Pause();
			}
			else if (Time.timeScale != 0f && isPaused)
			{
				isPaused = false;
				director.Play();
			}
		}
	}

	private void StartConcert()
	{
		if (!startedConcert && !((Object)(object)director == (Object)null))
		{
			startedConcert = true;
			director.Play();
		}
	}

	public void MoveBBNOBeginning(float upAmount)
	{
		//IL_0002: 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)
		((MonoBehaviour)this).StartCoroutine(MoveBBNORoutine(Vector3.up * upAmount));
	}

	public void setProfile(int index)
	{
		if (profiles != null && index >= 0 && index < profiles.Length && !((Object)(object)DayNightManager.instance == (Object)null))
		{
			DayNightManager.instance.BlendProfiles(profiles[index]);
		}
	}

	public void DisableEdgeFog()
	{
		((MonoBehaviour)this).StartCoroutine(DisableEdgeFogRoutine());
	}

	public void enableBBNO(bool enable)
	{
		if ((Object)(object)BBNO != (Object)null)
		{
			BBNO.SetActive(enable);
		}
	}

	public override void OnDisable()
	{
		((MonoBehaviourPunCallbacks)this).OnDisable();
		Shader.SetGlobalFloat("NoEdgeFog", 0f);
	}

	[PunRPC]
	public void SyncTime(double time)
	{
		if (!startedConcert)
		{
			StartConcert();
		}
		if ((Object)(object)director != (Object)null)
		{
			director.time = time;
		}
	}

	private IEnumerator MoveBBNORoutine(Vector3 newPosition)
	{
		//IL_000e: Unknown result type (might be due to invalid IL or missing references)
		//IL_000f: Unknown result type (might be due to invalid IL or missing references)
		if (!((Object)(object)BBNO == (Object)null))
		{
			Vector3 currentPosition = BBNO.transform.position;
			float normalizedTime = 0f;
			while (normalizedTime < 1f)
			{
				normalizedTime += Time.deltaTime / 5f;
				BBNO.transform.position = Vector3.Lerp(currentPosition, currentPosition + newPosition, normalizedTime);
				yield return null;
			}
		}
	}

	private static IEnumerator DisableEdgeFogRoutine()
	{
		float normalizedTime = 0f;
		while (normalizedTime < 1f)
		{
			normalizedTime += Time.deltaTime;
			Shader.SetGlobalFloat("NoEdgeFog", normalizedTime);
			yield return null;
		}
	}
}
namespace BBNO_COS
{
	[BepInPlugin("buhe.peak.bbno.cos", "BBNO-COS", "1.0.9")]
	public sealed class Plugin : BaseUnityPlugin, IOnEventCallback
	{
		private sealed class StageVisualClone
		{
			private sealed class PoseBinding
			{
				private readonly Transform _source;

				private readonly Transform _target;

				public PoseBinding(Transform source, Transform target)
				{
					_source = source;
					_target = target;
				}

				public void Apply()
				{
					//IL_0029: Unknown result type (might be due to invalid IL or missing references)
					if (!((Object)(object)_source == (Object)null) && !((Object)(object)_target == (Object)null))
					{
						_target.localRotation = _source.localRotation;
					}
				}
			}

			private sealed class AnchorBinding
			{
				private readonly Transform _sourceAnchor;

				private readonly Transform _targetAnchor;

				private readonly Transform _cloneRoot;

				public AnchorBinding(Transform sourceAnchor, Transform targetAnchor, Transform cloneRoot)
				{
					_sourceAnchor = sourceAnchor;
					_targetAnchor = targetAnchor;
					_cloneRoot = cloneRoot;
				}

				public void Apply()
				{
					//IL_0032: Unknown result type (might be due to invalid IL or missing references)
					//IL_003d: Unknown result type (might be due to invalid IL or missing references)
					//IL_0048: 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)
					//IL_0052: Unknown result type (might be due to invalid IL or missing references)
					if (!((Object)(object)_sourceAnchor == (Object)null) && !((Object)(object)_targetAnchor == (Object)null) && !((Object)(object)_cloneRoot == (Object)null))
					{
						Transform cloneRoot = _cloneRoot;
						cloneRoot.position += _sourceAnchor.position - _targetAnchor.position;
					}
				}
			}

			private readonly Transform _stageRoot;

			private readonly GameObject _cloneObject;

			private readonly int _boundRendererCount;

			private readonly PoseBinding[] _poseBindings;

			private readonly AnchorBinding _anchorBinding;

			public int BoundRendererCount => _boundRendererCount;

			private StageVisualClone(Transform stageRoot, GameObject cloneObject, int boundRendererCount, PoseBinding[] poseBindings, AnchorBinding anchorBinding)
			{
				_stageRoot = stageRoot;
				_cloneObject = cloneObject;
				_boundRendererCount = boundRendererCount;
				_poseBindings = poseBindings ?? Array.Empty<PoseBinding>();
				_anchorBinding = anchorBinding;
			}

			public static StageVisualClone Create(Transform stageRoot, GameObject cloneObject)
			{
				//IL_0225: Unknown result type (might be due to invalid IL or missing references)
				//IL_022a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0234: Unknown result type (might be due to invalid IL or missing references)
				//IL_0239: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)stageRoot == (Object)null || (Object)(object)cloneObject == (Object)null)
				{
					return null;
				}
				SkinnedMeshRenderer[] stageRenderers = (from renderer in ((Component)stageRoot).GetComponentsInChildren<SkinnedMeshRenderer>(true)
					where (Object)(object)renderer != (Object)null && !IsChildOf(((Component)renderer).transform, cloneObject.transform)
					select renderer).ToArray();
				Dictionary<string, Transform> dictionary = new Dictionary<string, Transform>(StringComparer.OrdinalIgnoreCase);
				Transform[] componentsInChildren = ((Component)stageRoot).GetComponentsInChildren<Transform>(true);
				foreach (Transform val in componentsInChildren)
				{
					if (!((Object)(object)val == (Object)null) && !IsChildOf(val, cloneObject.transform))
					{
						string text = NormalizeTransformName(((Object)val).name);
						if (text.Length != 0 && !dictionary.ContainsKey(text))
						{
							dictionary.Add(text, val);
						}
					}
				}
				int num2 = 0;
				Dictionary<Transform, PoseBinding> dictionary2 = new Dictionary<Transform, PoseBinding>();
				AnchorBinding anchorBinding = null;
				int num3 = 0;
				SkinnedMeshRenderer[] componentsInChildren2 = cloneObject.GetComponentsInChildren<SkinnedMeshRenderer>(true);
				foreach (SkinnedMeshRenderer val2 in componentsInChildren2)
				{
					if ((Object)(object)val2 == (Object)null || val2.bones == null || val2.bones.Length == 0)
					{
						continue;
					}
					SkinnedMeshRenderer val3 = FindBestStageRenderer(val2, stageRenderers);
					IReadOnlyDictionary<string, Transform> readOnlyDictionary = BuildBoneMap(((Object)(object)val3 == (Object)null) ? null : val3.bones);
					int num4 = 0;
					for (int num5 = 0; num5 < val2.bones.Length; num5++)
					{
						Transform val4 = val2.bones[num5];
						string text2 = (((Object)(object)val4 == (Object)null) ? string.Empty : NormalizeTransformName(((Object)val4).name));
						if (text2.Length > 0 && ((readOnlyDictionary != null && readOnlyDictionary.TryGetValue(text2, out var value)) || dictionary.TryGetValue(text2, out value)))
						{
							if ((Object)(object)val4 != (Object)null && (Object)(object)value != (Object)null && !dictionary2.ContainsKey(val4))
							{
								dictionary2.Add(val4, new PoseBinding(value, val4));
							}
							int num6 = AnchorPriority(text2);
							if ((Object)(object)val4 != (Object)null && (Object)(object)value != (Object)null && num6 > num3)
							{
								anchorBinding = new AnchorBinding(value, val4, cloneObject.transform);
								num3 = num6;
							}
							num4++;
						}
					}
					if (num4 != 0)
					{
						((Renderer)val2).localBounds = new Bounds(Vector3.zero, Vector3.one * 10000f);
						val2.updateWhenOffscreen = true;
						ManualLogSource log = Log;
						if (log != null)
						{
							log.LogInfo((object)string.Format("Stage visual pose bind: '{0}' -> '{1}', matched bones {2}/{3}.", ((Object)val2).name, ((Object)(object)val3 == (Object)null) ? "global stage bones" : ((Object)val3).name, num4, val2.bones.Length));
						}
						num2++;
					}
				}
				return new StageVisualClone(stageRoot, cloneObject, num2, dictionary2.Values.ToArray(), anchorBinding);
			}

			private static SkinnedMeshRenderer FindBestStageRenderer(SkinnedMeshRenderer sourceRenderer, SkinnedMeshRenderer[] stageRenderers)
			{
				if ((Object)(object)sourceRenderer == (Object)null || stageRenderers == null || stageRenderers.Length == 0)
				{
					return null;
				}
				SkinnedMeshRenderer result = null;
				int num = 0;
				string text = NormalizeTransformName(((Object)sourceRenderer).name);
				string text2 = RendererCategory((Renderer)(object)sourceRenderer);
				int num2 = ((((Renderer)sourceRenderer).sharedMaterials != null) ? ((Renderer)sourceRenderer).sharedMaterials.Length : 0);
				foreach (SkinnedMeshRenderer val in stageRenderers)
				{
					if (!((Object)(object)val == (Object)null) && val.bones != null && val.bones.Length != 0)
					{
						int num3 = CountMatchingBones(sourceRenderer.bones, val.bones) * 4;
						if (text.Length > 0 && string.Equals(text, NormalizeTransformName(((Object)val).name), StringComparison.OrdinalIgnoreCase))
						{
							num3 += 80;
						}
						if (num2 > 0 && ((Renderer)val).sharedMaterials != null && ((Renderer)val).sharedMaterials.Length == num2)
						{
							num3 += 12;
						}
						string text3 = RendererCategory((Renderer)(object)val);
						if (text2.Length > 0 && text2 == text3)
						{
							num3 += 40;
						}
						if (num3 > num)
						{
							num = num3;
							result = val;
						}
					}
				}
				if (num < 12)
				{
					return null;
				}
				return result;
			}

			private static int CountMatchingBones(Transform[] sourceBones, Transform[] candidateBones)
			{
				if (sourceBones == null || candidateBones == null)
				{
					return 0;
				}
				HashSet<string> hashSet = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
				Transform[] array = candidateBones;
				foreach (Transform val in array)
				{
					string text = (((Object)(object)val == (Object)null) ? string.Empty : NormalizeTransformName(((Object)val).name));
					if (text.Length > 0)
					{
						hashSet.Add(text);
					}
				}
				int num = 0;
				array = sourceBones;
				foreach (Transform val2 in array)
				{
					string text2 = (((Object)(object)val2 == (Object)null) ? string.Empty : NormalizeTransformName(((Object)val2).name));
					if (text2.Length > 0 && hashSet.Contains(text2))
					{
						num++;
					}
				}
				return num;
			}

			private static IReadOnlyDictionary<string, Transform> BuildBoneMap(Transform[] bones)
			{
				if (bones == null || bones.Length == 0)
				{
					return null;
				}
				Dictionary<string, Transform> dictionary = new Dictionary<string, Transform>(StringComparer.OrdinalIgnoreCase);
				foreach (Transform val in bones)
				{
					string text = (((Object)(object)val == (Object)null) ? string.Empty : NormalizeTransformName(((Object)val).name));
					if (text.Length > 0 && !dictionary.ContainsKey(text))
					{
						dictionary.Add(text, val);
					}
				}
				return dictionary;
			}

			private static string RendererCategory(Renderer renderer)
			{
				if ((Object)(object)renderer == (Object)null)
				{
					return string.Empty;
				}
				string text = (((Object)renderer).name ?? string.Empty) + " " + string.Join(" ", (from material in renderer.sharedMaterials ?? Array.Empty<Material>()
					where (Object)(object)material != (Object)null
					select CleanMaterialName(((Object)material).name)).ToArray());
				if (text.IndexOf("skirt", StringComparison.OrdinalIgnoreCase) >= 0)
				{
					return "skirt";
				}
				if (text.IndexOf("short", StringComparison.OrdinalIgnoreCase) >= 0 || text.IndexOf("pant", StringComparison.OrdinalIgnoreCase) >= 0)
				{
					return "pants";
				}
				if (text.IndexOf("shoe", StringComparison.OrdinalIgnoreCase) >= 0 || text.IndexOf("boot", StringComparison.OrdinalIgnoreCase) >= 0 || text.IndexOf("sock", StringComparison.OrdinalIgnoreCase) >= 0)
				{
					return "feet";
				}
				if (text.IndexOf("sash", StringComparison.OrdinalIgnoreCase) >= 0 || text.IndexOf("badge", StringComparison.OrdinalIgnoreCase) >= 0)
				{
					return "sash";
				}
				if (text.IndexOf("eye", StringComparison.OrdinalIgnoreCase) >= 0)
				{
					return "eyes";
				}
				if (text.IndexOf("mouth", StringComparison.OrdinalIgnoreCase) >= 0)
				{
					return "mouth";
				}
				if (text.IndexOf("hair", StringComparison.OrdinalIgnoreCase) >= 0 || text.IndexOf("hat", StringComparison.OrdinalIgnoreCase) >= 0)
				{
					return "head";
				}
				if (text.IndexOf("skin", StringComparison.OrdinalIgnoreCase) >= 0 || text.IndexOf("scout", StringComparison.OrdinalIgnoreCase) >= 0 || text.IndexOf("fit", StringComparison.OrdinalIgnoreCase) >= 0 || text.IndexOf("outfit", StringComparison.OrdinalIgnoreCase) >= 0)
				{
					return "body";
				}
				return string.Empty;
			}

			public void UpdatePose()
			{
				//IL_0029: Unknown result type (might be due to invalid IL or missing references)
				//IL_0034: Unknown result type (might be due to invalid IL or missing references)
				//IL_003e: Unknown result type (might be due to invalid IL or missing references)
				if (!((Object)(object)_stageRoot == (Object)null) && !((Object)(object)_cloneObject == (Object)null))
				{
					Transform transform = _cloneObject.transform;
					transform.localPosition = Vector3.zero;
					transform.localRotation = Quaternion.identity;
					transform.localScale = Vector3.one;
					PoseBinding[] poseBindings = _poseBindings;
					for (int i = 0; i < poseBindings.Length; i++)
					{
						poseBindings[i].Apply();
					}
					_anchorBinding?.Apply();
				}
			}

			public void Destroy()
			{
				if ((Object)(object)_cloneObject != (Object)null)
				{
					Object.Destroy((Object)(object)_cloneObject);
				}
			}

			private static bool IsChildOf(Transform transform, Transform possibleParent)
			{
				while ((Object)(object)transform != (Object)null)
				{
					if ((Object)(object)transform == (Object)(object)possibleParent)
					{
						return true;
					}
					transform = transform.parent;
				}
				return false;
			}

			private static void ReparentStaticVisualRenderers(IReadOnlyDictionary<string, Transform> stageTransforms, GameObject cloneObject)
			{
				//IL_007e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0083: Unknown result type (might be due to invalid IL or missing references)
				//IL_0086: Unknown result type (might be due to invalid IL or missing references)
				//IL_008b: Unknown result type (might be due to invalid IL or missing references)
				//IL_008e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0093: Unknown result type (might be due to invalid IL or missing references)
				//IL_009f: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
				//IL_00af: Unknown result type (might be due to invalid IL or missing references)
				if (stageTransforms == null || (Object)(object)cloneObject == (Object)null)
				{
					return;
				}
				MeshRenderer[] componentsInChildren = cloneObject.GetComponentsInChildren<MeshRenderer>(true);
				foreach (MeshRenderer val in componentsInChildren)
				{
					if (!((Object)(object)val == (Object)null) && !((Object)(object)((Component)val).GetComponent<SkinnedMeshRenderer>() != (Object)null))
					{
						Transform transform = ((Component)val).transform;
						Transform parent = transform.parent;
						string text = (((Object)(object)parent == (Object)null) ? string.Empty : NormalizeTransformName(((Object)parent).name));
						if (text.Length != 0 && stageTransforms.TryGetValue(text, out var value))
						{
							Vector3 localPosition = transform.localPosition;
							Quaternion localRotation = transform.localRotation;
							Vector3 localScale = transform.localScale;
							transform.SetParent(value, false);
							transform.localPosition = localPosition;
							transform.localRotation = localRotation;
							transform.localScale = localScale;
						}
					}
				}
			}

			private static string NormalizeTransformName(string name)
			{
				if (string.IsNullOrWhiteSpace(name))
				{
					return string.Empty;
				}
				string text = name.Replace("(Clone)", string.Empty).Trim();
				int num = text.LastIndexOf('.');
				if (num > 0 && num < text.Length - 1)
				{
					bool flag = true;
					for (int i = num + 1; i < text.Length; i++)
					{
						if (!char.IsDigit(text[i]))
						{
							flag = false;
							break;
						}
					}
					if (flag)
					{
						text = text.Substring(0, num);
					}
				}
				return text;
			}

			private static int AnchorPriority(string normalizedName)
			{
				if (string.IsNullOrWhiteSpace(normalizedName))
				{
					return 0;
				}
				if (string.Equals(normalizedName, "root", StringComparison.OrdinalIgnoreCase))
				{
					return 4;
				}
				if (string.Equals(normalizedName, "hip", StringComparison.OrdinalIgnoreCase) || string.Equals(normalizedName, "hips", StringComparison.OrdinalIgnoreCase) || string.Equals(normalizedName, "pelvis", StringComparison.OrdinalIgnoreCase))
				{
					return 3;
				}
				if (normalizedName.IndexOf("spine", StringComparison.OrdinalIgnoreCase) >= 0)
				{
					return 2;
				}
				return 0;
			}
		}

		private sealed class PlayerOption
		{
			public string Key { get; }

			public string Label { get; }

			public PlayerOption(string key, string label)
			{
				Key = key;
				Label = label;
			}
		}

		private sealed class StageRendererSnapshot
		{
			private readonly Mesh _skinnedMesh;

			private readonly Mesh _filterMesh;

			private readonly bool _rendererEnabled;

			private readonly bool _gameObjectActive;

			public Renderer Renderer { get; }

			public Material[] SharedMaterials { get; }

			public StageRendererSnapshot(Renderer renderer)
			{
				Renderer = renderer;
				SharedMaterials = (((Object)(object)renderer == (Object)null || renderer.sharedMaterials == null) ? Array.Empty<Material>() : renderer.sharedMaterials.ToArray());
				_rendererEnabled = (Object)(object)renderer != (Object)null && renderer.enabled;
				_gameObjectActive = (Object)(object)renderer != (Object)null && ((Component)renderer).gameObject.activeSelf;
				SkinnedMeshRenderer val = (SkinnedMeshRenderer)(object)((renderer is SkinnedMeshRenderer) ? renderer : null);
				if ((Object)(object)val != (Object)null)
				{
					_skinnedMesh = val.sharedMesh;
				}
				MeshFilter val2 = (((Object)(object)renderer == (Object)null) ? null : ((Component)renderer).GetComponent<MeshFilter>());
				if ((Object)(object)val2 != (Object)null)
				{
					_filterMesh = val2.sharedMesh;
				}
			}

			public void Restore()
			{
				if (!((Object)(object)Renderer == (Object)null))
				{
					((Component)Renderer).gameObject.SetActive(_gameObjectActive);
					Renderer.enabled = _rendererEnabled;
					Renderer.sharedMaterials = SharedMaterials;
					Renderer.SetPropertyBlock((MaterialPropertyBlock)null);
					Renderer renderer = Renderer;
					SkinnedMeshRenderer val = (SkinnedMeshRenderer)(object)((renderer is SkinnedMeshRenderer) ? renderer : null);
					if ((Object)(object)val != (Object)null)
					{
						val.sharedMesh = _skinnedMesh;
					}
					MeshFilter component = ((Component)Renderer).GetComponent<MeshFilter>();
					if ((Object)(object)component != (Object)null)
					{
						component.sharedMesh = _filterMesh;
					}
				}
			}
		}

		public const string PluginGuid = "buhe.peak.bbno.cos";

		public const string PluginName = "BBNO-COS";

		public const string PluginVersion = "1.0.9";

		private const string BundleFileName = "peak_bbno_concert";

		private const string PreferredPrefabName = "BBNOConcertRoot";

		private const double OfficialConcertStartTime = 68.45;

		private const string OfficialSelectionKey = "official";

		private const string AuthorUrl = "https://jisuk.top";

		private const byte NetworkPlayEventCode = 57;

		private const byte NetworkStopEventCode = 58;

		private const float NativeDanceStepSeconds = 1.55f;

		private const int StageAppearanceRetryMaxAttempts = 60;

		private const float StageAppearanceRetryIntervalSeconds = 0.5f;

		private const double BackFlipLandingHoldSeconds = 0.08;

		private const float VolumeApplyEpsilon = 0.001f;

		private static readonly PropertyInfo GuiStyleFontProperty = typeof(GUIStyle).GetProperty("font");

		private static readonly MethodInfo ResourcesGetBuiltinResourceMethod = typeof(Resources).GetMethod("GetBuiltinResource", new Type[2]
		{
			typeof(Type),
			typeof(string)
		});

		internal static ManualLogSource Log;

		private AssetBundle _bundle;

		private GameObject _concertRoot;

		private PlayableDirector _director;

		private AudioSource[] _concertAudioSources = Array.Empty<AudioSource>();

		private float _lastAppliedConcertVolume = -1f;

		private bool _showPanel;

		private bool _panelEnglish;

		private bool _concertSkyActive;

		private Dictionary<string, Material> _borrowableMaterials;

		private Dictionary<string, Shader> _borrowableShaders;

		private bool _savedFogState;

		private float _savedAmbienceMaxFog;

		private bool _savedAmbienceUseFog;

		private bool _savedRenderSettingsFog;

		private FogMode _savedRenderSettingsFogMode;

		private float _savedRenderSettingsFogDensity;

		private Color _savedRenderSettingsFogColor;

		private float _savedUseFogGlobal;

		private float _savedMaxFogGlobal;

		private float _savedFogEnabledGlobal;

		private float _savedFogSphereSizeGlobal;

		private float _savedCloseDistanceModGlobal;

		private float _savedWeatherBlendGlobal;

		private float _savedWindFogDensityGlobal;

		private float _savedWindFogTextureDensityGlobal;

		private float _savedBandFogAmountGlobal;

		private float _savedExtraFogGlobal;

		private float _savedNoEdgeFogGlobal;

		private Vector4 _savedFogCenterGlobal;

		private float _savedFakeMountainEnabledGlobal;

		private ConfigEntry<float> _concertVolumeConfig;

		private ConfigEntry<string> _stageASelection;

		private ConfigEntry<string> _stageBSelection;

		private ConfigEntry<string> _stageCSelection;

		private ConfigEntry<bool> _enableStagePlayerReplacement;

		private ConfigEntry<bool> _startNativePlayerDanceWithConcert;

		private ConfigEntry<bool> _defaultEnglishPanel;

		private bool _bingBongRainBoostApplied;

		private bool _customizationCursorUnlocked;

		private CursorLockMode _previousCursorLockState;

		private bool _previousCursorVisible;

		private int _openStageDropdown = -1;

		private Vector2 _customizationScroll;

		private bool _nativePlayerDanceActive;

		private float _nativePlayerDanceNextStepTime;

		private int _nativePlayerDanceStepIndex;

		private bool _stageAppearanceRetryActive;

		private float _nextStageAppearanceRetryTime;

		private int _stageAppearanceRetryAttempts;

		private readonly Dictionary<string, StageRendererSnapshot[]> _stageOriginalMaterials = new Dictionary<string, StageRendererSnapshot[]>(StringComparer.OrdinalIgnoreCase);

		private readonly Dictionary<string, StageVisualClone> _stageVisualClones = new Dictionary<string, StageVisualClone>(StringComparer.OrdinalIgnoreCase);

		private static readonly string[] NativePlayerDanceSequence = new string[6] { "A_Scout_Emote_Dance1", "A_Scout_Emote_Dance2", "A_Scout_Emote_CrossedArms", "A_Scout_Emote_Nono", "A_Scout_Emote_Salute", "A_Scout_Emote_Flex" };

		private static readonly string[] PreferredStageHatOrder = new string[39]
		{
			"Cap", "Beret", "Fedora", "PropellerHat", "StrawHat", "AviatorHat", "SailorHat", "MedicHelmet", "Midsummer", "MushroomHat",
			"CrabHat", "CourierHat", "ScoutmasterHat", "Bandana", "NinjaHeadband", "ChefHat", "WizardHat", "WolfEars", "Crown", "Goat",
			"DesertHat", "SunVisorHat", "StrawSunHat", "CowboyHat", "BBHat", "Racing Helmet", "SpaceHelmet White", "PumpkinHead", "MummyHat", "Antlers",
			"GnomeHat", "PlagueDoctor", "ClimbingHelmet", "NumberOne", "FlowerHat", "Sprout", "Ironmouse", "Ice Hood Blue", "Ice Hood Pink"
		};

		private GUIStyle _panelBoxStyle;

		private GUIStyle _panelLabelStyle;

		private GUIStyle _panelButtonStyle;

		private bool _panelFallbackFontResolved;

		private object _panelFallbackFont;

		private bool _panelFallbackFontLogged;

		private void Awake()
		{
			Log = ((BaseUnityPlugin)this).Logger;
			_stageASelection = ((BaseUnityPlugin)this).Config.Bind<string>("Stage Model Mapping", "StageA", "official", "Dance model A selection. Use 'official' to keep the original concert model.");
			_stageBSelection = ((BaseUnityPlugin)this).Config.Bind<string>("Stage Model Mapping", "StageB", "official", "Dance model B selection. Use 'official' to keep the original concert model.");
			_stageCSelection = ((BaseUnityPlugin)this).Config.Bind<string>("Stage Model Mapping", "StageC", "official", "Dance model C selection. Use 'official' to keep the original concert model.");
			_enableStagePlayerReplacement = ((BaseUnityPlugin)this).Config.Bind<bool>("Stage Model Mapping", "EnablePlayerReplacement", true, "Enable the experimental stage actor customization mapping.");
			_startNativePlayerDanceWithConcert = ((BaseUnityPlugin)this).Config.Bind<bool>("Experimental Native Player Dance", "StartWithConcert", true, "Start the native player dance driver when F8 starts the official concert.");
			_defaultEnglishPanel = ((BaseUnityPlugin)this).Config.Bind<bool>("Panel", "DefaultEnglish", false, "Open the BBNO-COS panel in English by default. The in-game language button can still switch it.");
			_panelEnglish = _defaultEnglishPanel.Value;
			_concertVolumeConfig = ((BaseUnityPlugin)this).Config.Bind<float>("Audio", "ConcertVolume", 1f, "Concert playback volume (0.0 to 1.0).");
			GetConfiguredConcertVolume();
			PhotonNetwork.AddCallbackTarget((object)this);
			SceneManager.sceneUnloaded += OnSceneUnloaded;
			((BaseUnityPlugin)this).Logger.LogInfo((object)"BBNO-COS loaded. F8 plays the official concert prefab when the bundle exists.");
		}

		private void OnSceneUnloaded(Scene scene)
		{
			try
			{
				CleanupRuntimeState();
			}
			catch (Exception ex)
			{
				ManualLogSource log = Log;
				if (log != null)
				{
					log.LogWarning((object)("Error cleaning up runtime state on scene unload: " + ex.Message));
				}
			}
		}

		private void Update()
		{
			if (Input.GetKeyDown((KeyCode)289))
			{
				BroadcastAndPlayConcert();
			}
			if (Input.GetKeyDown((KeyCode)290))
			{
				BroadcastAndStopConcert();
			}
			if (Input.GetKeyDown((KeyCode)291))
			{
				_showPanel = !_showPanel;
			}
			if (IsCustomizationCursorKeyDown())
			{
				if (_customizationCursorUnlocked)
				{
					RestoreCustomizationCursor();
					_openStageDropdown = -1;
				}
				else
				{
					UnlockCustomizationCursor();
				}
			}
			if (_customizationCursorUnlocked)
			{
				UnlockCustomizationCursor();
			}
		}

		private void LateUpdate()
		{
			if (_customizationCursorUnlocked)
			{
				UnlockCustomizationCursor();
			}
			if (_concertSkyActive)
			{
				ApplyConcertSky();
				ApplyConcertFogOverride();
				ApplyBingBongRainBoost();
				UpdateStageVisualClones();
				RetryPendingStageAppearanceApply();
				if (_concertVolumeConfig != null)
				{
					UpdateConcertVolume(GetConfiguredConcertVolume());
				}
			}
		}

		private void OnDisable()
		{
			CleanupRuntimeState();
		}

		private void OnDestroy()
		{
			PhotonNetwork.RemoveCallbackTarget((object)this);
			SceneManager.sceneUnloaded -= OnSceneUnloaded;
			CleanupRuntimeState();
		}

		private void BroadcastAndPlayConcert()
		{
			RaiseConcertNetworkEvent(57, SelectionKeyToActorNumber(_stageASelection.Value), SelectionKeyToActorNumber(_stageBSelection.Value), SelectionKeyToActorNumber(_stageCSelection.Value));
			PlayConcert();
			ScheduleStageAppearanceRetryIfNeeded("local play");
		}

		private void BroadcastAndStopConcert()
		{
			RaiseConcertNetworkEvent(58, 0, 0, 0);
			StopConcert();
		}

		private void RaiseConcertNetworkEvent(byte eventCode, int stageAActor, int stageBActor, int stageCActor)
		{
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Expected O, but got Unknown
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if (PhotonNetwork.InRoom)
				{
					object[] array = new object[5]
					{
						stageAActor,
						stageBActor,
						stageCActor,
						(PhotonNetwork.LocalPlayer != null) ? PhotonNetwork.LocalPlayer.ActorNumber : 0,
						PhotonNetwork.Time
					};
					RaiseEventOptions val = new RaiseEventOptions
					{
						Receivers = (ReceiverGroup)0
					};
					bool flag = PhotonNetwork.RaiseEvent(eventCode, (object)array, val, SendOptions.SendReliable);
					ManualLogSource log = Log;
					if (log != null)
					{
						log.LogInfo((object)$"Broadcast BBNO-COS network event {eventCode}: raised={flag}, A={stageAActor}, B={stageBActor}, C={stageCActor}.");
					}
				}
			}
			catch (Exception ex)
			{
				ManualLogSource log2 = Log;
				if (log2 != null)
				{
					log2.LogWarning((object)("Failed to broadcast BBNO-COS network event: " + ex.Message));
				}
			}
		}

		public void OnEvent(EventData photonEvent)
		{
			if (photonEvent == null)
			{
				return;
			}
			if (photonEvent.Code == 57)
			{
				ApplyNetworkConcertPlay(photonEvent.CustomData as object[]);
			}
			else if (photonEvent.Code == 58)
			{
				ManualLogSource log = Log;
				if (log != null)
				{
					log.LogInfo((object)"Received BBNO-COS network stop event.");
				}
				StopConcert();
			}
		}

		private void ApplyNetworkConcertPlay(object[] payload)
		{
			try
			{
				if (payload == null || payload.Length < 3)
				{
					ManualLogSource log = Log;
					if (log != null)
					{
						log.LogWarning((object)"Received invalid BBNO-COS play event payload.");
					}
					return;
				}
				int num = Convert.ToInt32(payload[0]);
				int num2 = Convert.ToInt32(payload[1]);
				int num3 = Convert.ToInt32(payload[2]);
				_stageASelection.Value = ActorNumberToSelectionKey(num);
				_stageBSelection.Value = ActorNumberToSelectionKey(num2);
				_stageCSelection.Value = ActorNumberToSelectionKey(num3);
				_openStageDropdown = -1;
				ManualLogSource log2 = Log;
				if (log2 != null)
				{
					log2.LogInfo((object)$"Received BBNO-COS network play event: A={num}, B={num2}, C={num3}.");
				}
				PlayConcert();
				ScheduleStageAppearanceRetryIfNeeded("network play");
			}
			catch (Exception ex)
			{
				ManualLogSource log3 = Log;
				if (log3 != null)
				{
					log3.LogWarning((object)("Failed to apply BBNO-COS network play event: " + ex.Message));
				}
			}
		}

		private void PlayConcert()
		{
			DestroyConcertInstance();
			if (EnsureConcertLoaded())
			{
				_concertRoot.SetActive(true);
				if ((Object)(object)_director == (Object)null)
				{
					_concertRoot.SetActive(false);
					Log.LogWarning((object)"Concert prefab has no PlayableDirector, so there is nothing to play yet.");
					return;
				}
				PrepareConcertDirectorForPlayback();
				ApplySelectedStageAppearances();
				_director.time = 68.45;
				_director.Evaluate();
				_director.Play();
				CaptureConcertFogState();
				_concertSkyActive = true;
				ApplyConcertSky();
				ApplyConcertFogOverride();
				Log.LogInfo((object)$"Started BBNO official Timeline at {68.45:0.00}s.");
			}
		}

		private static int SelectionKeyToActorNumber(string selectionKey)
		{
			if (string.IsNullOrWhiteSpace(selectionKey) || string.Equals(selectionKey, "official", StringComparison.OrdinalIgnoreCase))
			{
				return 0;
			}
			return GetCharacterActorNumber(FindCharacterByKey(selectionKey));
		}

		private static string ActorNumberToSelectionKey(int actorNumber)
		{
			if (actorNumber > 0)
			{
				return "actor:" + actorNumber;
			}
			return "official";
		}

		private void PrepareConcertDirectorForPlayback()
		{
			if (!((Object)(object)_director == (Object)null))
			{
				_director.Stop();
				PatchBackFlipTimelineContinuity(_director);
				ResetConcertAnimatorState();
				_director.time = 0.0;
				_director.Evaluate();
				_director.Play();
				_director.Pause();
				_director.time = 68.45;
				_director.Evaluate();
			}
		}

		private static void PatchBackFlipTimelineContinuity(PlayableDirector director)
		{
			PlayableAsset playableAsset = director.playableAsset;
			TimelineAsset val = (TimelineAsset)(object)((playableAsset is TimelineAsset) ? playableAsset : null);
			if (val == null)
			{
				return;
			}
			TimelineClip val2 = null;
			TimelineClip val3 = null;
			foreach (TrackAsset outputTrack in val.GetOutputTracks())
			{
				if ((Object)(object)outputTrack == (Object)null)
				{
					continue;
				}
				foreach (TimelineClip clip in outputTrack.GetClips())
				{
					if (clip != null)
					{
						if (string.Equals(clip.displayName, "A_Scout_Emote_BackFlip", StringComparison.Ordinal) && IsNear(clip.start, 189.1, 0.02))
						{
							val2 = clip;
						}
						if (string.Equals(clip.displayName, "A_Scout_Emote_BackFlip", StringComparison.Ordinal))
						{
							RetimingBackFlipClipToFullLength(clip);
							clip.blendInDuration = 0.0;
							clip.blendOutDuration = 0.0;
						}
						else if (string.Equals(clip.displayName, "A_Scout_Emote_Dance1", StringComparison.Ordinal) && IsNear(clip.start, 189.1945518909643, 0.02))
						{
							val3 = clip;
						}
					}
				}
			}
			if (val2 != null && val3 != null)
			{
				double start = val2.start + val2.duration + 0.08;
				double start2 = val3.start;
				val3.start = start;
				val3.blendInDuration = 0.0;
				val2.blendOutDuration = 0.0;
				Log.LogInfo((object)$"Patched BBNO BackFlip continuity: moved Dance1 from {start2:0.000}s to {val3.start:0.000}s ({0.08:0.00}s landing hold, 0 blend).");
			}
		}

		private static void RetimingBackFlipClipToFullLength(TimelineClip clip)
		{
			if (clip == null || clip.duration <= 0.0)
			{
				return;
			}
			Object asset = clip.asset;
			AnimationPlayableAsset val = (AnimationPlayableAsset)(object)((asset is AnimationPlayableAsset) ? asset : null);
			if (val != null && !((Object)(object)val.clip == (Object)null))
			{
				double num = val.clip.length;
				if (!(num <= 0.0) && !(clip.duration * clip.timeScale >= num * 0.98))
				{
					double timeScale = clip.timeScale;
					clip.clipIn = 0.0;
					clip.timeScale = num / clip.duration;
					Log.LogInfo((object)$"Retimed BBNO BackFlip at {clip.start:0.000}s from timeScale {timeScale:0.000000} to {clip.timeScale:0.000000} so the full landing plays.");
				}
			}
		}

		private static bool IsNear(double value, double target, double tolerance)
		{
			return Math.Abs(value - target) <= tolerance;
		}

		private void ResetConcertAnimatorState()
		{
			if ((Object)(object)_concertRoot == (Object)null)
			{
				return;
			}
			Animator[] componentsInChildren = _concertRoot.GetComponentsInChildren<Animator>(true);
			foreach (Animator val in componentsInChildren)
			{
				if (!((Object)(object)val == (Object)null))
				{
					val.cullingMode = (AnimatorCullingMode)0;
					val.updateMode = (AnimatorUpdateMode)0;
					val.Rebind();
					val.Update(0f);
				}
			}
			SkinnedMeshRenderer[] componentsInChildren2 = _concertRoot.GetComponentsInChildren<SkinnedMeshRenderer>(true);
			foreach (SkinnedMeshRenderer val2 in componentsInChildren2)
			{
				if ((Object)(object)val2 != (Object)null)
				{
					val2.updateWhenOffscreen = true;
				}
			}
		}

		private void StopConcert()
		{
			ClearStageAppearanceRetry();
			if ((Object)(object)_director != (Object)null)
			{
				_director.Stop();
			}
			if ((Object)(object)_concertRoot != (Object)null)
			{
				_concertRoot.SetActive(false);
			}
			_concertSkyActive = false;
			ResetConcertSky();
			RestoreConcertFogState();
			StopNativePlayerDance();
			DestroyConcertInstance();
		}

		private void CleanupRuntimeState()
		{
			bool num = _concertSkyActive || _savedFogState;
			RestoreCustomizationCursor();
			_openStageDropdown = -1;
			ClearStageAppearanceRetry();
			if ((Object)(object)_director != (Object)null)
			{
				_director.Stop();
			}
			if ((Object)(object)_concertRoot != (Object)null)
			{
				_concertRoot.SetActive(false);
			}
			_concertSkyActive = false;
			if (num)
			{
				ResetConcertSky();
				RestoreConcertFogState();
			}
			StopNativePlayerDance();
			RestoreAllStageOriginalMaterials();
			DestroyConcertInstance();
		}

		private void DestroyConcertInstance()
		{
			DestroyAllStageVisualClones();
			_stageOriginalMaterials.Clear();
			if ((Object)(object)_director != (Object)null)
			{
				_director.Stop();
				_director = null;
			}
			if ((Object)(object)_concertRoot != (Object)null)
			{
				_concertRoot.SetActive(false);
				Object.Destroy((Object)(object)_concertRoot);
				_concertRoot = null;
			}
			_concertAudioSources = Array.Empty<AudioSource>();
			_lastAppliedConcertVolume = -1f;
		}

		private void UnlockCustomizationCursor()
		{
			//IL_0009: 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)
			if (!_customizationCursorUnlocked)
			{
				_previousCursorLockState = Cursor.lockState;
				_previousCursorVisible = Cursor.visible;
				_customizationCursorUnlocked = true;
			}
			Cursor.lockState = (CursorLockMode)0;
			Cursor.visible = true;
		}

		private void RestoreCustomizationCursor()
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			if (_customizationCursorUnlocked)
			{
				Cursor.lockState = _previousCursorLockState;
				Cursor.visible = _previousCursorVisible;
				_customizationCursorUnlocked = false;
			}
		}

		private static bool IsCustomizationCursorKeyDown()
		{
			if (Input.GetKeyDown((KeyCode)96))
			{
				return true;
			}
			try
			{
				return Input.GetKeyDown("`") || Input.GetKeyDown("~");
			}
			catch
			{
				return false;
			}
		}

		private void InitPanelStyles()
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Expected O, but got Unknown
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Expected O, but got Unknown
			//IL_003c: 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_004d: Expected O, but got Unknown
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			//IL_014e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0163: Unknown result type (might be due to invalid IL or missing references)
			//IL_0178: Unknown result type (might be due to invalid IL or missing references)
			//IL_018d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_020b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0220: Unknown result type (might be due to invalid IL or missing references)
			//IL_0235: Unknown result type (might be due to invalid IL or missing references)
			//IL_024a: Unknown result type (might be due to invalid IL or missing references)
			//IL_025f: Unknown result type (might be due to invalid IL or missing references)
			_panelBoxStyle = new GUIStyle(GUI.skin.box);
			_panelLabelStyle = new GUIStyle(GUI.skin.label)
			{
				clipping = (TextClipping)1
			};
			_panelButtonStyle = new GUIStyle(GUI.skin.button)
			{
				clipping = (TextClipping)1
			};
			ApplyPanelFont(_panelBoxStyle);
			ApplyPanelFont(_panelLabelStyle);
			ApplyPanelFont(_panelButtonStyle);
			_panelBoxStyle.normal.textColor = Color.white;
			_panelBoxStyle.focused.textColor = Color.white;
			_panelBoxStyle.active.textColor = Color.white;
			_panelBoxStyle.hover.textColor = Color.white;
			_panelBoxStyle.onNormal.textColor = Color.white;
			_panelBoxStyle.onFocused.textColor = Color.white;
			_panelBoxStyle.onActive.textColor = Color.white;
			_panelBoxStyle.onHover.textColor = Color.white;
			_panelLabelStyle.normal.textColor = Color.white;
			_panelLabelStyle.focused.textColor = Color.white;
			_panelLabelStyle.active.textColor = Color.white;
			_panelLabelStyle.hover.textColor = Color.white;
			_panelLabelStyle.onNormal.textColor = Color.white;
			_panelLabelStyle.onFocused.textColor = Color.white;
			_panelLabelStyle.onActive.textColor = Color.white;
			_panelLabelStyle.onHover.textColor = Color.white;
			_panelButtonStyle.normal.textColor = Color.white;
			_panelButtonStyle.focused.textColor = Color.white;
			_panelButtonStyle.active.textColor = Color.white;
			_panelButtonStyle.hover.textColor = Color.white;
			_panelButtonStyle.onNormal.textColor = Color.white;
			_panelButtonStyle.onFocused.textColor = Color.white;
			_panelButtonStyle.onActive.textColor = Color.white;
			_panelButtonStyle.onHover.textColor = Color.white;
		}

		private void ApplyPanelFont(GUIStyle style)
		{
			if (style == null)
			{
				return;
			}
			try
			{
				if (!(GuiStyleFontProperty == null))
				{
					GuiStyleFontProperty.SetValue(style, ResolvePanelFallbackFont(), null);
				}
			}
			catch (Exception ex)
			{
				if (!_panelFallbackFontLogged)
				{
					_panelFallbackFontLogged = true;
					ManualLogSource log = Log;
					if (log != null)
					{
						log.LogWarning((object)("Failed to apply BBNO-COS panel font fallback: " + ex.Message));
					}
				}
			}
		}

		private object ResolvePanelFallbackFont()
		{
			if (_panelFallbackFontResolved)
			{
				return _panelFallbackFont;
			}
			_panelFallbackFontResolved = true;
			try
			{
				Type type = GuiStyleFontProperty?.PropertyType ?? Type.GetType("UnityEngine.Font, UnityEngine.TextRenderingModule");
				if (type == null)
				{
					return null;
				}
				if (ResourcesGetBuiltinResourceMethod != null)
				{
					string[] array = new string[2] { "Arial.ttf", "LegacyRuntime.ttf" };
					foreach (string text in array)
					{
						object obj = ResourcesGetBuiltinResourceMethod.Invoke(null, new object[2] { type, text });
						if (obj != null)
						{
							_panelFallbackFont = obj;
							ManualLogSource log = Log;
							if (log != null)
							{
								log.LogInfo((object)("BBNO-COS panel using IMGUI font fallback: " + text));
							}
							return _panelFallbackFont;
						}
					}
				}
			}
			catch (Exception ex)
			{
				if (!_panelFallbackFontLogged)
				{
					_panelFallbackFontLogged = true;
					ManualLogSource log2 = Log;
					if (log2 != null)
					{
						log2.LogWarning((object)("Failed to resolve BBNO-COS panel font fallback: " + ex.Message));
					}
				}
			}
			return null;
		}

		private void OnGUI()
		{
			if (!_showPanel)
			{
				return;
			}
			InitPanelStyles();
			try
			{
				DrawMainPanel();
			}
			catch (Exception ex)
			{
				ManualLogSource log = Log;
				if (log != null)
				{
					log.LogWarning((object)("Failed to draw BBNO-COS panel: " + ex.Message));
				}
			}
		}

		private void DrawMainPanel()
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e5: Unknown result type (might be due to invalid IL or missing references)
			List<PlayerOption> list = BuildPlayerOptions();
			GUILayout.BeginArea(new Rect(20f, 20f, 470f, 345f), _panelBoxStyle);
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			GUILayout.Label(PanelText("PEAK BBNO$ 演唱会 COS", "PEAK BBNO$ Concert COS"), _panelLabelStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Width(225f),
				GUILayout.Height(22f)
			});
			if (GUILayout.Button(PanelText("作者:KK还要玩,不鹤", "Author: KK还要玩, 不鹤"), _panelButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Width(160f),
				GUILayout.Height(22f)
			}))
			{
				Application.OpenURL("https://jisuk.top");
			}
			if (GUILayout.Button(_panelEnglish ? "中文" : "English", _panelButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Width(70f),
				GUILayout.Height(22f)
			}))
			{
				_panelEnglish = !_panelEnglish;
			}
			GUILayout.EndHorizontal();
			GUILayout.Label(PanelText("F8 播放演唱会    F9 停止    F10 隐藏/显示面板", "F8 Play concert    F9 Stop    F10 Show/hide panel"), _panelLabelStyle, Array.Empty<GUILayoutOption>());
			GUILayout.Label(_customizationCursorUnlocked ? PanelText($"鼠标已解锁（` 键切换）    玩家数：{Mathf.Max(0, list.Count - 1)}", $"Cursor unlocked (` to toggle)    Players: {Mathf.Max(0, list.Count - 1)}") : PanelText($"按 ` 解锁鼠标选择角色    玩家数：{Mathf.Max(0, list.Count - 1)}", $"Press ` to unlock cursor    Players: {Mathf.Max(0, list.Count - 1)}"), _panelLabelStyle, Array.Empty<GUILayoutOption>());
			_customizationScroll = GUILayout.BeginScrollView(_customizationScroll, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(140f) });
			DrawStageSelectionRow(0, PanelText("舞蹈 A", "Dance A"), _stageASelection, list);
			DrawStageSelectionRow(1, PanelText("舞蹈 B", "Dance B"), _stageBSelection, list);
			DrawStageSelectionRow(2, PanelText("舞蹈 C", "Dance C"), _stageCSelection, list);
			GUILayout.EndScrollView();
			GUILayout.BeginHorizontal(_panelBoxStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(30f) });
			GUILayout.Label(PanelText("演唱会音量", "Concert Volume"), _panelLabelStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(110f) });
			float configuredConcertVolume = GetConfiguredConcertVolume();
			float num = Mathf.Clamp01(GUILayout.HorizontalSlider(configuredConcertVolume, 0f, 1f, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(250f) }));
			GUILayout.Space(10f);
			GUILayout.Label($"{(int)(num * 100f)}%", _panelLabelStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(40f) });
			if (Mathf.Abs(num - configuredConcertVolume) > 0.01f)
			{
				_concertVolumeConfig.Value = num;
				((BaseUnityPlugin)this).Config.Save();
				UpdateConcertVolume(num);
			}
			GUILayout.EndHorizontal();
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			GUILayout.FlexibleSpace();
			GUILayout.Label(PanelText("本模组免费", "This mod is free"), _panelLabelStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(26f) });
			GUILayout.FlexibleSpace();
			GUILayout.EndHorizontal();
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			if (GUILayout.Button(PanelText("全部恢复官方原版", "Restore official models"), _panelButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Width(300f),
				GUILayout.Height(26f)
			}))
			{
				_stageASelection.Value = "official";
				_stageBSelection.Value = "official";
				_stageCSelection.Value = "official";
				((BaseUnityPlugin)this).Config.Save();
				_openStageDropdown = -1;
			}
			GUILayout.Label(PanelText($"当前可选玩家：{Mathf.Max(0, list.Count - 1)}", $"Available players: {Mathf.Max(0, list.Count - 1)}"), _panelLabelStyle, Array.Empty<GUILayoutOption>());
			GUILayout.EndHorizontal();
			GUILayout.EndArea();
		}

		private string PanelText(string chinese, string english)
		{
			if (!_panelEnglish)
			{
				return chinese;
			}
			return english;
		}

		private void DrawStageSelectionRow(int stageIndex, string label, ConfigEntry<string> selection, List<PlayerOption> options)
		{
			GUILayout.BeginVertical(_panelBoxStyle, Array.Empty<GUILayoutOption>());
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			GUILayout.Label(label, _panelLabelStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(110f) });
			if (GUILayout.Button(GetOptionLabel(selection.Value, options), _panelButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(300f) }))
			{
				_openStageDropdown = ((_openStageDropdown == stageIndex) ? (-1) : stageIndex);
			}
			GUILayout.EndHorizontal();
			if (_openStageDropdown == stageIndex)
			{
				foreach (PlayerOption option in options)
				{
					GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
					GUILayout.Space(110f);
					if (GUILayout.Button(option.Label, _panelButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
					{
						GUILayout.Width(300f),
						GUILayout.Height(24f)
					}))
					{
						selection.Value = option.Key;
						((BaseUnityPlugin)this).Config.Save();
						_openStageDropdown = -1;
					}
					GUILayout.EndHorizontal();
				}
			}
			GUILayout.EndVertical();
		}

		private string GetOptionLabel(string key, List<PlayerOption> options)
		{
			PlayerOption playerOption = options.FirstOrDefault((PlayerOption playerOption2) => string.Equals(playerOption2.Key, key, StringComparison.OrdinalIgnoreCase));
			if (playerOption != null)
			{
				return playerOption.Label;
			}
			Character val = FindCharacterByKey(key);
			if (!((Object)(object)val == (Object)null))
			{
				return CharacterDisplayName(val);
			}
			return PanelText("玩家不存在（" + key + "）", "Player missing (" + key + ")");
		}

		private List<PlayerOption> BuildPlayerOptions()
		{
			List<PlayerOption> list = new List<PlayerOption>
			{
				new PlayerOption("official", PanelText("官方原版", "Official original"))
			};
			foreach (Character item in SnapshotCharacters().Where(IsSelectablePlayerCharacter).OrderByDescending(IsLocalCharacter).ThenBy((Character character) => GetCharacterActorNumber(character)))
			{
				string key = CharacterKey(item);
				if (!string.IsNullOrWhiteSpace(key) && !list.Any((PlayerOption option) => option.Key == key))
				{
					string text = CharacterDisplayName(item);
					list.Add(new PlayerOption(key, IsLocalCharacter(item) ? (text + PanelText("（自己）", " (You)")) : text));
				}
			}
			return list;
		}

		private static IEnumerable<Character> SnapshotCharacters()
		{
			try
			{
				IEnumerable<Character> result;
				if (Character.AllCharacters != null)
				{
					IEnumerable<Character> enumerable = Character.AllCharacters.ToArray();
					result = enumerable;
				}
				else
				{
					result = Enumerable.Empty<Character>();
				}
				return result;
			}
			catch
			{
				return Enumerable.Empty<Character>();
			}
		}

		private static bool IsSelectablePlayerCharacter(Character character)
		{
			try
			{
				return (Object)(object)character != (Object)null && (Object)(object)((Component)character).gameObject != (Object)null && !character.isBot;
			}
			catch
			{
				return false;
			}
		}

		private static bool IsLocalCharacter(Character character)
		{
			try
			{
				return (Object)(object)character != (Object)null && character.IsLocal;
			}
			catch
			{
				return false;
			}
		}

		private static string CharacterKey(Character character)
		{
			if ((Object)(object)character == (Object)null)
			{
				return string.Empty;
			}
			if (IsLocalCharacter(character))
			{
				return "local";
			}
			try
			{
				if ((Object)(object)((MonoBehaviourPun)character).photonView != (Object)null && ((MonoBehaviourPun)character).photonView.Owner != null)
				{
					string userId = ((MonoBehaviourPun)character).photonView.Owner.UserId;
					if (!string.IsNullOrWhiteSpace(userId))
					{
						return "uid:" + userId;
					}
					return "actor:" + ((MonoBehaviourPun)character).photonView.Owner.ActorNumber;
				}
			}
			catch
			{
			}
			return "name:" + character.characterName;
		}

		private static Character FindCharacterByKey(string key)
		{
			if (string.IsNullOrWhiteSpace(key) || string.Equals(key, "official", StringComparison.OrdinalIgnoreCase))
			{
				return null;
			}
			foreach (Character item in SnapshotCharacters())
			{
				if (IsSelectablePlayerCharacter(item) && CharacterMatchesKey(item, key))
				{
					return item;
				}
			}
			return null;
		}

		private static bool CharacterMatchesKey(Character character, string key)
		{
			if ((Object)(object)character == (Object)null || string.IsNullOrWhiteSpace(key))
			{
				return false;
			}
			if (string.Equals(CharacterKey(character), key, StringComparison.OrdinalIgnoreCase))
			{
				return true;
			}
			if (string.Equals(key, "local", StringComparison.OrdinalIgnoreCase))
			{
				return IsLocalCharacter(character);
			}
			if (TryParseActorSelectionKey(key, out var actorNumber))
			{
				return GetCharacterActorNumber(character) == actorNumber;
			}
			return false;
		}

		private static bool TryParseActorSelectionKey(string key, out int actorNumber)
		{
			actorNumber = 0;
			if (string.IsNullOrWhiteSpace(key) || !key.StartsWith("actor:", StringComparison.OrdinalIgnoreCase))
			{
				return false;
			}
			return int.TryParse(key.Substring("actor:".Length), out actorNumber);
		}

		private static int GetCharacterActorNumber(Character character)
		{
			try
			{
				return ((Object)(object)character != (Object)null && (Object)(object)((MonoBehaviourPun)character).photonView != (Object)null && ((MonoBehaviourPun)character).photonView.Owner != null) ? ((MonoBehaviourPun)character).photonView.Owner.ActorNumber : int.MaxValue;
			}
			catch
			{
				return int.MaxValue;
			}
		}

		private static string CharacterDisplayName(Character character)
		{
			try
			{
				string characterName = character.characterName;
				if (!string.IsNullOrWhiteSpace(characterName))
				{
					return characterName;
				}
			}
			catch
			{
			}
			return $"Player {GetCharacterActorNumber(character)}";
		}

		private void ToggleNativePlayerDance()
		{
			if (_nativePlayerDanceActive)
			{
				StopNativePlayerDance();
			}
			else
			{
				StartNativePlayerDance();
			}
		}

		private void StartNativePlayerDance()
		{
			_nativePlayerDanceActive = true;
			_nativePlayerDanceStepIndex = 0;
			_nativePlayerDanceNextStepTime = 0f;
			UpdateNativePlayerDance();
			ManualLogSource log = Log;
			if (log != null)
			{
				log.LogInfo((object)"Native player dance driver started.");
			}
		}

		private void StopNativePlayerDance()
		{
			if (!_nativePlayerDanceActive)
			{
				return;
			}
			_nativePlayerDanceActive = false;
			foreach (Character item in SnapshotCharacters().Where(IsSelectablePlayerCharacter))
			{
				TrySetNativePlayerEmote(item, enabled: false);
			}
			ManualLogSource log = Log;
			if (log != null)
			{
				log.LogInfo((object)"Native player dance driver stopped.");
			}
		}

		private void UpdateNativePlayerDance()
		{
			if (!_nativePlayerDanceActive || Time.time < _nativePlayerDanceNextStepTime)
			{
				return;
			}
			_nativePlayerDanceNextStepTime = Time.time + 1.55f;
			int num = 0;
			foreach (Character item in SnapshotCharacters().Where(IsSelectablePlayerCharacter))
			{
				int num2 = Mathf.Abs(GetCharacterActorNumber(item));
				string animationName = NativePlayerDanceSequence[(_nativePlayerDanceStepIndex + num2) % NativePlayerDanceSequence.Length];
				if (TryPlayNativePlayerDance(item, animationName))
				{
					num++;
				}
			}
			_nativePlayerDanceStepIndex++;
			if (num == 0)
			{
				ManualLogSource log = Log;
				if (log != null)
				{
					log.LogWarning((object)"Native player dance driver found no playable player animator states this step.");
				}
			}
		}

		private static bool TryPlayNativePlayerDance(Character character, string animationName)
		{
			try
			{
				Animator val = (((Object)(object)character == (Object)null || character.refs == null) ? null : character.refs.animator);
				if ((Object)(object)val == (Object)null || string.IsNullOrWhiteSpace(animationName))
				{
					return false;
				}
				if (!HasAnimatorState(val, animationName))
				{
					return false;
				}
				val.cullingMode = (AnimatorCullingMode)0;
				val.updateMode = (AnimatorUpdateMode)0;
				val.SetBool("Emote", true);
				val.Play(animationName, 0, 0f);
				val.Update(0f);
				return true;
			}
			catch (Exception ex)
			{
				ManualLogSource log = Log;
				if (log != null)
				{
					log.LogWarning((object)("Native player dance failed for '" + animationName + "': " + ex.Message));
				}
				return false;
			}
		}

		private static bool HasAnimatorState(Animator animator, string stateName)
		{
			if ((Object)(object)animator == (Object)null || string.IsNullOrWhiteSpace(stateName))
			{
				return false;
			}
			if (!animator.HasState(0, Animator.StringToHash(stateName)))
			{
				return animator.HasState(0, Animator.StringToHash("Base Layer." + stateName));
			}
			return true;
		}

		private static void TrySetNativePlayerEmote(Character character, bool enabled)
		{
			try
			{
				Animator val = (((Object)(object)character == (Object)null || character.refs == null) ? null : character.refs.animator);
				if ((Object)(object)val != (Object)null)
				{
					val.SetBool("Emote", enabled);
				}
			}
			catch
			{
			}
		}

		private void ApplySelectedStageAppearances()
		{
			ApplyStageAppearance("Dance Model A", "BBNO Parent", _stageASelection.Value);
			ApplyStageAppearance("Dance Model B", "IronMouseParent", _stageBSelection.Value);
			ApplyStageAppearance("Dance Model C", "Vanilla Parent", _stageCSelection.Value);
		}

		private void ScheduleStageAppearanceRetryIfNeeded(string reason)
		{
			if (!HasUnresolvedStageSelection())
			{
				_stageAppearanceRetryActive = false;
				return;
			}
			_stageAppearanceRetryActive = true;
			_stageAppearanceRetryAttempts = 0;
			_nextStageAppearanceRetryTime = Time.time + 0.5f;
			ManualLogSource log = Log;
			if (log != null)
			{
				log.LogInfo((object)("Scheduled BBNO-COS stage appearance retry after " + reason + ": " + DescribeStageSelections() + "."));
			}
		}

		private void RetryPendingStageAppearanceApply()
		{
			if (!_stageAppearanceRetryActive || Time.time < _nextStageAppearanceRetryTime)
			{
				return;
			}
			if ((Object)(object)_concertRoot == (Object)null || !_concertRoot.activeInHierarchy)
			{
				ClearStageAppearanceRetry();
				return;
			}
			_stageAppearanceRetryAttempts++;
			if (!HasUnresolvedStageSelection())
			{
				ApplySelectedStageAppearances();
				ClearStageAppearanceRetry();
				ManualLogSource log = Log;
				if (log != null)
				{
					log.LogInfo((object)$"BBNO-COS stage appearance retry resolved after {_stageAppearanceRetryAttempts} attempt(s).");
				}
			}
			else if (_stageAppearanceRetryAttempts >= 60)
			{
				ManualLogSource log2 = Log;
				if (log2 != null)
				{
					log2.LogWarning((object)("BBNO-COS stage appearance retry expired with unresolved selection(s): " + DescribeStageSelections() + "."));
				}
				ClearStageAppearanceRetry();
			}
			else
			{
				_nextStageAppearanceRetryTime = Time.time + 0.5f;
			}
		}

		private void ClearStageAppearanceRetry()
		{
			_stageAppearanceRetryActive = false;
			_stageAppearanceRetryAttempts = 0;
			_nextStageAppearanceRetryTime = 0f;
		}

		private bool HasUnresolvedStageSelection()
		{
			if (!IsUnresolvedStageSelection(_stageASelection.Value) && !IsUnresolvedStageSelection(_stageBSelection.Value))
			{
				return IsUnresolvedStageSelection(_stageCSelection.Value);
			}
			return true;
		}

		private static bool IsUnresolvedStageSelection(string selectionKey)
		{
			if (!string.IsNullOrWhiteSpace(selectionKey) && !string.Equals(selectionKey, "official", StringComparison.OrdinalIgnoreCase))
			{
				return (Object)(object)FindCharacterByKey(selectionKey) == (Object)null;
			}
			return false;
		}

		private string DescribeStageSelections()
		{
			return "A=" + _stageASelection.Value + ", B=" + _stageBSelection.Value + ", C=" + _stageCSelection.Value;
		}

		private void ApplyStageAppearance(string label, string stageRootName, string selectionKey)
		{
			Transform val = FindChildByName(((Object)(object)_concertRoot == (Object)null) ? null : _concertRoot.transform, stageRootName);
			if ((Object)(object)val == (Object)null)
			{
				ManualLogSource log = Log;
				if (log != null)
				{
					log.LogWarning((object)(label + ": stage root '" + stageRootName + "' was not found; keeping official original."));
				}
				return;
			}
			CaptureStageOriginalMaterials(stageRootName, val);
			if (string.IsNullOrWhiteSpace(selectionKey) || string.Equals(selectionKey, "official", StringComparison.OrdinalIgnoreCase))
			{
				RestoreStageOriginalMaterials(stageRootName);
				ManualLogSource log2 = Log;
				if (log2 != null)
				{
					log2.LogInfo((object)(label + ": keeping official original."));
				}
				return;
			}
			Character val2 = FindCharacterByKey(selectionKey);
			if ((Object)(object)val2 == (Object)null)
			{
				RestoreStageOriginalMaterials(stageRootName);
				ManualLogSource log3 = Log;
				if (log3 != null)
				{
					log3.LogWarning((object)(label + ": selected player '" + selectionKey + "' was not found; keeping official original."));
				}
				return;
			}
			RestoreStageOriginalMaterials(stageRootName);
			if (!IsStagePlayerReplacementEnabled())
			{
				ManualLogSource log4 = Log;
				if (log4 != null)
				{
					log4.LogInfo((object)(label + ": player appearance replacement is disabled for now; keeping official original."));
				}
			}
			else if (CopyPlayerCustomizationToStage(val2, val))
			{
				ManualLogSource log5 = Log;
				if (log5 != null)
				{
					log5.LogInfo((object)(label + ": copied player customization from " + CharacterDisplayName(val2) + "."));
				}
			}
			else
			{
				ManualLogSource log6 = Log;
				if (log6 != null)
				{
					log6.LogWarning((object)(label + ": player customization mapping failed; keeping official original."));
				}
			}
		}

		private bool IsStagePlayerReplacementEnabled()
		{
			if (_enableStagePlayerReplacement != null)
			{
				return _enableStagePlayerReplacement.Value;
			}
			return false;
		}

		private void CaptureStageOriginalMaterials(string stageRootName, Transform stageRoot)
		{
			if (!_stageOriginalMaterials.ContainsKey(stageRootName) && !((Object)(object)stageRoot == (Object)null))
			{
				_stageOriginalMaterials[stageRootName] = (from renderer in ((Component)stageRoot).GetComponentsInChildren<Renderer>(true)
					where (Object)(object)renderer != (Object)null
					select new StageRendererSnapshot(renderer)).ToArray();
			}
		}

		private void RestoreStageOriginalMaterials(string stageRootName)
		{
			DestroyStageVisualClone(stageRootName);
			if (!_stageOriginalMaterials.TryGetValue(stageRootName, out var value))
			{
				return;
			}
			StageRendererSnapshot[] array = value;
			foreach (StageRendererSnapshot stageRendererSnapshot in array)
			{
				if ((Object)(object)stageRendererSnapshot.Renderer != (Object)null)
				{
					stageRendererSnapshot.Restore();
				}
			}
			RemoveTemporaryStageCustomizationRefs(stageRootName);
		}

		private void RemoveTemporaryStageCustomizationRefs(string stageRootName)
		{
			Transform val = FindChildByName(((Object)(object)_concertRoot == (Object)null) ? null : _concertRoot.transform, stageRootName);
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			int num = 0;
			CustomizationRefs[] componentsInChildren = ((Component)val).GetComponentsInChildren<CustomizationRefs>(true);
			foreach (CustomizationRefs val2 in componentsInChildren)
			{
				if (!((Object)(object)val2 == (Object)null))
				{
					Object.Destroy((Object)(object)val2);
					num++;
				}
			}
			if (num > 0)
			{
				ManualLogSource log = Log;
				if (log != null)
				{
					log.LogInfo((object)$"Removed {num} temporary stage customization refs under '{stageRootName}'.");
				}
			}
		}

		private void RestoreAllStageOriginalMaterials()
		{
			string[] array = _stageOriginalMaterials.Keys.ToArray();
			foreach (string stageRootName in array)
			{
				RestoreStageOriginalMaterials(stageRootName);
			}
		}

		private void UpdateStageVisualClones()
		{
			StageVisualClone[] array = _stageVisualClones.Values.ToArray();
			for (int i = 0; i < array.Length; i++)
			{
				array[i]?.UpdatePose();
			}
		}

		private void DestroyStageVisualClone(string stageRootName)
		{
			if (!string.IsNullOrWhiteSpace(stageRootName) && _stageVisualClones.TryGetValue(stageRootName, out var value))
			{
				value.Destroy();
				_stageVisualClones.Remove(stageRootName);
			}
		}

		private void DestroyAllStageVisualClones()
		{
			string[] array = _stageVisualClones.Keys.ToArray();
			foreach (string stageRootName in array)
			{
				DestroyStageVisualClone(stageRootName);
			}
		}

		private static Transform FindChildByName(Transform root, string childName)
		{
			if ((Object)(object)root == (Object)null)
			{
				return null;
			}
			Transform[] componentsInChildren = ((Component)root).GetComponentsInChildren<Transform>(true);
			foreach (Transform val in componentsInChildren)
			{
				if (string.Equals(((Object)val).name, childName, StringComparison.OrdinalIgnoreCase))
				{
					return val;
				}
			}
			return null;
		}

		private bool ApplyPlayerVisualCloneToStage(Character source, string stageRootName, Transform stageRoot)
		{
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)source == (Object)null || (Object)(object)stageRoot == (Object)null || string.IsNullOrWhiteSpace(stageRootName))
			{
				return false;
			}
			Transform sourceVisualRoot = GetSourceVisualRoot(source);
			if ((Object)(object)sourceVisualRoot == (Object)null)
			{
				return false;
			}
			DestroyStageVisualClone(stageRootName);
			HideOfficialStageVisuals(stageRoot);
			GameObject val = Object.Instantiate<GameObject>(((Component)sourceVisualRoot).gameObject, stageRoot);
			((Object)val).name = "BBNO-COS Visual Clone - " + CharacterDisplayName(source);
			val.SetActive(true);
			val.transform.localPosition = Vector3.zero;
			val.transform.localRotation = Quaternion.identity;
			val.transform.localScale = Vector3.one;
			StripRuntimeComponentsFromVisualClone(val);
			StageVisualClone stageVisualClone = StageVisualClone.Create(stageRoot, val);
			if (stageVisualClone == null || stageVisualClone.BoundRendererCount == 0)
			{
				Object.Destroy((Object)(object)val);
				RestoreStageOriginalMaterials(stageRootName);
				return false;
			}
			stageVisualClone.UpdatePose();
			_stageVisualClones[stageRootName] = stageVisualClone;
			ManualLogSource log = Log;
			if (log != null)
			{
				log.LogInfo((object)$"Created stage visual clone for '{stageRootName}'. Bound skinned renderers: {stageVisualClone.BoundRendererCount}.");
			}
			return true;
		}

		private static Transform GetSourceVisualRoot(Character source)
		{
			try
			{
				if ((Object)(object)source != (Object)null && source.refs != null && (Object)(object)source.refs.animator != (Object)null)
				{
					return ((Component)source.refs.animator).transform;
				}
			}
			catch
			{
			}
			CustomizationRefs customizationRefs = GetCustomizationRefs(source);
			if (!((Object)(object)customizationRefs == (Object)null))
			{
				return ((Component)customizationRefs).transform;
			}
			return null;
		}

		private static void HideOfficialStageVisuals(Transform stageRoot)
		{
			if ((Object)(object)stageRoot == (Object)null)
			{
				return;
			}
			Renderer[] componentsInChildren = ((Component)stageRoot).GetComponentsInChildren<Renderer>(true);
			foreach (Renderer val in componentsInChildren)
			{
				if (ShouldHideOfficialStageRenderer(val))
				{
					val.enabled = false;
				}
			}
		}

		private static bool ShouldHideOfficialStageRenderer(Renderer renderer)
		{
			if ((Object)(object)renderer == (Object)null || renderer is ParticleSystemRenderer || renderer is LineRenderer || renderer is TrailRenderer || (!(renderer is MeshRenderer) && !(renderer is SkinnedMeshRenderer)))
			{
				return false;
			}
			string name = ((Object)renderer).name ?? string.Empty;
			string transformPath = GetTransformPath(((Component)renderer).transform);
			if (LooksLikeNonCharacterStageEffect(name) || LooksLikeNonCharacterStageEffect(transformPath))
			{
				return false;
			}
			Material[] sharedMaterials = renderer.sharedMaterials;
			foreach (Material val in sharedMaterials)
			{
				string name2 = (((Object)(object)val == (Object)null) ? string.Empty : CleanMaterialName(((Object)val).name));
				string name3 = (((Object)(object)val == (Object)null || (Object)(object)val.shader == (Object)null) ? string.Empty : ((Object)val.shader).name);
				if (LooksLikeNonCharacterStageEffect(name2) || IsObscuringEffectName(name3))
				{
					return false;
				}
			}
			return true;
		}

		private static bool LooksLikeNonCharacterStageEffect(string name)
		{
			if (string.IsNullOrWhiteSpace(name))
			{
				return false;
			}
			if (name.IndexOf("particle", StringComparison.OrdinalIgnoreCase) < 0 && name.IndexOf("poof", StringComparison.OrdinalIgnoreCase) < 0 && name.IndexOf("steam", StringComparison.OrdinalIgnoreCase) < 0 && name.IndexOf("smoke", StringComparison.OrdinalIgnoreCase) < 0 && name.IndexOf("fog", StringComparison.OrdinalIgnoreCase) < 0 && name.IndexOf("spark", StringComparison.OrdinalIgnoreCase) < 0 && name.IndexOf("light", StringComparison.OrdinalIgnoreCase) < 0 && name.IndexOf("beam", StringComparison.OrdinalIgnoreCase) < 0 && name.IndexOf("money", StringComparison.OrdinalIgnoreCase) < 0 && name.IndexOf("dollar", StringComparison.OrdinalIgnoreCase) < 0 && name.IndexOf("cash", StringComparison.OrdinalIgnoreCase) < 0 && name.IndexOf("bubble", StringComparison.OrdinalIgnoreCase) < 0)
			{
				return name.IndexOf("sfx", StringComparison.OrdinalIgnoreCase) >= 0;
			}
			return true;
		}

		private static void StripRuntimeComponentsFromVisualClone(GameObject cloneObject)
		{
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)cloneObject == (Object)null)
			{
				return;
			}
			Animator[] componentsInChildren = cloneObject.GetComponentsInChildren<Animator>(true);
			foreach (Animator obj in componentsInChildren)
			{
				((Behaviour)obj).enabled = false;
				obj.cullingMode = (AnimatorCullingMode)0;
			}
			MonoBehaviour[] componentsInChildren2 = cloneObject.GetComponentsInChildren<MonoBehaviour>(true);
			foreach (MonoBehaviour val in componentsInChildren2)
			{
				if ((Object)(object)val != (Object)null)
				{
					((Behaviour)val).enabled = false;
				}
			}
			Collider[] componentsInChildren3 = cloneObject.GetComponentsInChildren<Collider>(true);
			for (int i = 0; i < componentsInChildren3.Length; i++)
			{
				componentsInChildren3[i].enabled = false;
			}
			Rigidbody[] componentsInChildren4 = cloneObject.GetComponentsInChildren<Rigidbody>(true);
			foreach (Rigidbody obj2 in componentsInChildren4)
			{
				obj2.isKinematic = true;
				obj2.detectCollisions = false;
			}
			AudioSource[] componentsInChildren5 = cloneObject.GetComponentsInChildren<AudioSource>(true);
			for (int i = 0; i < componentsInChildren5.Length; i++)
			{
				((Behaviour)componentsInChildren5[i]).enabled = false;
			}
			ParticleSystem[] componentsInChildren6 = cloneObject.GetComponentsInChildren<ParticleSystem>(true);
			foreach (ParticleSystem obj3 in componentsInChildren6)
			{
				EmissionModule emission = obj3.emission;
				((EmissionModule)(ref emission)).enabled = false;
				obj3.Stop(true, (ParticleSystemStopBehavior)0);
				obj3.Clear(true);
			}
			SkinnedMeshRenderer[] componentsInChildren7 = cloneObject.GetComponentsInChildren<SkinnedMeshRenderer>(true);
			foreach (SkinnedMeshRenderer obj4 in componentsInChildren7)
			{
				((Renderer)obj4).enabled = true;
				obj4.updateWhenOffscreen = true;
			}
			Renderer[] componentsInChildren8 = cloneObject.GetComponentsInChildren<Renderer>(true);
			foreach (Renderer val2 in componentsInChildren8)
			{
				if (val2 is MeshRenderer)
				{
					val2.enabled = true;
				}
			}
		}

		private static bool CopyPlayerCustomizationToStage(Character source, Transform stageRoot)
		{
			CustomizationRefs customizationRefs = GetCustomizationRefs(source);
			CustomizationRefs orCreateStageCustomizationRefs = GetOrCreateStageCustomizationRefs(stageRoot, customizationRefs);
			if ((Object)(object)customizationRefs == (Object)null || (Object)(object)orCreateStageCustomizationRefs == (Object)null)
			{
				return false;
			}
			bool flag = ApplyOfficialCustomizationToStage(source, orCreateStageCustomizationRefs);
			CopyPlayerClothingMaterials(customizationRefs, orCreateStageCustomizationRefs);
			CopyPlayerSashMaterials(customizationRefs, orCreateStageCustomizationRefs);
			CopyPlayerAccessoryToStageFace(customizationRefs, orCreateStageCustomizationRefs);
			NormalizeStageCustomizationRefs(orCreateStageCustomizationRefs);
			DisableUnmappedStageCosmeticRenderers(orCreateStageCustomizationRefs);
			ManualLogSource log = Log;
			if (log != null)
			{
				log.LogInfo((object)$"Stage customization refs applied. Official API: {flag}. No player renderer mesh/bone fallback was used.");
			}
			return flag;
		}

		private static void CopyPlayerClothingMaterials(CustomizationRefs sourceRefs, CustomizationRefs targetRefs)
		{
			if (!((Object)(object)sourceRefs == (Object)null) && !((Object)(object)targetRefs == (Object)null))
			{
				CopyRendererMaterialsOnly(sourceRefs.shorts, targetRefs.shorts);
				CopyRendererMaterialsOnly(sourceRefs.skirt, targetRefs.skirt);
				CopyRendererMaterialsOnly(sourceRefs.shortsShadow, targetRefs.shortsShadow);
				CopyRendererMaterialsOnly(sourceRefs.skirtShadow, targetRefs.skirtShadow);
			}
		}

		private static void CopyPlayerSashMaterials(CustomizationRefs sourceRefs, CustomizationRefs targetRefs)
		{
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Expected O, but got Unknown
			if (!((Object)(object)sourceRefs == (Object)null) && !((Object)(object)targetRefs == (Object)null) && !((Object)(object)sourceRefs.sashRenderer == (Object)null) && !((Object)(object)targetRefs.sashRenderer == (Object)null) && sourceRefs.sashRenderer.sharedMaterials != null && sourceRefs.sashRenderer.sharedMaterials.Length != 0)
			{
				targetRefs.sashRenderer.sharedMaterials = sourceRefs.sashRenderer.sharedMaterials.ToArray();
				MaterialPropertyBlock val = new MaterialPropertyBlock();
				sourceRefs.sashRenderer.GetPropertyBlock(val);
				targetRefs.sashRenderer.SetPropertyBlock(val);
			}
		}

		private static void CopyPlayerAccessoryToStageFace(CustomizationRefs sourceRefs, CustomizationRefs targetRefs)
		{
			if ((Object)(object)sourceRefs == (Object)null || (Object)(object)targetRefs == (Object)null || (Object)(object)sourceRefs.accessoryRenderer == (Object)null || (Object)(object)targetRefs.accessoryRenderer == (Object)null)
			{
				return;
			}
			Renderer[] array = FindStageAccessoryRenderers(((Component)targetRefs).transform);
			if (array.Length == 0)
			{
				array = (Renderer[])(object)new Renderer[1] { targetRefs.accessoryRenderer };
			}
			bool activeSelf = ((Component)targetRefs.accessoryRenderer).gameObject.activeSelf;
			bool enabled = targetRefs.accessoryRenderer.enabled;
			Renderer[] array2 = array;
			foreach (Renderer val in array2)
			{
				if (!((Object)(object)val == (Object)null))
				{
					CopyRendererMaterialsOnly(sourceRefs.accessoryRenderer, val);
					((Component)val).gameObject.SetActive(activeSelf || enabled);
					val.enabled = enabled;
				}
			}
			if (array.Length > 1)
			{
				ManualLogSource log = Log;
				if (log != null)
				{
					log.LogInfo((object)$"Synced accessory renderer to {array.Length} stage face cards under '{GetTransformPath(((Component)targetRefs).transform)}'.");
				}
			}
		}

		private static void CopyRendererMaterialsOnly(Renderer source, Renderer target)
		{
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Expected O, but got Unknown
			if (!((Object)(object)source == (Object)null) && !((Object)(object)target == (Object)null) && source.sharedMaterials != null && source.sharedMaterials.Length != 0)
			{
				try
				{
					target.materials = source.materials.ToArray();
				}
				catch
				{
					target.sharedMaterials = source.sharedMaterials.ToArray();
				}
				MaterialPropertyBlock val = new MaterialPropertyBlock();
				source.GetPropertyBlock(val);
				target.SetPropertyBlock(val);
			}
		}

		private static void DisableUnmappedStageCosmeticRenderers(CustomizationRefs refs)
		{
			if ((Object)(object)refs == (Object)null)
			{
				return;
			}
			HashSet<Renderer> hashSet = new HashSet<Renderer>();
			AddRenderer(hashSet, (Renderer)(object)refs.mainRenderer);
			AddRenderer(hashSet, (Renderer)(object)refs.mainRendererShadow);
			AddRenderer(hashSet, refs.mouthRenderer);
			AddRenderer(hashSet, refs.accessoryRenderer);
			AddRenderer(hashSet, refs.shorts);
			AddRenderer(hashSet, refs.skirt);
			AddRenderer(hashSet, refs.shortsShadow);
			AddRenderer(hashSet, refs.skirtShadow);
			AddRenderer(hashSet, refs.sashRenderer);
			AddRenderers(hashSet, refs.PlayerRenderers);
			AddRenderers(hashSet, refs.EyeRenderers);
			AddRenderers(hashSet, refs.playerHats);
			AddRenderers(hashSet, FindStageAccessoryRenderers(((Component)refs).transform));
			if ((Object)(object)refs.thirdEye != (Object)null)
			{
				AddRenderer(hashSet, refs.thirdEye.GetComponent<Renderer>());
			}
			int num = 0;
			Renderer[] componentsInChildren = ((Component)refs).GetComponentsInChildren<Renderer>(true);
			foreach (Renderer val in componentsInChildren)
			{
				if (!((Object)(object)val == (Object)null) && !hashSet.Contains(val) && !IsHatShadowRenderer(val) && IsStageCosmeticRenderer(val))
				{
					val.enabled = false;
					((Component)val).gameObject.SetActive(false);
					num++;
				}
			}
			if (num > 0)
			{
				ManualLogSource log = Log;
				if (log != null)
				{
					log.LogInfo((object)$"Disabled {num} unmapped stage cosmetic renderers under '{GetTransformPath(((Component)refs).transform)}'.");
				}
			}
		}

		private static void AddRenderers(HashSet<Renderer> renderers, Renderer[] values)
		{
			if (values != null)
			{
				foreach (Renderer renderer in values)
				{
					AddRenderer(renderers, renderer);
				}
			}
		}

		private static void AddRenderer(HashSet<Renderer> renderers, Renderer renderer)
		{
			if (renderers != null && (Object)(object)renderer != (Object)null)
			{
				renderers.Add(renderer);
			}
		}

		private static bool IsStageCosmeticRenderer(Renderer renderer)
		{
			if ((Object)(object)renderer == (Object)null)
			{
				return false;
			}
			string normalized = NormalizeObjectName(((Object)renderer).name);
			if (normalized.StartsWith("HeadMesh", StringComparison.OrdinalIgnoreCase) || normalized.StartsWith("MouthCard", StringComparison.OrdinalIgnoreCase) || normalized.StartsWith("AccesoryCard", StringComparison.OrdinalIgnoreCase) || normalized.StartsWith("AccessoryCard", StringComparison.OrdinalIgnoreCase) || normalized.StartsWith("EyeCardL", StringComparison.OrdinalIgnoreCase) || normalized.StartsWith("EyeCardR", StringComparison.OrdinalIgnoreCase) || normalized.StartsWith("ThirdEye", StringComparison.OrdinalIgnoreCase))
			{
				return true;
			}
			return PreferredStageHatOrder.Any((string name) => NormalizeObjectName(name).Equals(normalized, StringComparison.OrdinalIgnoreCase));
		}

		private static Renderer[] FindStageAccessoryRenderers(Transform root)
		{
			if ((Object)(object)root == (Object)null)
			{
				return Array.Empty<Renderer>();
			}
			return (from renderer in ((Component)root).GetComponentsInChildren<Renderer>(true)
				where (Object)(object)renderer != (Object)null && IsAccessoryRendererName(((Object)renderer).name)
				select renderer).ToArray();
		}

		private static bool IsAccessoryRendererName(string name)
		{
			string text = NormalizeObjectName(name);
			if (!text.StartsWith("AccesoryCard", StringComparison.OrdinalIgnoreCase))
			{
				return text.StartsWith("AccessoryCard", StringComparison.OrdinalIgnoreCase);
			}
			return true;
		}

		private static bool ApplyOfficialCustomizationToStage(Character source, CustomizationRefs targetRefs)
		{
			try
			{
				if ((Object)(object)source == (Object)null || source.refs == null || (Object)(object)source.refs.customization == (Object)null || (Object)(object)targetRefs == (Object)null)
				{
					return false;
				}
				source.refs.customization.SetCustomizationForRef(targetRefs);
				TryRemoveTemporaryCustomizationSubscription(source, source.refs.customization);
				SetTargetCustomizationRenderersAlwaysUpdate(targetRefs);
				NormalizeStageCustomizationRefs(targetRefs);
				return true;
			}
			catch (Exception ex)
			{
				ManualLogSource log = Log;
				if (log != null)
				{
					log.LogWarning((object)("Official player customization copy failed, using fallback renderer copy: " + ex.Message));
				}
				return false;
			}
		}

		private static void TryRemoveTemporaryCustomizationSubscription(Character source, CharacterCustomization customization)
		{
			try
			{
				if ((Object)(object)source == (Object)null || (Object)(object)((MonoBehaviourPun)source).photonView == (Object)null || ((MonoBehaviourPun)source).photonView.Owner == null || (Object)(object)customization == (Object)null)
				{
					return;
				}
				PersistentPlayerDataService service = GameHandler.GetService<PersistentPlayerDataService>();
				if (service == null)
				{
					return;
				}
				MethodInfo method = typeof(CharacterCustomization).GetMethod("OnPlayerDataChange", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				if (!(method == null))
				{
					Action<PersistentPlayerData> action = (Action<PersistentPlayerData>)Delegate.CreateDelegate(typeof(Action<PersistentPlayerData>), customization, method, throwOnBindFailure: false);
					if (action != null)
					{
						service.UnsubscribeToPlayerDataChange(((MonoBehaviourPun)source).photonView.Owner, action);
					}
				}
			}
			catch
			{
			}
		}

		private static CustomizationRefs GetOrCreateStageCustomizationRefs(Transform stageRoot, CustomizationRefs sourceRefs)
		{
			if ((Object)(object)stageRoot == (Object)null)
			{
				return null;
			}
			SkinnedMeshRenderer val = FindStageSkinnedRenderer(stageRoot, "MainMesh");
			Transform val2 = FindStageActorRoot(stageRoot, (Renderer)(object)val) ?? stageRoot;
			CustomizationRefs val3 = ((Component)val2).GetComponentInChildren<CustomizationRefs>(true);
			if ((Object)(object)val3 == (Object)null)
			{
				val3 = ((Component)val2).gameObject.AddComponent<CustomizationRefs>();
			}
			Transform val4 = FindStageJoint(val2, "Head") ?? val2;
			Transform root = FindChildByName(val2, "Face") ?? val4;
			Transform val5 = FindChildByName(val4, "Hat") ?? FindChildByName(val2, "Hat") ?? val4;
			val3.mainRenderer = val ?? val3.mainRenderer ?? FindStageSkinnedRenderer(val2, "MainMesh");
			val3.mainRendererShadow = val3.mainRendererShadow ?? FindStageSkinnedRenderer(val2, "Shadows", "MainMesh Shadow", "HeadMesh Shadow");
			if ((Object)(object)val3.mainRendererShadow == (Object)null)
			{
				val3.mainRendererShadow = CreateDummySkinnedRenderer("BBNO-COS Main Shadow", val2, val3.mainRenderer);
			}
			val3.shorts = val3.shorts ?? FindStageRenderer(val2, "Shorts");
			val3.skirt = val3.skirt ?? FindStageRenderer(val2, "Skirt");
			val3.shortsShadow = val3.shortsShadow ?? FindStageRenderer(val2, "Shorts Shadow", "ShortsShadow");
			val3.skirtShadow = val3.skirtShadow ?? FindStageRenderer(val2, "Skirt Shadow", "SkirtShadow");
			if ((Object)(object)val3.shortsShadow == (Object)null)
			{
				ref Renderer shortsShadow = ref val3.shortsShadow;
				Renderer shorts = val3.shorts;
				shortsShadow = (Renderer)(object)CreateDummySkinnedRenderer("BBNO-COS Shorts Shadow", val2, (SkinnedMeshRenderer)(object)((shorts is SkinnedMeshRenderer) ? shorts : null));
			}
			if ((Object)(object)val3.skirtShadow == (Object)null)
			{
				ref Renderer skirtShadow = ref val3.skirtShadow;
				Renderer skirt = val3.skirt;
				skirtShadow = (Renderer)(object)CreateDummySkinnedRenderer("BBNO-COS Skirt Shadow", val2, (SkinnedMeshRenderer)(object)((skirt is SkinnedMeshRenderer) ? skirt : null));
			}
			val3.sashRenderer = val3.sashRenderer ?? FindStageRenderer(val2, "Sash");
			val3.chickenRenderer = val3.chickenRenderer ?? FindStageRenderer(val2, "Chicken");
			val3.skeletonRenderer = val3.skeletonRenderer ?? FindStageRenderer(val2, "Skeleton");
			Renderer val6 = FindStageRenderer(val2, "HeadMesh");
			Renderer val7 = FindStageRenderer(root, "Eye Card L");
			Renderer val8 = FindStageRenderer(root, "Eye Card R");
			Renderer val9 = FindStageRenderer(root, "Third Eye");
			val3.EyeRenderers = EnsureRendererArray(val3.EyeRenderers, BuildRendererArray(val7, val8, val9));
			val3.PlayerRenderers = EnsureRendererArray(val3.PlayerRenderers, BuildRendererArray(val6, (Renderer)val3.mainRenderer, val7, val8, val9));
			val3.mouthRenderer = val3.mouthRenderer ?? FindStageRenderer(root, "Mouth Card", "Mouth");
			val3.accessoryRenderer = val3.accessoryRenderer ?? FindStageRenderer(root, "Accesory Card", "Accessory Card", "Accessory");
			Renderer[] array = FindStageHatRenderers(val5, sourceRefs);
			val3.playerHats = ((array.Length != 0) ? array : EnsureRendererArray(val3.playerHats, Array.Empty<Renderer>()));
			val3.hatTransform = val3.hatTransform ?? val5;
			if ((Object)(object)val3.hatShadowMeshFilter == (Object)null)
			{
				val3.hatShadowMeshFilter = FindStageHatShadowMeshFilter(val5);
			}
			if ((Object)(object)val3.hatShadowMeshFilter == (Object)null)
			{
				val3.hatShadowMeshFilter = CreateDummyMeshFilter("BBNO-COS Hat Shadow", val5);
			}
			if (val3.sashAscentMaterials == null || val3.sashAscentMaterials.Length == 0)
			{
				val3.sashAscentMaterials = (((Object)(object)sourceRefs != (Object)null && sourceRefs.sashAscentMaterials != null && sourceRefs.sashAscentMaterials.Length != 0) ? sourceRefs.sashAscentMaterials : ExtractMaterials(val3.sashRenderer));
			}
			val3.thirdEye = val3.thirdEye ?? (((Object)(object)val9 == (Object)null) ? null : ((Component)val9).gameObject);
			val3.AllRenderers = (from renderer in BuildRendererArray(val6, (Renderer)val3.mainRenderer, val3.shorts, val3.skirt, val3.sashRenderer, val3.accessoryRenderer, val7, val8, val3.mouthRenderer, val9)
				where (Object)(object)renderer != (Object)null
				select renderer).ToArray();
			if (!HasRequiredStageCustomizationRefs(val3))
			{
				LogStageCustomizationRefs(val2, val3, "incomplete");
				return null;
			}
			NormalizeStageCustomizationRefs(val3);
			LogStageCustomizationRefs(val2, val3, "ready");
			if (!((Object)(object)val3.mainRenderer == (Object)null))
			{
				return val3;
			}
			return null;
		}

		private static Transform FindStageActorRoot(Transform stageRoot, Renderer mainRenderer)
		{
			if ((Object)(object)stageRoot == (Object)null || (Object)(object)mainRenderer == (Object)null)
			{
				return stageRoot;
			}
			Transform val = ((Component)mainRenderer).transform;
			Transform val2 = val;
			while ((Object)(object)val != (Object)null && (Object)(object)val.parent != (Object)null && (Object)(object)val.parent != (Object)(object)stageRoot)
			{
				val = val.parent;
				val2 = val;
			}
			return val2 ?? stageRoot;
		}

		private static Renderer[] BuildRendererArray(params Renderer[] renderers)
		{
			if (renderers != null)
			{
				return renderers.Where((Renderer renderer) => (Object)(object)renderer != (Object)null).Distinct().ToArray();
			}
			return Array.Empty<Renderer>();
		}

		private static Renderer[] FindStageHatRenderers(Transform hatRoot, CustomizationRefs sourceRefs)
		{
			if ((Object)(object)hatRoot == (Object)null)
			{
				return Array.Empty<Renderer>();
			}
			Renderer[] array = (from renderer in ((Component)hatRoot).GetComponentsInChildren<Renderer>(true)
				where (Object)(object)renderer != (Object)null
				where !IsHatShadowRenderer(renderer)
				select renderer).ToArray();
			List<Renderer> list = new List<Renderer>();
			Renderer[] playerHats;
			if ((Object)(object)sourceRefs != (Object)null && sourceRefs.playerHats != null)
			{
				playerHats = sourceRefs.playerHats;
				foreach (Renderer val in playerHats)
				{
					AddMatchingStageHat(list, array, ((Object)(object)val == (Object)null) ? null : ((Object)val).name);
				}
			}
			string[] preferredStageHatOrder = PreferredStageHatOrder;
			foreach (string sourceHatName in preferredStageHatOrder)
			{
				AddMatchingStageHat(list, array, sourceHatName);
			}
			playerHats = array;
			foreach (Renderer item in playerHats)
			{
				if (!list.Contains(item))
				{
					list.Add(item);
				}
			}
			ManualLogSource log = Log;
			if (log != null)
			{
				log.LogInfo((object)string.Format("Stage hat order for '{0}': {1}[{2}]", GetTransformPath(hatRoot), list.Count, string.Join(",", list.Take(16).Select(RendererName).ToArray())));
			}
			return list.ToArray();
		}

		private static void AddMatchingStageHat(List<Renderer> ordered, Renderer[] candidates, string sourceHatName)
		{
			if (ordered != null && candidates != null && !string.IsNullOrWhiteSpace(sourceHatName))
			{
				string wanted = NormalizeObjectName(sourceHatName);
				Renderer val = ((IEnumerable<Renderer>)candidates).FirstOrDefault((Func<Renderer, bool>)((Renderer renderer) => NormalizeObjectName(((Object)renderer).name).Equals(wanted, StringComparison.OrdinalIgnoreCase)));
				if ((Object)(object)val != (Object)null && !ordered.Contains(val))
				{
					ordered.Add(val);
				}
			}
		}

		private static MeshFilter FindStageHatShadowMeshFilter(Transform hatRoot)
		{
			if ((Object)(object)hatRoot == (Object)null)
			{
				return null;
			}
			MeshFilter[] componentsInChildren = ((Component)hatRoot).GetComponentsInChildren<MeshFilter>(true);
			foreach (MeshFilter val in componentsInChildren)
			{
				if ((Object)(object)val != (Object)null && IsHatShadowName(((Object)val).name))
				{
					return val;
				}
			}
			return null;
		}

		private static bool IsHatShadowRenderer(Renderer renderer)
		{
			if ((Object)(object)renderer != (Object)null)
			{
				return IsHatShadowName(((Object)renderer).name);
			}
			return false;
		}

		private static bool IsHatShadowName(string name)
		{
			string text = NormalizeObjectName(name);
			if (!text.Equals("Shadow", StringComparison.OrdinalIgnoreCase) && !text.Equals("Shadow1", StringComparison.OrdinalIgnoreCase))
			{
				return text.IndexOf("HatShadow", StringComparison.OrdinalIgnoreCase) >= 0;
			}
			return true;
		}

		private static bool HasRequiredStageCustomizationRefs(CustomizationRefs refs)
		{
			if ((Object)(object)refs != (Object)null && (Object)(object)refs.mainRenderer != (Object)null && (Object)(object)refs.mainRendererShadow != (Object)null && refs.PlayerRenderers != null && refs.PlayerRenderers.Length != 0 && (Object)(object)refs.PlayerRenderers[0] != (Object)null && refs.EyeRenderers != null && refs.EyeRenderers.Length >= 2 && (Object)(object)refs.mouthRenderer != (Object)null && (Object)(object)refs.accessoryRenderer != (Object)null && (Object)(object)refs.shorts != (Object)null && (Object)(object)refs.skirt != (Object)null && (Object)(object)refs.shortsShadow != (Object)null && (Object)(object)refs.skirtShadow != (Object)null && refs.playerHats != null && refs.playerHats.Length >= 2 && (Object)(object)refs.playerHats[0] != (Object)null && (Object)(object)refs.playerHats[1] != (Object)null && (Object)(object)refs.hatShadowMeshFilter != (Object)null && (Object)(object)refs.sashRenderer != (Object)null && refs.sashAscentMaterials != null && refs.sashAscentMaterials.Length != 0 && (Object)(object)refs.thirdEye != (Object)null && refs.AllRenderers != null)
			{
				return refs.AllRenderers.Length != 0;
			}
			return false;
		}

		private static void LogStageCustomizationRefs(Transform root, CustomizationRefs refs, string state)
		{
			ManualLogSource log = Log;
			if (log != null)
			{
				log.LogInfo((object)("Stage customization refs " + state + " for '" + GetTransformPath(root) + "': main=" + RendererName((Renderer)(object)(((Object)(object)refs == (Object)null) ? null : refs.mainRenderer)) + ", head/player=" + RendererArraySummary(((Object)(object)refs == (Object)null) ? null : refs.PlayerRenderers) + ", eyes=" + RendererArraySummary(((Object)(object)refs == (Object)null) ? null : refs.EyeRenderers) + ", mouth=" + RendererName(((Object)(object)refs == (Object)null) ? null : refs.mouthRenderer) + ", accessory=" + RendererName(((Object)(object)refs == (Object)null) ? null : refs.accessoryRenderer) + ", shorts=" + RendererName(((Object)(object)refs == (Object)null) ? null : refs.shorts) + ", skirt=" + RendererName(((Object)(object)refs == (Object)null) ? null : refs.skirt) + ", sash=" + RendererName(((Object)(object)refs == (Object)null) ? null : refs.sashRenderer) + ", " + $"hats={((!((Object)(object)refs == (Object)null) && refs.playerHats != null) ? refs.playerHats.Length : 0)}, " + "hatShadow=" + (((Object)(object)refs == (Object)null || (Object)(object)refs.hatShadowMeshFilter == (Object)null) ? "null" : ((Object)refs.hatShadowMeshFilter).name) + ", thirdEye=" + (((Object)(object)refs == (Object)null || (Object)(object)refs.thirdEye == (Object)null) ? "null" : ((Object)refs.thirdEye).name) + "."));
			}
		}

		private static string RendererArraySummary(Renderer[] renderers)
		{
			if (renderers == null)
			{
				return "null";
			}
			return string.Format("{0}[{1}]", renderers.Length, string.Join(",", renderers.Take(5).Select(RendererName).ToArray()));
		}

		private static string RendererName(Renderer renderer)
		{
			if (!((Object)(object)renderer == (Object)null))
			{
				return ((Object)renderer).name;
			}
			return "null";
		}

		private static SkinnedMeshRenderer FindStageSkinnedRenderer(Transform root, params string[] names)
		{
			Renderer obj = FindStageRenderer(root, names);
			return (SkinnedMeshRenderer)(object)((obj is SkinnedMeshRenderer) ? obj : null);
		}

		private static Renderer FindStageRenderer(Transform root, params string[] names)
		{
			if ((Object)(object)root == (Object)null || names == null || names.Length == 0)
			{
				return null;
			}
			Renderer[] componentsInChildren = ((Component)root).GetComponentsInChildren<Renderer>(true);
			Renderer[] array = componentsInChildren;
			foreach (Renderer val in array)
			{
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				string text = NormalizeObjectName(((Object)val).name);
				string[] array2 = names;
				for (int j = 0; j < array2.Length; j++)
				{
					string value = NormalizeObjectName(array2[j]);
					if (text.Equals(value, StringComparison.OrdinalIgnoreCase))
					{
						return val;
					}
				}
			}
			array = componentsInChildren;
			foreach (Renderer val2 in array)
			{
				if ((Object)(object)val2 == (Object)null)
				{
					continue;
				}
				string text2 = NormalizeObjectName(((Object)val2).name);
				string[] array2 = names;
				for (int j = 0; j < array2.Length; j++)
				{
					string value2 = NormalizeObjectName(array2[j]);
					if (text2.Equals(value2, StringComparison.OrdinalIgnoreCase) || text2.IndexOf(value2, StringComparison.OrdinalIgnoreCase) >= 0)
					{
						return val2;
					}
				}
			}
			return null;
		}

		private static Transform FindStageJoint(Transform root, string name)
		{
			if ((Object)(object)root == (Object)null || string.IsNullOrWhiteSpace(name))
			{
				return null;
			}
			string value = NormalizeObjectName(name);
			Transform[] componentsInChildren = ((Component)root).GetComponentsInChildren<Transform>(true);
			foreach (Transform val in componentsInChildren)
			{
				if ((Object)(object)val != (Object)null && NormalizeObjectName(((Object)val).name).Equals(value, StringComparison.OrdinalIgnoreCase))
				{
					return val;
				}
			}
			return null;
		}

		private static Renderer[] EnsureRendererArray(Renderer[] current, Renderer[] fallback)
		{
			if (current != null && current.Length != 0 && current.Any((Renderer renderer) => (Object)(object)renderer != (Object)null))
			{
				return current;
			}
			if (fallback != null)
			{
				return fallback.Where((Renderer renderer) => (Object)(object)renderer != (Object)null).ToArray();
			}
			return Array.Empty<Renderer>();
		}

		private static Renderer[] CreateDummyRenderers(string baseName, Transform parent, int count)
		{
			int num = Mathf.Max(1, count);
			Renderer[] array = (Renderer[])(object)new Renderer[num];
			for (int i = 0; i < num; i++)
			{
				array[i] = CreateDummyRenderer($"{baseName} {i + 1}", parent);
			}
			return array;
		}

		private static Renderer CreateDummyRenderer(string name, Transform parent)
		{
			//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_0013: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(name);
			val.transform.SetParent(parent, false);
			MeshFilter val2 = val.AddComponent<MeshFilter>();
			MeshRenderer obj = val.AddComponent<MeshRenderer>();
			((Renderer)obj).enabled = false;
			val2.sharedMesh = null;
			return (Renderer)(object)obj;
		}

		private static MeshFilter CreateDummyMeshFilter(string name, Transform parent)
		{
			//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_0013: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(name);
			val.transform.SetParent(parent, false);
			MeshFilter result = val.AddComponent<MeshFilter>();
			((Renderer)val.AddComponent<MeshRenderer>()).enabled = false;
			return result;
		}

		private static SkinnedMeshRenderer CreateDummySkinnedRenderer(string name, Transform parent, SkinnedMeshRenderer template)
		{
			//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)
			GameObject val = new GameObject(name);
			val.transform.SetParent(parent, false);
			SkinnedMeshRenderer val2 = val.AddComponent<SkinnedMeshRenderer>();
			((Renderer)val2).enabled = false;
			val2.updateWhenOffscreen = true;
			if ((Object)(object)template != (Object)null)
			{
				val2.bones = template.bones;
				val2.rootBone = template.rootBone;
				val2.sharedMesh = template.sharedMesh;
				((Renderer)val2).sharedMaterials = ((Renderer)template).sharedMaterials;
			}
			return val2;
		}

		private static Material[] ExtractMaterials(Renderer renderer)
		{
			if (!((Object)(object)renderer != (Object)null) || renderer.sharedMaterials == null)
			{
				return Array.Empty<Material>();
			}
			return renderer.sharedMaterials.Where((Material material) => (Object)(object)material != (Object)null).ToArray();
		}

		private static string NormalizeObjectName(string name)
		{
			if (string.IsNullOrWhiteSpace(name))
			{
				return string.Empty;
			}
			string text = name.Replace("(Clone)", string.Empty).Trim();
			int num = text.LastIndexOf('.');
			if (num > 0 && num < text.Length - 1 && text.Skip(num + 1).All(char.IsDigit))
			{
				text = text.Substring(0, num);
			}
			return text.Replace(" ", string.Empty).Replace("_", string.Empty);
		}

		private static void NormalizeStageCustomizationRefs(CustomizationRefs refs)
		{
			if (!((Object)(object)refs == (Object)null))
			{
				DisableSpecialRenderer(refs.chickenRenderer);
				DisableSpecialRenderer(refs.skeletonRenderer);
				if ((Object)(object)refs.mainRenderer != (Object)null)
				{
					((Renderer)refs.mainRenderer).enabled = true;
					((Component)refs.mainRenderer).gameObject.SetActive(true);
				}
				if ((Object)(object)refs.sashRenderer != (Object)null)
				{
					refs.sashRenderer.enabled = true;
					((Component)refs.sashRenderer).gameObject.SetActive(true);
				}
				SetTargetCustomizationRenderersAlwaysUpdate(refs);
			}
		}

		private static void DisableSpecialRenderer(Renderer renderer)
		{
			if (!((Object)(object)renderer == (Object)null))
			{
				renderer.enabled = false;
				((Component)renderer).gameObject.SetActive(false);
			}
		}

		private static void SetTargetCustomizationRenderersAlwaysUpdate(CustomizationRefs targetRefs)
		{
			if ((Object)(object)targetRefs == (Object)null)
			{
				return;
			}
			SkinnedMeshRenderer[] componentsInChildren = ((Component)targetRefs).GetComponentsInChildren<SkinnedMeshRenderer>(true);
			foreach (SkinnedMeshRenderer val in componentsInChildren)
			{
				if ((Object)(object)val != (Object)null)
				{
					val.updateWhenOffscreen = true;
				}
			}
		}

		private static CustomizationRefs GetCustomizationRefs(Character character)
		{
			try
			{
				return ((Object)(object)character != (Object)null && character.refs != null && (Object)(object)character.refs.customization != (Object)null) ? character.refs.customization.refs : null;
			}
			catch
			{
				return null;
			}
		}

		private static int CopyRendererArrayAppearance(Renderer[] sources, Renderer[] targets, bool copyMesh, bool copyEnabled, bool copyActive, Transform targetRigRoot = null)
		{
			if (sources == null || targets == null)
			{
				return 0;
			}
			int num = 0;
			int num2 = Mathf.Min(sources.Length, targets.Length);
			for (int i = 0; i < num2; i++)
			{
				num += CopyRendererAppearance(sources[i], targets[i], copyMesh, copyEnabled, copyActive, targetRigRoot);
			}
			return num;
		}

		private static int CopyRendererAppearance(Renderer source, Renderer target, bool copyMesh, bool copyEnabled, bool copyActive, Transform targetRigRoot = null)
		{
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Expected O, but got Unknown
			if ((Object)(object)source == (Object)null || (Object)(object)target == (Object)null)
			{
				return 0;
			}
			if (copyActive)
			{
				((Component)target).gameObject.SetActive(((Component)source).gameObject.activeSelf);
			}
			if (copyEnabled)
			{
				target.enabled = source.enabled;
			}
			if (source.sharedMaterials != null && source.sharedMaterials.Length != 0)
			{
				target.sharedMaterials = source.sharedMaterials.ToArray();
			}
			if (copyMesh)
			{
				CopyRendererMesh(source, target, targetRigRoot);
			}
			MaterialPropertyBlock val = new MaterialPropertyBlock();
			source.GetPropertyBlock(val);
			target.SetPropertyBlock(val);
			return 1;
		}

		private static void CopyRendererMesh(Renderer source, Renderer target, Transform targetRigRoot = null)
		{
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			SkinnedMeshRenderer val = (SkinnedMeshRenderer)(object)((source is SkinnedMeshRenderer) ? source : null);
			SkinnedMeshRenderer val2 = (SkinnedMeshRenderer)(object)((target is SkinnedMeshRenderer) ? target : null);
			if ((Object)(object)val != (Object)null && (Object)(object)val2 != (Object)null)
			{
				val2.sharedMesh = val.sharedMesh;
				MapSkinnedMeshRendererBones(val, val2, targetRigRoot);
				return;
			}
			MeshFilter component = ((Component)source).GetComponent<MeshFilter>();
			MeshFilter component2 = ((Component)target).GetComponent<MeshFilter>();
			if ((Object)(object)component != (Object)null && (Object)(object)component2 != (Object)null)
			{
				component2.sharedMesh = component.sharedMesh;
				((Component)component2).transform.localPosition = ((Component)component).transform.localPosition;
				((Component)component2).transform.localRotation = ((Component)component).transform.localRotation;
				((Component)component2).transform.localScale = ((Component)component).transform.localScale;
			}
		}

		private static void MapSkinnedMeshRendererBones(SkinnedMeshRenderer source, SkinnedMeshRenderer target, Transform targetRigRoot)
		{
			//IL_0182: Unknown result type (might be due to invalid IL or missing references)
			//IL_0187: Unknown result type (might be due to invalid IL or missing references)
			//IL_0191: Unknown result type (might be due to invalid IL or missing references)
			//IL_0196: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)source == (Object)null || (Object)(object)target == (Object)null || source.bones == null || source.bones.Length == 0 || (Object)(object)targetRigRoot == (Object)null)
			{
				return;
			}
			Dictionary<string, Transform> dictionary = new Dictionary<string, Transform>(StringComparer.OrdinalIgnoreCase);
			Transform[] componentsInChildren = ((Component)targetRigRoot).GetComponentsInChildren<Transform>(true);
			foreach (Transform val in componentsInChildren)
			{
				string text = (((Object)(object)val == (Object)null) ? string.Empty : NormalizeObjectName(((Object)val).name));
				if (text.Length > 0 && !dictionary.ContainsKey(text))
				{
					dictionary.Add(text, val);
				}
			}
			Transform[] array = (Transform[])(object)new Transform[source.bones.Length];
			int num = 0;
			for (int j = 0; j < source.bones.Length; j++)
			{
				Transform val2 = source.bones[j];
				string text2 = (((Object)(object)val2 == (Object)null) ? string.Empty : NormalizeObjectName(((Object)val2).name));
				if (text2.Length > 0 && dictionary.TryGetValue(text2, out var value))
				{
					array[j] = value;
					num++;
				}
				else if (target.bones != null && j < target.bones.Length)
				{
					array[j] = target.bones[j];
				}
				else
				{
					array[j] = target.rootBone;
				}
			}
			if (num > 0)
			{
				target.bones = array;
				if ((Object)(object)source.rootBone != (Object)null)
				{
					string text3 = NormalizeObjectName(((Object)source.rootBone).name);
					if (text3.Length > 0 && dictionary.TryGetValue(text3, out var value2))
					{
						target.rootBone = value2;
					}
				}
			}
			((Renderer)target).localBounds = new Bounds(Vector3.zero, Vector3.one * 10000f);
			target.updateWhenOffscreen = true;
		}

		private static void CopyHatTransformState(CustomizationRefs sourceRefs, CustomizationRefs targetRefs)
		{
			//IL_005b: 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)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)sourceRefs == (Object)null) && !((Object)(object)targetRefs == (Object)null) && !((Object)(object)sourceRefs.hatTransform == (Object)null) && !((Object)(object)targetRefs.hatTransform == (Object)null))
			{
				((Component)targetRefs.hatTransform).gameObject.SetActive(((Component)sourceRefs.hatTransform).gameObject.activeSelf);
				targetRefs.hatTransform.localPosition = sourceRefs.hatTransform.localPosition;
				targetRefs.hatTransform.localRotation = sourceRefs.hatTransform.localRotation;
				targetRefs.hatTransform.localScale = sourceRefs.hatTransform.localScale;
				if ((Object)(object)sourceRefs.hatShadowMeshFilter != (Object)null && (Object)(object)targetRefs.hatShadowMeshFilter != (Object)null)
				{
					targetRefs.hatShadowMeshFilter.sharedMesh = sourceRefs.hatShadowMeshFilter.sharedMesh;
					((Component)targetRefs.hatShadowMeshFilter).transform.localPosition = ((Component)sourceRefs.hatShadowMeshFilter).transform.localPosition;
					((Component)targetRefs.hatShadowMeshFilter).transform.localRotation = ((Component)sourceRefs.hatShadowMeshFilter).transform.localRotation;
					((Component)targetRefs.hatShadowMeshFilter).transform.localScale = ((Component)sourceRefs.hatShadowMeshFilter).transform.localScale;
				}
			}
		}

		private static void MirrorPlayerMaterialsToStage(Character source, Transform stageRoot)
		{
			if ((Object)(object)source == (Object)null || (Object)(object)stageRoot == (Object)null)
			{
				return;
			}
			Renderer[] array = (from renderer in ((Component)source).GetComponentsInChildren<Renderer>(true)
				where IsAppearanceRenderer(renderer, requireEnabled: true)
				select renderer).ToArray();
			if (array.Length == 0)
			{
				return;
			}
			Material[] array2 = (from material in array.SelectMany((Renderer renderer) => renderer.sharedMaterials)
				where (Object)(object)material != (Object)null
				select material).ToArray();
			if (array2.Length == 0)
			{
				return;
			}
			Renderer[] componentsInChildren = ((Component)stageRoot).GetComponentsInChildren<Renderer>(true);
			foreach (Renderer val in componentsInChildren)
			{
				if (IsAppearanceRenderer(val, requireEnabled: false))
				{
					Material[] sharedMaterials = val.sharedMaterials;
					for (int num2 = 0; num2 < sharedMaterials.Length; num2++)
					{
						sharedMaterials[num2] = array2[Mathf.Min(num2, array2.Length - 1)];
					}
					val.sharedMaterials = sharedMaterials;
				}
			}
		}

		private static bool IsAppearanceRenderer(Renderer renderer, bool requireEnabled)
		{
			if ((Object)(object)renderer == (Object)null || renderer.sharedMaterials == null || renderer.sharedMaterials.Length == 0 || renderer is ParticleSystemRenderer || renderer is LineRenderer || renderer is TrailRenderer)
			{
				return false;
			}
			if (requireEnabled && !renderer.enabled)
			{
				return false;
			}
			if (!(renderer is MeshRenderer) && !(renderer is SkinnedMeshRenderer))
			{
				return false;
			}
			if (HasAppearanceExcludedName(((Object)renderer).name) || HasAppearanceExcludedName(GetTransformPath(((Component)renderer).transform)))
			{
				return false;
			}
			bool result = false;
			Material[] sharedMaterials = renderer.sharedMaterials;
			foreach (Material val in sharedMaterials)
			{
				if (!((Object)(object)val == (Object)null))
				{
					string name = CleanMaterialName(((Object)val).name);
					string name2 = (((Object)(object)val.shader == (Object)null) ? string.Empty : ((Object)val.shader).name);
					if (HasAppearanceExcludedName(name) || IsObscuringEffectName(name2))
					{
						return false;
					}
					result = true;
				}
			}
			return result;
		}

		private static bool HasAppearanceExcludedName(string name)
		{
			if (string.IsNullOrWhiteSpace(name))
			{
				return false;
			}
			if (name.IndexOf("particle", StringComparison.OrdinalIgnoreCase) < 0 && name.IndexOf("poof", StringComparison.OrdinalIgnoreCase) < 0 && name.IndexOf("steam", StringComparison.OrdinalIgnoreCase) < 0 && name.IndexOf("smoke", StringComparison.OrdinalIgnoreCase) < 0 && name.IndexOf("fog", StringComparison.OrdinalIgnoreCase) < 0 && name.IndexOf("spark", StringComparison.OrdinalIgnoreCase) < 0 && name.IndexOf("light", StringComparison.OrdinalIgnoreCase) < 0 && name.IndexOf("beam", StringComparison.OrdinalIgnoreCase) < 0 && name.IndexOf("money", StringComparison.OrdinalIgnoreCase) < 0 && name.IndexOf("dollar", StringComparison.OrdinalIgnoreCase) < 0 && name.IndexOf("cash", StringComparison.OrdinalIgnoreCase) < 0 && name.IndexOf("bubble", StringComparison.OrdinalIgnoreCase) < 0 && name.IndexOf("shadow", StringComparison.OrdinalIgnoreCase) < 0 && name.IndexOf("backpack", StringComparison.OrdinalIgnoreCase) < 0 && name.IndexOf("item", StringComparison.OrdinalIgnoreCase) < 0 && name.IndexOf("rope", StringComparison.OrdinalIgnoreCase) < 0 && name.IndexOf("balloon", StringComparison.OrdinalIgnoreCase) < 0 && name.IndexOf("screen", StringComparison.OrdinalIgnoreCase) < 0 && name.IndexOf("ui", StringComparison.OrdinalIgnoreCase) < 0)
			{
				return name.IndexOf("sfx", StringComparison.OrdinalIgnoreCase) >= 0;
			}
			return true;
		}

		private static string GetTransformPath(Transform transform)
		{
			if ((Object)(object)transform == (Object)null)
			{
				return string.Empty;
			}
			List<string> list = new List<string>();
			while ((Object)(object)transform != (Object)null)
			{
				list.Add(((Object)transform).name ?? string.Empty);
				transform = transform.parent;
			}
			list.Reverse();
			return string.Join("/", list.ToArray());
		}

		private bool EnsureConcertLoaded()
		{
			if ((Object)(object)_concertRoot != (Object)null)
			{
				return true;
			}
			_borrowableMaterials = BuildBorrowableMaterialMap();
			_borrowableShaders = BuildBorrowableShaderMap();
			if ((Object)(object)_bundle == (Object)null)
			{
				string text = FindBundlePath();
				if (text == null)
				{
					Log.LogWarning((object)"Missing asset bundle: peak_bbno_concert. Put it under BepInEx/plugins/BBNO-COS/ after Unity build.");
					return false;
				}
				_bundle = AssetBundle.LoadFromFile(text);
				if ((Object)(object)_bundle == (Object)null)
				{
					Log.LogError((object)("Failed to load asset bundle: " + text));
					return false;
				}
				Log.LogInfo((object)"Loaded asset bundle:");
				string[] allAssetNames = _bundle.GetAllAssetNames();
				foreach (string text2 in allAssetNames)
				{
					Log.LogInfo((object)("  " + text2));
				}
			}
			GameObject val = LoadConcertPrefab();
			if ((Object)(object)val == (Object)null)
			{
				Log.LogError((object)"No GameObject prefab was found in the BBNO asset bundle.");
				return false;
			}
			_concertRoot = Object.Instantiate<GameObject>(val);
			((Object)_concertRoot).name = "BBNOConcertRoot";
			_concertRoot.SetActive(false);
			Object.DontDestroyOnLoad((Object)(object)_concertRoot);
			_bingBongRainBoostApplied = false;
			FixConcertAppearance(_concertRoot, _borrowableMaterials, _borrowableShaders);
			_director = _concertRoot.GetComponentInChildren<PlayableDirector>(true);
			_concertAudioSources = _concertRoot.GetComponentsInChildren<AudioSource>(true);
			float configuredConcertVolume = GetConfiguredConcertVolume();
			AudioSource[] concertAudioSources = _concertAudioSources;
			foreach (AudioSource obj in concertAudioSources)
			{
				obj.spatialBlend = 0f;
				obj.volume = configuredConcertVolume;
			}
			_lastAppliedConcertVolume = configuredConcertVolume;
			Log.LogInfo((object)$"Instantiated concert prefab. PlayableDirector found: {(Object)(object)_director != (Object)null}. AudioSources: {_concertAudioSources.Length}");
			return true;
		}

		private static Dictionary<string, Material> BuildBorrowableMaterialMap()
		{
			Dictionary<string, Material> dictionary = new Dictionary<string, Material>(StringComparer.OrdinalIgnoreCase);
			Material[] array = Resources.FindObjectsOfTypeAll<Material>();
			foreach (Material val in array)
			{
				if (!((Object)(object)val == (Object)null) && !((Object)(object)val.shader == (Object)null) && !IsBadShader(val.shader))
				{
					string text = CleanMaterialName(((Object)val).name);
					if (text.Length != 0 && !dictionary.ContainsKey(text))
					{
						dictionary.Add(text, val);
					}
				}
			}
			ManualLogSource log = Log;
			if (log != null)
			{
				log.LogInfo((object)$"Borrowable current-game materials: {dictionary.Count}.");
			}
			return dictionary;
		}

		private static Dictionary<string, Shader> BuildBorrowableShaderMap()
		{
			Dictionary<string, Shader> dictionary = new Dictionary<string, Shader>(StringComparer.OrdinalIgnoreCase);
			Material[] array = Resources.FindObjectsOfTypeAll<Material>();
			foreach (Material val in array)
			{
				if (!((Object)(object)val == (Object)null) && !((Object)(object)val.shader == (Object)null) && !IsBadShader(val.shader))
				{
					string name = ((Object)val.shader).name;
					if (!string.IsNullOrWhiteSpace(name) && !dictionary.ContainsKey(name))
					{
						dictionary.Add(name, val.shader);
					}
				}
			}
			ManualLogSource log = Log;
			if (log != null)
			{
				log.LogInfo((object)string.Format("Borrowable current-game shaders: {0}. W/Character available: {1}.", dictionary.Count, dictionary.ContainsKey("W/Character")));
			}
			return dictionary;
		}

		private static void FixConcertAppearance(GameObject root, IReadOnlyDictionary<string, Material> borrowableMaterials, IReadOnlyDictionary<string, Shader> borrowableShaders)
		{
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0249: Unknown result type (might be due to invalid IL or missing references)
			//IL_0216: Unknown result type (might be due to invalid IL or missing references)
			//IL_0221: Unknown result type (might be due to invalid IL or missing references)
			//IL_0380: Unknown result type (might be due to invalid IL or missing references)
			//IL_0385: Unknown result type (might be due to invalid IL or missing references)
			//IL_038e: Unknown result type (might be due to invalid IL or missing references)
			//IL_039c: Unknown result type (might be due to invalid IL or missing references)
			//IL_03aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0308: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			int num2 = 0;
			int num3 = 0;
			Transform[] componentsInChildren = root.GetComponentsInChildren<Transform>(true);
			Renderer[] componentsInChildren2;
			foreach (Transform val in componentsInChildren)
			{
				if (string.Equals(((Object)val).name, "Chicken", StringComparison.OrdinalIgnoreCase))
				{
					componentsInChildren2 = ((Component)val).GetComponentsInChildren<Renderer>(true);
					for (int j = 0; j < componentsInChildren2.Length; j++)
					{
						componentsInChildren2[j].enabled = false;
						num2++;
					}
					ParticleSystem[] componentsInChildren3 = ((Component)val).GetComponentsInChildren<ParticleSystem>(true);
					foreach (ParticleSystem obj in componentsInChildren3)
					{
						EmissionModule emission = obj.emission;
						((EmissionModule)(ref emission)).enabled = false;
						obj.Stop(true, (ParticleSystemStopBehavior)0);
						obj.Clear(true);
						num3++;
					}
					((Component)val).gameObject.SetActive(false);
					num++;
				}
			}
			int num4 = 0;
			int num5 = 0;
			int num6 = 0;
			int num7 = 0;
			int num8 = 0;
			int num9 = 0;
			int num10 = 0;
			int num11 = DisableFogParticles(root);
			int num12 = SoftenLargeSteamParticles(root);
			Shader val2 = FindFirstShader("Universal Render Pipeline/Lit", "Universal Render Pipeline/Simple Lit", "Standard");
			Shader val3 = FindFirstShader("Universal Render Pipeline/Unlit", "Unlit/Texture", "Unlit/Color");
			Shader val4 = FindFirstShader("Universal Render Pipeline/Particles/Unlit", "Particles/Standard Unlit", "Legacy Shaders/Particles/Alpha Blended", "Unlit/Transparent", "Unlit/Texture");
			componentsInChildren2 = root.GetComponentsInChildren<Renderer>(true);
			foreach (Renderer val5 in componentsInChildren2)
			{
				if (ShouldHideObscuringConcertRenderer(val5))
				{
					val5.enabled = false;
					num10++;
					continue;
				}
				Material[] materials = val5.materials;
				bool flag = false;
				foreach (Material val6 in materials)
				{
					if ((Object)(object)val6 == (Object)null)
					{
						continue;
					}
					Color val7 = ReadBestMaterialColor(val6);
					Texture sourceTexture = ReadBestMaterialTexture(val6);
					string key = CleanMaterialName(((Object)val6).name);
					Material value;
					if (LooksLikeMoneyMaterial(val6, val5))
					{
						Shader val8 = val4 ?? val3 ?? val2;
						if ((Object)(object)val8 != (Object)null)
						{
							val6.shader = val8;
						}
						ApplyLegacyMaterialPayload(val6, val7, sourceTexture);
						ConfigureTransparentMaterial(val6, val7);
						num9++;
						flag = true;
					}
					else if (borrowableMaterials != null && borrowableMaterials.TryGetValue(key, out value))
					{
						ApplyBorrowedShader(val6, value, val7, sourceTexture);
						num5++;
						flag = true;
					}
					else if ((Object)(object)val6.shader == (Object)null || IsBadShader(val6.shader) || ShouldReplaceOldBundleShader(val6))
					{
						Shader val9 = FindReplacementShader(val6, borrowableShaders);
						if ((Object)(object)val9 != (Object)null)
						{
							ApplyRuntimeShaderOnly(val6, val9);
							num6++;
							flag = true;
						}
						else
						{
							bool flag2 = LooksLikeEffectMaterial(val6) || val5 is ParticleSystemRenderer;
							Shader val10 = (flag2 ? (val4 ?? val3 ?? val2) : val2);
							if ((Object)(object)val10 != (Object)null)
							{
								val6.shader = val10;
								ApplyLegacyMaterialPayload(val6, val7, sourceTexture);
								if (flag2)
								{
									ConfigureTransparentMaterial(val6, val7);
								}
								num8++;
								flag = true;
							}
						}
					}
					else
					{
						Shader val11 = FindReplacementShader(val6, borrowableShaders);
						if ((Object)(object)val11 != (Object)null && (Object)(object)val11 != (Object)(object)val6.shader)
						{
							ApplyRuntimeShaderOnly(val6, val11);
							num7++;
							flag = true;
						}
					}
					if (((Object)val6).name.IndexOf("skin", StringComparison.OrdinalIgnoreCase) >= 0)
					{
						if (ShouldPreservePeakMaterialProperties(val6, val6.shader))
						{
							ConfigureSolidRenderState(val6);
						}
						else
						{
							Color color = ResolveSkinColor(val6);
							SetMaterialColor(val6, "_BaseColor", color);
							SetMaterialColor(val6, "_Color", color);
							SetMaterialColor(val6, "_Color1", color);
							SetMaterialColor(val6, "_SkinColor", color);
							ConfigureSolidMaterial(val6, color);
						}
						num4++;
						flag = true;
					}
					else if (LooksLikeSolidConcertMaterial(val6))
					{
						if (ShouldPreservePeakMaterialProperties(val6, val6.shader))
						{
							ConfigureSolidRenderState(val6);
						}
						else
						{
							ConfigureSolidMaterial(val6, val7);
						}
						flag = true;
					}
				}
				if (flag)
				{
					val5.materials = materials;
				}
			}
			ManualLogSource log = Log;
			if (log != null)
			{
				log.LogInfo((object)$"Appearance fix applied. Hidden Chicken objects: {num}. Disabled chicken renderers: {num2}. Disabled chicken particles: {num3}. Disabled fog particles: {num11}. Softened large steam particles: {num12}. Hidden screen fog overlays: {num10}. Borrowed shaders: {num5}. Borrowed shader-only: {num6}. Runtime shader swaps: {num7}. Fallback shaders: {num8}. Fixed skin materials: {num4}. Fixed money materials: {num9}.");
			}
		}

		private static int SoftenLargeSteamParticles(GameObject root)
		{
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			ParticleSystem[] componentsInChildren = root.GetComponentsInChildren<ParticleSystem>(true);
			foreach (ParticleSystem val in componentsInChildren)
			{
				Transform transform = ((Component)val).transform;
				if (string.Equals(((Object)transform).name, "Steam", StringComparison.OrdinalIgnoreCase) && !((Object)(object)transform.parent == (Object)null) && string.Equals(((Object)transform.parent).name, "BBNO Timeline", StringComparison.OrdinalIgnoreCase))
				{
					MainModule main = val.main;
					((MainModule)(ref main)).startColor = new MinMaxGradient(new Color(1f, 1f, 1f, 0.16f));
					ParticleSystemRenderer component = ((Component)val).GetComponent<ParticleSystemRenderer>();
					if ((Object)(object)component != (Object)null)
					{
						component.maxParticleSize = Mathf.Min(component.maxParticleSize, 0.18f);
						component.sortingFudge = Mathf.Min(component.sortingFudge, -0.5f);
					}
					num++;
				}
			}
			return num;
		}

		private static int DisableFogParticles(GameObject root)
		{
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			ParticleSystem[] componentsInChildren = root.GetComponentsInChildren<ParticleSystem>(true);
			foreach (ParticleSystem val in componentsInChildren)
			{
				Transform transform = ((Component)val).transform;
				string name = ((Object)transform).name ?? string.Empty;
				string name2 = (((Object)(object)transform.parent == (Object)null) ? string.Empty : ((Object)transform.parent).name);
				ParticleSystemRenderer component = ((Component)val).GetComponent<ParticleSystemRenderer>();
				bool flag = false;
				if ((Object)(object)component != (Object)null)
				{
					Material[] sharedMaterials = ((Renderer)component).sharedMaterials;
					foreach (Material val2 in sharedMaterials)
					{
						if (!((Object)(object)val2 == (Object)null))
						{
							string name3 = (((Object)(object)val2.shader == (Object)null) ? string.Empty : ((Object)val2.shader).name);
							if (IsObscuringEffectName(CleanMaterialName(((Object)val2).name)) || IsObscuringEffectName(name3))
							{
								flag = true;
								break;
							}
						}
					}
				}
				if (IsObscuringEffectName(name) || IsObscuringEffectName(name2) || flag)
				{
					EmissionModule emission = val.emission;
					((EmissionModule)(ref emission)).enabled = false;
					val.Stop(true, (ParticleSystemStopBehavior)0);
					val.Clear(true);
					if ((Object)(object)component != (Object)null)
					{
						((Renderer)component).enabled = false;
					}
					num++;
				}
			}
			return num;
		}

		private static void ApplyBorrowedShader(Material target, Material borrowed, Color sourceColor, Texture sourceTexture)
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			target.shader = borrowed.shader;
			target.renderQueue = borrowed.renderQueue;
			target.enableInstancing = borrowed.enableInstancing;
			if (!ShouldPreservePeakMaterialProperties(target, borrowed.shader))
			{
				ApplyLegacyMaterialPayload(target, sourceColor, sourceTexture);
			}
		}

		private static void ApplyRuntimeShaderOnly(Material target, Shader shader)
		{
			int renderQueue = target.renderQueue;
			target.shader = shader;
			target.renderQueue = renderQueue;
		}

		private static Shader FindReplacementShader(Material material, IReadOnlyDictionary<string, Shader> borrowableShaders)
		{
			if ((Object)(object)material == (Object)null || (Object)(object)material.shader == (Object)null)
			{
				return null;
			}
			string name = ((Object)material.shader).name;
			if (!ShouldReplaceOldBundleShader(material))
			{
				return null;
			}
			if (borrowableShaders != null && borrowableShaders.TryGetValue(name, out var value) && (Object)(object)value != (Object)null && !IsBadShader(value))
			{
				return value;
			}
			Shader val = Shader.Find(name);
			if ((Object)(object)val != (Object)null && !IsBadShader(val))
			{
				return val;
			}
			return null;
		}

		private static bool ShouldPreservePeakMaterialProperties(Material material, Shader replacementShader)
		{
			if (IsPeakCustomCharacterShaderName(((Object)(object)replacementShader == (Object)null) ? string.Empty : ((Object)replacementShader).name))
			{
				return true;
			}
			if (!material.HasProperty("_SkinColor") && !material.HasProperty("_Color1") && !material.HasProperty("_Color2") && !material.HasProperty("_Color3") && !material.HasProperty("_Color4") && !material.HasProperty("_VertexGhost"))
			{
				return material.HasProperty("_UseSkinTone");
			}
			return true;
		}

		private static void ApplyLegacyMaterialPayload(Material material, Color sourceColor, Texture sourceTexture)
		{
			//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_002a: Unknown result type (might be due to invalid IL or missing references)
			SetMaterialColor(material, "_BaseColor", sourceColor);
			SetMaterialColor(material, "_Color", sourceColor);
			SetMaterialColor(material, "_Color1", sourceColor);
			SetMaterialColor(material, "_Tint", sourceColor);
			if ((Object)(object)sourceTexture != (Object)null)
			{
				SetMaterialTexture(material, "_BaseMap", sourceTexture);
				SetMaterialTexture(material, "_MainTex", sourceTexture);
				SetMaterialTexture(material, "_Texture1", sourceTexture);
				SetMaterialTexture(material, "_Texture", sourceTexture);
				SetMaterialTexture(material, "_Textureu", sourceTexture);
				SetMaterialTexture(material, "_Shape", sourceTexture);
				SetMaterialTexture(material, "_BaseColorMap", sourceTexture);
			}
		}

		private static Color ReadBestMaterialColor(Material material)
		{
			//IL_0086: 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_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			string[] array = new string[5] { "_Tint", "_BaseColor", "_Color", "_Color1", "_SkinColor" };
			foreach (string text in array)
			{
				if (material.HasProperty(text))
				{
					Color color = material.GetColor(text);
					if (((Color)(ref color)).maxColorComponent > 0.01f || color.a > 0.01f)
					{
						color.a = Mathf.Max(color.a, 1f);
						return color;
					}
				}
			}
			return Color.white;
		}

		private static Texture ReadBestMaterialTexture(Material material)
		{
			string[] array = new string[11]
			{
				"_BaseMap", "_MainTex", "_Textureu", "_Texture1", "_Texture2", "_Texture3", "_Texture4", "_Texture", "_Shape", "_BaseColorMap",
				"_DistortionTexture"
			};
			foreach (string text in array)
			{
				if (material.HasProperty(text))
				{
					Texture texture = material.GetTexture(text);
					if ((Object)(object)texture != (Object)null)
					{
						return texture;
					}
				}
			}
			return null;
		}

		private static void SetMaterialTexture(Material material, string propertyName, Texture texture)
		{
			if ((Object)(object)texture != (Object)null && material.HasProperty(propertyName))
			{
				material.SetTexture(propertyName, texture);
			}
		}

		private static Shader FindFirstShader(params string[] shaderNames)
		{
			for (int i = 0; i < shaderNames.Length; i++)
			{
				Shader val = Shader.Find(shaderNames[i]);
				if ((Object)(object)val != (Object)null)
				{
					return val;
				}
			}
			return null;
		}

		private static bool IsBadShader(Shader shader)
		{
			if ((Object)(object)shader == (Object)null)
			{
				return true;
			}
			string name = ((Object)shader).name;
			if (name.IndexOf("error", StringComparison.OrdinalIgnoreCase) < 0 && name.IndexOf("fallback", StringComparison.OrdinalIgnoreCase) < 0)
			{
				return name.IndexOf("hidden/internalerror", StringComparison.OrdinalIgnoreCase) >= 0;
			}
			return true;
		}

		private static bool ShouldReplaceOldBundleShader(Material material)
		{
			string text = (((Object)(object)material.shader == (Object)null) ? string.Empty : ((Object)material.shader).name);
			if (text.IndexOf("Shader Graphs", StringComparison.OrdinalIgnoreCase) >= 0 || text.IndexOf("Shader Graph", StringComparison.OrdinalIgnoreCase) >= 0 || IsPeakCustomCharacterShaderName(text) || text.StartsWith("GD/", StringComparison.OrdinalIgnoreCase))
			{
				return true;
			}
			return false;
		}

		private static bool IsPeakCustomCharacterShaderName(string shaderName)
		{
			if (string.IsNullOrWhiteSpace(shaderName))
			{
				return false;
			}
			if (!shaderName.Equals("W/Character", StringComparison.OrdinalIgnoreCase) && !shaderName.StartsWith("W/Character", StringComparison.OrdinalIgnoreCase))
			{
				return shaderName.StartsWith("W/Peak", StringComparison.OrdinalIgnoreCase);
			}
			return true;
		}

		private static bool LooksLikeEffectMaterial(Material material)
		{
			string text = CleanMaterialName(((Object)material).name);
			if (text.IndexOf("vfx", StringComparison.OrdinalIgnoreCase) < 0 && text.IndexOf("particle", StringComparison.OrdinalIgnoreCase) < 0 && text.IndexOf("beam", StringComparison.OrdinalIgnoreCase) < 0 && text.IndexOf("light", StringComparison.OrdinalIgnoreCase) < 0 && text.IndexOf("music", StringComparison.OrdinalIgnoreCase) < 0 && text.IndexOf("smoke", StringComparison.OrdinalIgnoreCase) < 0)
			{
				return text.IndexOf("fog", StringComparison.OrdinalIgnoreCase) >= 0;
			}
			return true;
		}

		private static bool LooksLikeMoneyMaterial(Material material, Renderer renderer)
		{
			string text = CleanMaterialName(((Object)material).name);
			string text2 = (((Object)(object)renderer == (Object)null) ? string.Empty : ((Object)renderer).name);
			string text3 = (((Object)(object)renderer == (Object)null || (Object)(object)((Component)renderer).transform.parent == (Object)null) ? string.Empty : ((Object)((Component)renderer).transform.parent).name);
			if (text.IndexOf("dollar", StringComparison.OrdinalIgnoreCase) < 0 && text.IndexOf("money", StringComparison.OrdinalIgnoreCase) < 0 && text2.IndexOf("money", StringComparison.OrdinalIgnoreCase) < 0)
			{
				return text3.IndexOf("money", StringComparison.OrdinalIgnoreCase) >= 0;
			}
			return true;
		}

		private static bool LooksLikeSolidConcertMaterial(Material material)
		{
			string text = CleanMaterialName(((Object)material).name);
			if (text.Length == 0)
			{
				return false;
			}
			if (text.IndexOf("glass", StringComparison.OrdinalIgnoreCase) >= 0 || text.IndexOf("visor", StringComparison.OrdinalIgnoreCase) >= 0 || text.IndexOf("water", StringComparison.OrdinalIgnoreCase) >= 0 || text.IndexOf("shadow", StringComparison.OrdinalIgnoreCase) >= 0 || text.IndexOf("screen", StringComparison.OrdinalIgnoreCase) >= 0 || text.IndexOf("mouth", StringComparison.OrdinalIgnoreCase) >= 0 || text.IndexOf("eye", StringComparison.OrdinalIgnoreCase) >= 0 || text.IndexOf("glasses", StringComparison.OrdinalIgnoreCase) >= 0 || text.IndexOf("ui", StringComparison.OrdinalIgnoreCase) >= 0 || LooksLikeEffectMaterial(material))
			{
				return false;
			}
			if (text.IndexOf("scout", StringComparison.OrdinalIgnoreCase) < 0 && text.IndexOf("bbno", StringComparison.OrdinalIgnoreCase) < 0 && text.IndexOf("bingbong", StringComparison.OrdinalIgnoreCase) < 0 && text.IndexOf("ironmouse", StringComparison.OrdinalIgnoreCase) < 0 && text.IndexOf("costume", StringComparison.OrdinalIgnoreCase) < 0 && text.IndexOf("sash", StringComparison.OrdinalIgnoreCase) < 0 && text.IndexOf("shirt", StringComparison.OrdinalIgnoreCase) < 0 && text.IndexOf("short", StringComparison.OrdinalIgnoreCase) < 0 && text.IndexOf("skirt", StringComparison.OrdinalIgnoreCase) < 0)
			{
				return text.IndexOf("skin", StringComparison.OrdinalIgnoreCase) >= 0;
			}
			return true;
		}

		private static bool ShouldHideObscuringConcertRenderer(Renderer renderer)
		{
			if ((Object)(object)renderer == (Object)null)
			{
				return false;
			}
			string name = ((Object)renderer).name ?? string.Empty;
			string name2 = (((Object)(object)((Component)renderer).transform.parent == (Object)null) ? string.Empty : ((Object)((Component)renderer).transform.parent).name);
			if (IsObscuringEffectName(name) || IsObscuringEffectName(name2))
			{
				return true;
			}
			Material[] sharedMaterials = renderer.sharedMaterials;
			foreach (Material val in sharedMaterials)
			{
				if (!((Object)(object)val == (Object)null))
				{
					string name3 = (((Object)(object)val.shader == (Object)null) ? string.Empty : ((Object)val.shader).name);
					if (IsObscuringEffectName(CleanMaterialName(((Object)val).name)) || IsObscuringEffectName(name3))
					{
						return true;
					}
				}
			}
			return false;
		}

		private static bool IsObscuringEffectName(string name)
		{
			if (string.IsNullOrWhiteSpace(name))
			{
				return false;
			}
			if (name.IndexOf("screen space fog", StringComparison.OrdinalIgnoreCase) < 0 && name.IndexOf("screen fog", StringComparison.OrdinalIgnoreCase) < 0 && name.IndexOf("fogdepth", StringComparison.OrdinalIgnoreCase) < 0 && name.IndexOf("fog depth", StringComparison.OrdinalIgnoreCase) < 0 && name.IndexOf("fog feature", StringComparison.OrdinalIgnoreCase) < 0 && name.IndexOf("fogfeature", StringComparison.OrdinalIgnoreCase) < 0 && name.IndexOf("sphere fog", StringComparison.OrdinalIgnoreCase) < 0 && name.IndexOf("spherefog", StringComparison.OrdinalIgnoreCase) < 0 && name.IndexOf("storm fog", StringComparison.OrdinalIgnoreCase) < 0 && name.IndexOf("stormfog", StringComparison.OrdinalIgnoreCase) < 0 && name.IndexOf("fog orb", StringComparison.OrdinalIgnoreCase) < 0 && name.IndexOf("fogorb", StringComparison.OrdinalIgnoreCase) < 0 && name.IndexOf("fog wall", StringComparison.OrdinalIgnoreCase) < 0 && name.IndexOf("fogwall", StringComparison.OrdinalIgnoreCase) < 0 && name.IndexOf("fog plane", StringComparison.OrdinalIgnoreCase) < 0 && name.IndexOf("fogplane", StringComparison.OrdinalIgnoreCase) < 0 && name.IndexOf("rain fog", StringComparison.OrdinalIgnoreCase) < 0 && name.IndexOf("rainfog", StringComparison.OrdinalIgnoreCase) < 0 && name.IndexOf("snow fog", StringComparison.OrdinalIgnoreCase) < 0 && name.IndexOf("snowfog", StringComparison.OrdinalIgnoreCase) < 0 && name.IndexOf("screenfog", StringComparison.OrdinalIgnoreCase) < 0 && name.IndexOf("gd/spherefog", StringComparison.OrdinalIgnoreCase) < 0 && name.IndexOf("gd/screenfog", StringComparison.OrdinalIgnoreCase) < 0)
			{
				return name.IndexOf("fog", StringComparison.OrdinalIgnoreCase) >= 0;
			}
			return true;
		}

		private static void ConfigureSolidMaterial(Material material, Color color)
		{
			//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_002a: Unknown result type (might be due to invalid IL or missing references)
			color.a = 1f;
			SetMaterialColor(material, "_BaseColor", color);
			SetMaterialColor(material, "_Color", color);
			SetMaterialColor(material, "_Color1", color);
			SetMaterialFloat(material, "_Surface", 0f);
			SetMaterialFloat(material, "_AlphaClip", 0f);
			SetMaterialFloat(material, "_Mode", 0f);
			SetMaterialFloat(material, "_Blend", 0f);
			SetMaterialFloat(material, "_SrcBlend", 1f);
			SetMaterialFloat(material, "_DstBlend", 0f);
			SetMaterialFloat(material, "_SrcBlendAlpha", 1f);
			SetMaterialFloat(material, "_DstBlendAlpha", 0f);
			SetMaterialFloat(material, "_ZWrite", 1f);
			SetMaterialFloat(material, "_Opacity", 1f);
			SetMaterialFloat(material, "_VertexGhost", 0f);
			SetMaterialFloat(material, "_UseTextureAlpha", 0f);
			SetMaterialFloat(material, "_AlphaSource", 0f);
			SetMaterialFloat(material, "_QueueControl", 0f);
			SetMaterialFloat(material, "_QueueOffset", 0f);
			material.renderQueue = -1;
			material.DisableKeyword("_SURFACE_TYPE_TRANSPARENT");
			material.DisableKeyword("_ALPHATEST_ON");
			material.DisableKeyword("_ALPHABLEND_ON");
			material.DisableKeyword("_ALPHAPREMULTIPLY_ON");
		}

		private static void ConfigureSolidRenderState(Material material)
		{
			SetMaterialFloat(material, "_Surface", 0f);
			SetMaterialFloat(material, "_AlphaClip", 0f);
			SetMaterialFloat(material, "_Mode", 0f);
			SetMaterialFloat(material, "_Blend", 0f);
			SetMaterialFloat(material, "_SrcBlend", 1f);
			SetMaterialFloat(material, "_DstBlend", 0f);
			SetMaterialFloat(material, "_SrcBlendAlpha", 1f);
			SetMaterialFloat(material, "_DstBlendAlpha", 0f);
			SetMaterialFloat(material, "_ZWrite", 1f);
			SetMaterialFloat(material, "_Opacity", 1f);
			SetMaterialFloat(material, "_VertexGhost", 0f);
			SetMaterialFloat(material, "_UseTextureAlpha", 0f);
			SetMaterialFloat(material, "_AlphaSource", 0f);
			SetMaterialFloat(material, "_QueueControl", 0f);
			SetMaterialFloat(material, "_QueueOffset", 0f);
			material.renderQueue = -1;
			material.DisableKeyword("_SURFACE_TYPE_TRANSPARENT");
			material.DisableKeyword("_ALPHATEST_ON");
			material.DisableKeyword("_ALPHABLEND_ON");
			material.DisableKeyword("_ALPHAPREMULTIPLY_ON");
		}

		private static void ConfigureTransparentMaterial(Material material, Color color)
		{
			//IL_0002: 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_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: 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)
			color.a = Mathf.Clamp01((color.a <= 0.01f) ? 1f : color.a);
			SetMaterialColor(material, "_BaseColor", color);
			SetMaterialColor(material, "_Color", color);
			SetMaterialColor(material, "_Color1", color);
			SetMaterialFloat(material, "_Surface", 1f);
			SetMaterialFloat(material, "_AlphaClip", 0f);
			SetMaterialFloat(material, "_Mode", 2f);
			SetMaterialFloat(material, "_SrcBlend", 5f);
			SetMaterialFloat(material, "_DstBlend", 10f);
			SetMaterialFloat(material, "_ZWrite", 0f);
			material.renderQueue = 3000;
			material.EnableKeyword("_SURFACE_TYPE_TRANSPARENT");
			material.EnableKeyword("_ALPHABLEND_ON");
		}

		private static string CleanMaterialName(string name)
		{
			if (string.IsNullOrWhiteSpace(name))
			{
				return string.Empty;
			}
			return name.Replace(" (Instance)", string.Empty).Replace("(Instance)", string.Empty).Trim();
		}

		private static Color ResolveSkinColor(Material material)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			if (material.HasProperty("_SkinColor"))
			{
				Color color = material.GetColor("_SkinColor");
				color.a = 1f;
				if (((Color)(ref color)).maxColorComponent > 0.01f)
				{
					return color;
				}
			}
			string name = ((Object)material).name;
			if (name.IndexOf("IronMouse", StringComparison.OrdinalIgnoreCase) >= 0)
			{
				return new Color(1f, 0.39f, 0.61f, 1f);
			}
			if (name.IndexOf("vanilla", StringComparison.OrdinalIgnoreCase) >= 0)
			{
				return new Color(1f, 0.76f, 0.11f, 1f);
			}
			return new Color(0.92f, 0.52f, 0.23f, 1f);
		}

		private static void SetMaterialColor(Material material, string propertyName, Color color)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			if (material.HasProperty(propertyName))
			{
				material.SetColor(propertyName, color);
			}
		}

		private static void SetMaterialFloat(Material material, string propertyName, float value)
		{
			if (material.HasProperty(propertyName))
			{
				material.SetFloat(propertyName, value);
			}
		}

		private void ApplyConcertSky()
		{
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Unknown result type (might be due to invalid IL or missing references)
			//IL_014c: Unknown result type (might be due to invalid IL or missing references)
			//IL_014e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0150: Unknown result type (might be due to invalid IL or missing references)
			//IL_0169: Unknown result type (might be due to invalid IL or missing references)
			//IL_016b: Unknown result type (might be due to invalid IL or missing references)
			//IL_016d: Unknown result type (might be due to invalid IL or missing references)
			//IL_017a: Unknown result type (might be due to invalid IL or missing references)
			//IL_017d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0182: Unknown result type (might be due to invalid IL or missing references)
			//IL_0184: Unknown result type (might be due to invalid IL or missing references)
			//IL_0185: Unknown result type (might be due to invalid IL or missing references)
			//IL_0188: Unknown result type (might be due to invalid IL or missing references)
			//IL_018d: Unknown result type (might be due to invalid IL or missing references)
			//IL_018f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0190: Unknown result type (might be due to invalid IL or missing references)
			//IL_0193: Unknown result type (might be due to invalid IL or missing references)
			//IL_0198: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0214: Unknown result type (might be due to invalid IL or missing references)
			//IL_0216: Unknown result type (might be due to invalid IL or missing references)
			//IL_0220: Unknown result type (might be due to invalid IL or missing references)
			//IL_0222: 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_0252: Unknown result type (might be due to invalid IL or missing references)
			//IL_0254: Unknown result type (might be due to invalid IL or missing references)
			//IL_026c: Unknown result type (might be due to invalid IL or missing references)
			double num = (((Object)(object)_director == (Object)null) ? 68.45 : _director.time);
			float num2 = Mathf.SmoothStep(0f, 1f, Mathf.InverseLerp(68.45f, 71f, (float)num));
			Color val = new Color(0f, 0.17f, 0.26f, 1f);
			Color val2 = default(Color);
			((Color)(ref val2))..ctor(0.31f, 0.12f, 0.28f, 1f);
			Color val3 = default(Color);
			((Color)(ref val3))..ctor(0.16f, 0.17f, 1f, 1f);
			Color targetTop = default(Color);
			((Color)(ref targetTop))..ctor(1f, 0.3f, 0f, 1f);
			Color targetMid = default(Color);
			((Color)(ref targetMid))..ctor(1f, 0f, 0.33f, 1f);
			Color targetBottom = default(Color);
			((Color)(ref targetBottom))..ctor(1f, 0.3f, 0.17f, 1f);
			Color targetTop2 = default(Color);
			((Color)(ref targetTop2))..ctor(0.08f, 0.38f, 0.82f, 1f);
			Color targetMid2 = default(Color);
			((Color)(ref targetMid2))..ctor(0f, 0.62f, 0.95f, 1f);
			Color targetBottom2 = default(Color);
			((Color)(ref targetBottom2))..ctor(0f, 0.36f, 0.86f, 1f);
			Color top = val;
			Color mid = val2;
			Color bottom = val3;
			BlendTimelineSkyProfile((float)num, 223.88333f, 8f, targetTop, targetMid, targetBottom, ref top, ref mid, ref bottom);
			BlendTimelineSkyProfile((float)num, 438.75f, 8f, targetTop2, targetMid2, targetBottom2, ref top, ref mid, ref bottom);
			Color val4 = Color.Lerp(val, top, num2);
			Color val5 = Color.Lerp(val2, mid, num2);
			Color val6 = Color.Lerp(val3, bottom, num2);
			Color specialSunColor = default(Color);
			((Color)(ref specialSunColor))..ctor(1f, 0.65f, 0.39f, 1f);
			Shader.SetGlobalColor("SkyTopColor", val4);
			Shader.SetGlobalColor("SkyMidColor", val5);
			Shader.SetGlobalColor("SkyBottomColor", val6);
			Shader.SetGlobalFloat("EXTRAFOG", 0f);
			Shader.SetGlobalFloat("NoEdgeFog", 1f);
			if ((Object)(object)DayNightManager.instance != (Object)null)
			{
				DayNightManager.instance.specialDaySkyBlend = num2;
				DayNightManager.instance.specialTopColor = val4;
				DayNightManager.instance.specialMidColor = val5;
				DayNightManager.instance.specialBottomColor = val6;
				DayNightManager.instance.specialDaySunBlend = Mathf.Lerp(0f, 0.65f, num2);
				DayNightManager.instance.specialSunColor = specialSunColor;
			}
			Camera main = Camera.main;
			if ((Object)(object)main != (Object)null)
			{
				main.backgroundColor = val5;
			}
		}

		private void ApplyBingBongRainBoost()
		{
			//IL_0089: 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)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			if (_bingBongRainBoostApplied || (Object)(object)_concertRoot == (Object)null || (Object)(object)_director == (Object)null || _director.time < 438.75)
			{
				return;
			}
			_bingBongRainBoostApplied = true;
			Transform[] componentsInChildren = _concertRoot.GetComponentsInChildren<Transform>(true);
			foreach (Transform val in componentsInChildren)
			{
				if (!string.Equals(((Object)val).name ?? string.Empty, "Bing Bong Particles", StringComparison.OrdinalIgnoreCase))
				{
					continue;
				}
				val.localScale = new Vector3(3f, 1f, 3f);
				ParticleSystem[] componentsInChildren2 = ((Component)val).GetComponentsInChildren<ParticleSystem>(true);
				for (int j = 0; j < componentsInChildren2.Length; j++)
				{
					BoostBingBongParticleSystem(componentsInChildren2[j]);
				}
				Transform[] componentsInChildren3 = ((Component)val).GetComponentsInChildren<Transform>(true);
				foreach (Transform val2 in componentsInChildren3)
				{
					if (string.Equals(((Object)val2).name, "BIGBong", StringComparison.OrdinalIgnoreCase))
					{
						val2.localScale = Vector3.one * 180f;
					}
				}
			}
		}

		private static void BoostBingBongParticleSystem(ParticleSystem particleSystem)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)particleSystem == (Object)null))
			{
				MainModule main = particleSystem.main;
				((MainModule)(ref main)).maxParticles = Mathf.Max(((MainModule)(ref main)).maxParticles, 2000);
				((MainModule)(ref main)).startSizeMultiplier = Mathf.Max(((MainModule)(ref main)).startSizeMultiplier, 2.2f);
				EmissionModule emission = particleSystem.emission;
				if (((EmissionModule)(ref emission)).enabled && ((EmissionModule)(ref emission)).rateOverTimeMultiplier > 0f)
				{
					((EmissionModule)(ref emission)).rateOverTimeMultiplier = Mathf.Max(((EmissionModule)(ref emission)).rateOverTimeMultiplier, 2.5f);
				}
				ShapeModule shape = particleSystem.shape;
				if (((ShapeModule)(ref shape)).enabled)
				{
					((ShapeModule)(ref shape)).radius = Mathf.Max(((ShapeModule)(ref shape)).radius, 90f);
					Vector3 scale = ((ShapeModule)(ref shape)).scale;
					((ShapeModule)(ref shape)).scale = new Vector3(Mathf.Max(Mathf.Abs(scale.x), 150f), Mathf.Max(Mathf.Abs(scale.y), 25f), Mathf.Max(Mathf.Abs(scale.z), 150f));
				}
			}
		}

		private static void BlendTimelineSkyProfile(float timelineTime, float markerTime, float blendSeconds, Color targetTop, Color targetMid, Color targetBottom, ref Color top, ref Color mid, ref Color bottom)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: 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_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			if (!(timelineTime < markerTime))
			{
				float num = Mathf.SmoothStep(0f, 1f, Mathf.InverseLerp(markerTime, markerTime + blendSeconds, timelineTime));
				top = Color.Lerp(top, targetTop, num);
				mid = Color.Lerp(mid, targetMid, num);
				bottom = Color.Lerp(bottom, targetBottom, num);
			}
		}

		private void CaptureConcertFogState()
		{
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			if (!_savedFogState)
			{
				_savedFogState = true;
				if ((Object)(object)AmbienceManager.instance != (Object)null)
				{
					_savedAmbienceMaxFog = AmbienceManager.instance.maxFog;
					_savedAmbienceUseFog = AmbienceManager.instance.useFog;
				}
				_savedRenderSettingsFog = RenderSettings.fog;
				_savedRenderSettingsFogMode = RenderSettings.fogMode;
				_savedRenderSettingsFogDensity = RenderSettings.fogDensity;
				_savedRenderSettingsFogColor = RenderSettings.fogColor;
				_savedUseFogGlobal = Shader.GetGlobalFloat("USEFOG");
				_savedMaxFogGlobal = Shader.GetGlobalFloat("MAXFOG");
				_savedFogEnabledGlobal = Shader.GetGlobalFloat("FogEnabled");
				_savedFogSphereSizeGlobal = Shader.GetGlobalFloat("_FogSphereSize");
				_savedCloseDistanceModGlobal = Shader.GetGlobalFloat("CloseDistanceMod");
				_savedWeatherBlendGlobal = Shader.GetGlobalFloat("_WeatherBlend");
				_savedWindFogDensityGlobal = Shader.GetGlobalFloat("WindFogDensity");
				_savedWindFogTextureDensityGlobal = Shader.GetGlobalFloat("WindFogTextureDensity");
				_savedBandFogAmountGlobal = Shader.GetGlobalFloat("BandFogAmount");
				_savedExtraFogGlobal = Shader.GetGlobalFloat("EXTRAFOG");
				_savedNoEdgeFogGlobal = Shader.GetGlobalFloat("NoEdgeFog");
				_savedFogCenterGlobal = Shader.GetGlobalVector("FogCenter");
				_savedFakeMountainEnabledGlobal = Shader.GetGlobalFloat("FakeMountainEnabled");
			}
		}

		private static void ApplyConcertFogOverride()
		{
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)AmbienceManager.instance != (Object)null)
			{
				AmbienceManager.instance.maxFog = 160000f;
				AmbienceManager.instance.useFog = false;
			}
			RenderSettings.fog = false;
			RenderSettings.fogDensity = 0f;
			Shader.SetGlobalFloat("USEFOG", 0f);
			Shader.SetGlobalFloat("MAXFOG", 160000f);
			Shader.SetGlobalFloat("FogEnabled", 0f);
			Shader.SetGlobalFloat("_FogSphereSize", 9999999f);
			Shader.SetGlobalVector("FogCenter", new Vector4(0f, -99999f, 0f, 0f));
			Shader.SetGlobalFloat("CloseDistanceMod", 50f);
			Shader.SetGlobalFloat("NoEdgeFog", 8f);
			Shader.SetGlobalFloat("EXTRAFOG", 0f);
			Shader.SetGlobalFloat("_WeatherBlend", 0f);
			Shader.SetGlobalFloat("WindFogDensity", 0f);
			Shader.SetGlobalFloat("WindFogTextureDensity", 0f);
			Shader.SetGlobalFloat("BandFogAmount", 0f);
			Shader.SetGlobalFloat("FakeMountainEnabled", 1f);
		}

		private void ApplyConcertLightColors()
		{
			//IL_004b: 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_012c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			//IL_0146: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_concertRoot == (Object)null)
			{
				return;
			}
			Color color = Color.HSVToRGB(Mathf.Repeat((float)(((Object)(object)_director == (Object)null) ? ((double)Time.time) : _director.time) * 0.08f, 1f), 0.75f, 1f);
			color.a = 0.82f;
			Renderer[] componentsInChildren = _concertRoot.GetComponentsInChildren<Renderer>(true);
			foreach (Renderer val in componentsInChildren)
			{
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				string obj = ((Object)val).name ?? string.Empty;
				string text = (((Object)(object)((Component)val).transform.parent == (Object)null) ? string.Empty : ((Object)((Component)val).transform.parent).name);
				bool flag = obj.IndexOf("Light Beams", StringComparison.OrdinalIgnoreCase) >= 0 || text.IndexOf("Light Beams", StringComparison.OrdinalIgnoreCase) >= 0;
				Material[] sharedMaterials = val.sharedMaterials;
				bool flag2 = false;
				foreach (Material val2 in sharedMaterials)
				{
					if (!((Object)(object)val2 == (Object)null))
					{
						string text2 = CleanMaterialName(((Object)val2).name);
						if (flag || text2.IndexOf("spark", StringComparison.OrdinalIgnoreCase) >= 0)
						{
							SetMaterialColor(val2, "_BaseColor", color);
							SetMaterialColor(val2, "_Color", color);
							SetMaterialColor(val2, "_Tint", color);
							SetMaterialFloat(val2, "_Opacity", 0.82f);
							flag2 = true;
						}
					}
				}
				if (flag2)
				{
					val.sharedMaterials = sharedMaterials;
				}
			}
		}

		private void RestoreConcertFogState()
		{
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: Unknown result type (might be due to invalid IL or missing references)
			if (_savedFogState)
			{
				if ((Object)(object)AmbienceManager.instance != (Object)null)
				{
					AmbienceManager.instance.maxFog = _savedAmbienceMaxFog;
					AmbienceManager.instance.useFog = _savedAmbienceUseFog;
				}
				RenderSettings.fog = _savedRenderSettingsFog;
				RenderSettings.fogMode = _savedRenderSettingsFogMode;
				RenderSettings.fogDensity = _savedRenderSettingsFogDensity;
				RenderSettings.fogColor = _savedRenderSettingsFogColor;
				Shader.SetGlobalFloat("USEFOG", _savedUseFogGlobal);
				Shader.SetGlobalFloat("MAXFOG", _savedMaxFogGlobal);
				Shader.SetGlobalFloat("FogEnabled", _savedFogEnabledGlobal);
				Shader.SetGlobalFloat("_FogSphereSize", _savedFogSphereSizeGlobal);
				Shader.SetGlobalFloat("CloseDistanceMod", _savedCloseDistanceModGlobal);
				Shader.SetGlobalFloat("_WeatherBlend", _savedWeatherBlendGlobal);
				Shader.SetGlobalFloat("WindFogDensity", _savedWindFogDensityGlobal);
				Shader.SetGlobalFloat("WindFogTextureDensity", _savedWindFogTextureDensityGlobal);
				Shader.SetGlobalFloat("BandFogAmount", _savedBandFogAmountGlobal);
				Shader.SetGlobalFloat("EXTRAFOG", _savedExtraFogGlobal);
				Shader.SetGlobalFloat("NoEdgeFog", _savedNoEdgeFogGlobal);
				Shader.SetGlobalVector("FogCenter", _savedFogCenterGlobal);
				Shader.SetGlobalFloat("FakeMountainEnabled", _savedFakeMountainEnabledGlobal);
				_savedFogState = false;
			}
		}

		private static void ResetConcertSky()
		{
			if ((Object)(object)DayNightManager.instance != (Object)null)
			{
				DayNightManager.instance.specialDaySkyBlend = 0f;
				DayNightManager.instance.specialDaySunBlend = 0f;
			}
		}

		private void UpdateConcertVolume(float volume)
		{
			if ((Object)(object)_concertRoot == (Object)null)
			{
				return;
			}
			float num = Mathf.Clamp01(volume);
			if (_concertAudioSources == null || _concertAudioSources.Length == 0)
			{
				_concertAudioSources = _concertRoot.GetComponentsInChildren<AudioSource>(true);
			}
			if (Mathf.Abs(_lastAppliedConcertVolume - num) <= 0.001f)
			{
				return;
			}
			AudioSource[] concertAudioSources = _concertAudioSources;
			foreach (AudioSource val in concertAudioSources)
			{
				if ((Object)(object)val != (Object)null && Mathf.Abs(val.volume - num) > 0.001f)
				{
					val.volume = num;
				}
			}
			_lastAppliedConcertVolume = num;
		}

		private float GetConfiguredConcertVolume()
		{
			if (_concertVolumeConfig == null)
			{
				return 1f;
			}
			float value = _concertVolumeConfig.Value;
			float num = Mathf.Clamp01(value);
			if (Mathf.Abs(value - num) > 0.001f)
			{
				_concertVolumeConfig.Value = num;
				((BaseUnityPlugin)this).Config.Save();
			}
			return num;
		}

		private static string FindBundlePath()
		{
			string directoryName = Path.GetDirectoryName(typeof(Plugin).Assembly.Location);
			return new string[3]
			{
				Path.Combine(directoryName, "peak_bbno_concert"),
				Path.Combine(directoryName, "BBNO-COS", "peak_bbno_concert"),
				Path.Combine(Paths.PluginPath, "BBNO-COS", "peak_bbno_concert")
			}.FirstOrDefault(File.Exists);
		}

		private GameObject LoadConcertPrefab()
		{
			GameObject val = _bundle.LoadAsset<GameObject>("BBNOConcertRoot");
			if ((Object)(object)val != (Object)null)
			{
				return val;
			}
			string text = _bundle.GetAllAssetNames().FirstOrDefault((string name) => (Object)(object)_bundle.LoadAsset<GameObject>(name) != (Object)null);
			if (text != null)
			{
				return _bundle.LoadAsset<GameObject>(text);
			}
			return null;
		}
	}
}