using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Text;
using BepInEx;
using BepInEx.Configuration;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using Photon.Pun;
using Photon.Realtime;
using TMPro;
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.Events;
using UnityEngine.SceneManagement;
using UnityEngine.UI;
using Zorro.Core;
using Zorro.Core.Serizalization;
using Zorro.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyVersion("0.0.0.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace PEAKSaveManager
{
	[BepInPlugin("com.lucasandersen.peakallyouneedsavemanager", "The All You Need Save Manager", "1.0.0")]
	public sealed class SaveManagerPlugin : BaseUnityPlugin
	{
		[CompilerGenerated]
		private sealed class <>c__DisplayClass188_0
		{
			public PlayerSnapshot snapshot;

			internal bool <WaitForPlayersRoutine>b__0(Player player)
			{
				PhotonView photonView = GetPhotonView((Component)(object)player);
				if ((Object)(object)photonView == (Object)null)
				{
					return false;
				}
				Player owner = photonView.Owner;
				if (snapshot.actorNumber > 0 && owner != null && owner.ActorNumber == snapshot.actorNumber)
				{
					return true;
				}
				if (owner != null)
				{
					return string.Equals(owner.NickName, snapshot.playerName, StringComparison.OrdinalIgnoreCase);
				}
				return false;
			}
		}

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

			private object <>2__current;

			public Player player;

			public SaveManagerPlugin <>4__this;

			public PlayerSnapshot snapshot;

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

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

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

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

			private bool MoveNext()
			{
				//IL_006d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0072: Unknown result type (might be due to invalid IL or missing references)
				//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
				//IL_0194: Unknown result type (might be due to invalid IL or missing references)
				//IL_019e: Expected O, but got Unknown
				//IL_0151: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
				//IL_0117: Unknown result type (might be due to invalid IL or missing references)
				//IL_011c: Unknown result type (might be due to invalid IL or missing references)
				int num = <>1__state;
				SaveManagerPlugin saveManagerPlugin = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
				{
					<>1__state = -1;
					Character character = player.character;
					if ((Object)(object)character == (Object)null)
					{
						return false;
					}
					saveManagerPlugin.ApplyInventory(player, character, snapshot.inventory);
					saveManagerPlugin.ApplyCharacterSnapshot(character, snapshot.character);
					Vector3 val = snapshot.position.ToUnity();
					PhotonView photonView = GetPhotonView((Component)(object)character);
					Player val2 = (((Object)(object)photonView != (Object)null) ? photonView.Owner : null);
					if ((Object)(object)photonView != (Object)null && val2 != null)
					{
						photonView.RPC("WarpPlayerRPC", val2, new object[2] { val, false });
					}
					else
					{
						((Component)character).transform.position = val;
					}
					if ((Object)(object)photonView != (Object)null && photonView.IsMine)
					{
						((Component)character).transform.eulerAngles = snapshot.rotation.ToUnity();
						character.data.lookValues = snapshot.character.lookValues.ToUnity();
						RecalculateLookDirectionsMethod?.Invoke(character, null);
					}
					else if ((Object)(object)photonView == (Object)null)
					{
						((Component)character).transform.eulerAngles = snapshot.rotation.ToUnity();
					}
					ApplyCharacterVelocity(character, snapshot.velocity, snapshot.angularVelocity);
					ApplyEquippedSelection(player, character, snapshot.inventory);
					<>2__current = (object)new WaitForSeconds(0.05f);
					<>1__state = 1;
					return true;
				}
				case 1:
					<>1__state = -1;
					return false;
				}
			}

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

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

		[CompilerGenerated]
		private sealed class <EnumeratePlayersFromHandler>d__155 : IEnumerable<Player>, IEnumerable, IEnumerator<Player>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private Player <>2__current;

			private int <>l__initialThreadId;

			private IEnumerator <>7__wrap1;

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

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

			[DebuggerHidden]
			public <EnumeratePlayersFromHandler>d__155(int <>1__state)
			{
				this.<>1__state = <>1__state;
				<>l__initialThreadId = Environment.CurrentManagedThreadId;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 1)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<>7__wrap1 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				try
				{
					int num = <>1__state;
					if (num != 0)
					{
						if (num != 1)
						{
							return false;
						}
						<>1__state = -3;
					}
					else
					{
						<>1__state = -1;
						Type type = AccessTools.TypeByName("PlayerHandler");
						if (type == null)
						{
							return false;
						}
						MethodInfo methodInfo = AccessTools.Method(type, "GetAllPlayers", (Type[])null, (Type[])null);
						if (methodInfo == null)
						{
							return false;
						}
						object obj;
						try
						{
							obj = methodInfo.Invoke(null, null);
						}
						catch
						{
							return false;
						}
						if (!(obj is IEnumerable enumerable))
						{
							goto IL_00d9;
						}
						<>7__wrap1 = enumerable.GetEnumerator();
						<>1__state = -3;
					}
					while (<>7__wrap1.MoveNext())
					{
						object current = <>7__wrap1.Current;
						Player val = (Player)((current is Player) ? current : null);
						if (val != null)
						{
							<>2__current = val;
							<>1__state = 1;
							return true;
						}
					}
					<>m__Finally1();
					<>7__wrap1 = null;
					goto IL_00d9;
					IL_00d9:
					return false;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<>7__wrap1 is IDisposable disposable)
				{
					disposable.Dispose();
				}
			}

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

			[DebuggerHidden]
			IEnumerator<Player> IEnumerable<Player>.GetEnumerator()
			{
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					return this;
				}
				return new <EnumeratePlayersFromHandler>d__155(0);
			}

			[DebuggerHidden]
			IEnumerator IEnumerable.GetEnumerator()
			{
				return ((IEnumerable<Player>)this).GetEnumerator();
			}
		}

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

			private object <>2__current;

			public SaveManagerPlugin <>4__this;

			public string fullPath;

			private SaveEnvelope <envelope>5__2;

			private string <targetScene>5__3;

			private int <appliedCount>5__4;

			private List<PlayerSnapshot>.Enumerator <>7__wrap4;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if ((uint)(num - -4) <= 1u || (uint)(num - 1) <= 4u)
				{
					try
					{
						if (num == -4 || num == 5)
						{
							try
							{
							}
							finally
							{
								<>m__Finally2();
							}
						}
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<envelope>5__2 = null;
				<targetScene>5__3 = null;
				<>7__wrap4 = default(List<PlayerSnapshot>.Enumerator);
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0056: 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_02c5: 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_02f2: Unknown result type (might be due to invalid IL or missing references)
				//IL_02f7: Unknown result type (might be due to invalid IL or missing references)
				//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
				//IL_030f: Unknown result type (might be due to invalid IL or missing references)
				//IL_04ae: Unknown result type (might be due to invalid IL or missing references)
				//IL_045f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0314: Unknown result type (might be due to invalid IL or missing references)
				//IL_0316: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
				//IL_031a: Unknown result type (might be due to invalid IL or missing references)
				//IL_031c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0179: Unknown result type (might be due to invalid IL or missing references)
				//IL_017e: Unknown result type (might be due to invalid IL or missing references)
				//IL_015d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0141: Unknown result type (might be due to invalid IL or missing references)
				//IL_0320: Unknown result type (might be due to invalid IL or missing references)
				//IL_032d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0337: Expected O, but got Unknown
				bool result;
				try
				{
					int num = <>1__state;
					SaveManagerPlugin saveManagerPlugin = <>4__this;
					switch (num)
					{
					default:
						result = false;
						goto end_IL_0000;
					case 0:
						<>1__state = -1;
						if (saveManagerPlugin.isLoading)
						{
							result = false;
						}
						else
						{
							saveManagerPlugin.isLoading = true;
							saveManagerPlugin.SetStatus("Loading save...", Color.cyan, 10f);
							<>1__state = -3;
							if (!TryReadSaveEnvelope(fullPath, out <envelope>5__2, out var reason))
							{
								saveManagerPlugin.SetStatus("Incompatible save: " + reason, Color.yellow, 6f);
								result = false;
								break;
							}
							if (<envelope>5__2.players.Count == 0)
							{
								saveManagerPlugin.SetStatus("Save file has no player snapshots.", Color.yellow, 6f);
								result = false;
								break;
							}
							if (PhotonNetwork.InRoom && !PhotonNetwork.IsMasterClient)
							{
								saveManagerPlugin.SetStatus("Only host can load shared saves.", Color.yellow, 4f);
								result = false;
								break;
							}
							<targetScene>5__3 = ResolveTargetScene(<envelope>5__2.metadata);
							bool flag = SaveNeedsNonAirportScene(<envelope>5__2.metadata);
							if (string.IsNullOrWhiteSpace(<targetScene>5__3) && flag)
							{
								if (IsInAirportScene())
								{
									saveManagerPlugin.SetStatus("Saved level is unavailable or mismatched for this version.", Color.yellow, 7f);
									result = false;
									break;
								}
								saveManagerPlugin.SetStatus("Saved level mismatch. Loading into current level.", Color.yellow, 5f);
							}
							int num2;
							if (!string.IsNullOrEmpty(<targetScene>5__3))
							{
								Scene activeScene = SceneManager.GetActiveScene();
								num2 = ((!string.Equals(((Scene)(ref activeScene)).name, <targetScene>5__3, StringComparison.OrdinalIgnoreCase)) ? 1 : 0);
							}
							else
							{
								num2 = 0;
							}
							if (<envelope>5__2.metadata.levelSeed != 0)
							{
								SetPendingSeedForLoad(<envelope>5__2.metadata.levelSeed);
								((BaseUnityPlugin)saveManagerPlugin).Logger.LogInfo((object)$"Queued seed {PendingSeedForLoad.Value} for next level generation");
							}
							else
							{
								ClearPendingSeedForLoad();
							}
							if (num2 == 0)
							{
								Ascents.currentAscent = <envelope>5__2.metadata.ascent;
								goto IL_0274;
							}
							<>2__current = ((MonoBehaviour)saveManagerPlugin).StartCoroutine(saveManagerPlugin.LoadSceneRoutine(<targetScene>5__3, <envelope>5__2.metadata.ascent));
							<>1__state = 1;
							result = true;
						}
						goto end_IL_0000;
					case 1:
						<>1__state = -3;
						if (!saveManagerPlugin.lastSceneLoadSucceeded)
						{
							saveManagerPlugin.SetStatus("Failed to load scene '" + <targetScene>5__3 + "'.", Color.red, 6f);
							result = false;
							break;
						}
						goto IL_0274;
					case 2:
					{
						<>1__state = -3;
						if (saveManagerPlugin.CountMatchedPlayers(<envelope>5__2.players) <= 0)
						{
							saveManagerPlugin.SetStatus("No matching players were found for this save.", Color.yellow, 6f);
							result = false;
							break;
						}
						if (!MapHandler.Exists)
						{
							goto IL_034d;
						}
						Segment val2 = ClampSegment(<envelope>5__2.metadata.currentSegment);
						MapHandler val3 = Object.FindFirstObjectByType<MapHandler>();
						Segment val4 = (Segment)(((Object)(object)val3 != (Object)null) ? ((int)val3.GetCurrentSegment()) : 0);
						if ((int)val2 == 0 || val2 == val4)
						{
							goto IL_034d;
						}
						MapHandler.JumpToSegment(val2);
						<>2__current = (object)new WaitForSeconds(0.75f);
						<>1__state = 3;
						result = true;
						goto end_IL_0000;
					}
					case 3:
						<>1__state = -3;
						goto IL_034d;
					case 4:
						<>1__state = -3;
						<appliedCount>5__4 = 0;
						<>7__wrap4 = <envelope>5__2.players.GetEnumerator();
						<>1__state = -4;
						goto IL_042e;
					case 5:
						{
							<>1__state = -4;
							<appliedCount>5__4++;
							goto IL_042e;
						}
						IL_042e:
						while (true)
						{
							if (<>7__wrap4.MoveNext())
							{
								PlayerSnapshot current = <>7__wrap4.Current;
								Player val = saveManagerPlugin.FindPlayer(current);
								if ((Object)(object)val == (Object)null)
								{
									((BaseUnityPlugin)saveManagerPlugin).Logger.LogWarning((object)$"Could not find player for snapshot '{current.playerName}' (Actor: {current.actorNumber})");
									continue;
								}
								<>2__current = ((MonoBehaviour)saveManagerPlugin).StartCoroutine(saveManagerPlugin.ApplyPlayerSnapshotRoutine(val, current));
								<>1__state = 5;
								result = true;
							}
							else
							{
								<>m__Finally2();
								<>7__wrap4 = default(List<PlayerSnapshot>.Enumerator);
								if (<appliedCount>5__4 <= 0)
								{
									saveManagerPlugin.SetStatus("Load finished but no players were restored.", Color.yellow, 6f);
									result = false;
									break;
								}
								saveManagerPlugin.RestoreRunMetadata(<envelope>5__2.metadata);
								saveManagerPlugin.SetStatus($"Loaded save successfully ({<appliedCount>5__4}/{<envelope>5__2.players.Count} players).", Color.green, 4f);
								<envelope>5__2 = null;
								<targetScene>5__3 = null;
								<>m__Finally1();
								result = false;
							}
							goto end_IL_0000;
						}
						break;
						IL_034d:
						<>2__current = ((MonoBehaviour)saveManagerPlugin).StartCoroutine(saveManagerPlugin.RestoreWorldInteractablesRoutine(<envelope>5__2));
						<>1__state = 4;
						result = true;
						goto end_IL_0000;
						IL_0274:
						<>2__current = ((MonoBehaviour)saveManagerPlugin).StartCoroutine(WaitForPlayersRoutine(<envelope>5__2.players, 20f));
						<>1__state = 2;
						result = true;
						goto end_IL_0000;
					}
					<>m__Finally1();
					end_IL_0000:;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
				return result;
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				SaveManagerPlugin saveManagerPlugin = <>4__this;
				ClearPendingSeedForLoad();
				saveManagerPlugin.isLoading = false;
				saveManagerPlugin.RefreshSaveFileList();
			}

			private void <>m__Finally2()
			{
				<>1__state = -3;
				((IDisposable)<>7__wrap4).Dispose();
			}

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

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

			private object <>2__current;

			public SaveManagerPlugin <>4__this;

			public int ascent;

			public string sceneName;

			private bool <usedLoadingScreen>5__2;

			private float <timeout>5__3;

			private AsyncOperation <operation>5__4;

			private float <fallbackTimeout>5__5;

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

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

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

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

			private bool MoveNext()
			{
				//IL_003b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0045: Expected O, but got Unknown
				//IL_0172: Unknown result type (might be due to invalid IL or missing references)
				//IL_0177: Unknown result type (might be due to invalid IL or missing references)
				int num = <>1__state;
				SaveManagerPlugin saveManagerPlugin = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					saveManagerPlugin.lastSceneLoadSucceeded = false;
					Ascents.currentAscent = ascent;
					try
					{
						GameHandler.AddStatus<SceneSwitchingStatus>((GameStatus)new SceneSwitchingStatus());
					}
					catch (Exception ex)
					{
						((BaseUnityPlugin)saveManagerPlugin).Logger.LogWarning((object)("Could not set scene switching status: " + ex.Message));
					}
					<usedLoadingScreen>5__2 = false;
					try
					{
						LoadingScreenHandler instance = RetrievableResourceSingleton<LoadingScreenHandler>.Instance;
						if ((Object)(object)instance != (Object)null)
						{
							instance.Load((LoadingScreenType)1, (Action)null, new IEnumerator[1] { instance.LoadSceneProcess(sceneName, true, true, 0.5f) });
							<usedLoadingScreen>5__2 = true;
						}
					}
					catch (Exception ex2)
					{
						((BaseUnityPlugin)saveManagerPlugin).Logger.LogWarning((object)("LoadingScreenHandler load failed, using fallback load: " + ex2.Message));
					}
					if (!<usedLoadingScreen>5__2)
					{
						<operation>5__4 = SceneManager.LoadSceneAsync(sceneName);
						if (<operation>5__4 == null)
						{
							((BaseUnityPlugin)saveManagerPlugin).Logger.LogError((object)("Could not start fallback scene load for '" + sceneName + "'."));
							return false;
						}
						<fallbackTimeout>5__5 = 45f;
						goto IL_0144;
					}
					goto IL_0165;
				case 1:
					<>1__state = -1;
					goto IL_0144;
				case 2:
					{
						<>1__state = -1;
						break;
					}
					IL_0165:
					<timeout>5__3 = 45f;
					break;
					IL_0144:
					if (!<operation>5__4.isDone && <fallbackTimeout>5__5 > 0f)
					{
						<fallbackTimeout>5__5 -= Time.unscaledDeltaTime;
						<>2__current = null;
						<>1__state = 1;
						return true;
					}
					<operation>5__4 = null;
					goto IL_0165;
				}
				if (<timeout>5__3 > 0f)
				{
					Scene activeScene = SceneManager.GetActiveScene();
					bool num2 = string.Equals(((Scene)(ref activeScene)).name, sceneName, StringComparison.OrdinalIgnoreCase);
					bool flag = !<usedLoadingScreen>5__2 || !LoadingScreenHandler.loading;
					if (num2 && flag)
					{
						saveManagerPlugin.lastSceneLoadSucceeded = true;
						return false;
					}
					<timeout>5__3 -= Time.unscaledDeltaTime;
					<>2__current = null;
					<>1__state = 2;
					return true;
				}
				((BaseUnityPlugin)saveManagerPlugin).Logger.LogWarning((object)("Timed out waiting for scene '" + sceneName + "' to finish loading."));
				return false;
			}

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

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

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

			private object <>2__current;

			public SaveEnvelope envelope;

			public SaveManagerPlugin <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f5: Expected O, but got Unknown
				//IL_0082: Unknown result type (might be due to invalid IL or missing references)
				//IL_008c: Expected O, but got Unknown
				int num = <>1__state;
				SaveManagerPlugin saveManagerPlugin = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if (envelope == null)
					{
						return false;
					}
					saveManagerPlugin.RestoreCampfires(envelope.campfires);
					saveManagerPlugin.RestoreContainerStates(envelope.containerStates, envelope.luggageStates);
					saveManagerPlugin.RestoreWorldObjects(envelope.worldObjects, envelope.formatVersion);
					<>2__current = (object)new WaitForSeconds(0.2f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					saveManagerPlugin.RestoreCampfires(envelope.campfires);
					saveManagerPlugin.RestoreContainerStates(envelope.containerStates, envelope.luggageStates);
					saveManagerPlugin.RestoreWorldObjects(envelope.worldObjects, envelope.formatVersion);
					<>2__current = (object)new WaitForSeconds(1.1f);
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					saveManagerPlugin.RestoreContainerStates(envelope.containerStates, envelope.luggageStates);
					saveManagerPlugin.RestoreWorldObjects(envelope.worldObjects, envelope.formatVersion);
					saveManagerPlugin.RestoreGroundItems(envelope.groundItems);
					saveManagerPlugin.RestoreWorldObjects(envelope.worldObjects, envelope.formatVersion);
					return false;
				}
			}

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

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

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

			private object <>2__current;

			public float timeoutSeconds;

			public List<PlayerSnapshot> players;

			private float <timeout>5__2;

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

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

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

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

			private bool MoveNext()
			{
				//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b3: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<timeout>5__2 = Mathf.Max(1f, timeoutSeconds);
					break;
				case 1:
					<>1__state = -1;
					break;
				}
				if (<timeout>5__2 > 0f)
				{
					Player[] array = Object.FindObjectsByType<Player>((FindObjectsSortMode)0);
					if (array.Length != 0)
					{
						int num = 0;
						for (int i = 0; i < players.Count; i++)
						{
							if (array.Any(new <>c__DisplayClass188_0
							{
								snapshot = players[i]
							}.<WaitForPlayersRoutine>b__0))
							{
								num++;
							}
						}
						if (num > 0)
						{
							return false;
						}
					}
					<timeout>5__2 -= Time.deltaTime;
					<>2__current = (object)new WaitForSeconds(0.1f);
					<>1__state = 1;
					return true;
				}
				return false;
			}

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

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

		public const string PluginGuid = "com.lucasandersen.peakallyouneedsavemanager";

		public const string PluginName = "The All You Need Save Manager";

		public const string PluginVersion = "1.0.0";

		private const string SaveFilePattern = "*.json";

		private const int UiWindowId = 129193;

		private const string PauseMenuButtonObjectName = "PeakSaveManagerButton";

		private const float PendingSeedLifetimeSeconds = 90f;

		private static readonly MethodInfo RecalculateLookDirectionsMethod = AccessTools.Method(typeof(Character), "RecalculateLookDirections", (Type[])null, (Type[])null);

		private static readonly MethodInfo CampfireUpdateLitMethod = AccessTools.Method(typeof(Campfire), "UpdateLit", (Type[])null, (Type[])null);

		private static readonly MethodInfo CampfireHideLogsMethod = AccessTools.Method(typeof(Campfire), "HideLogs", (Type[])null, (Type[])null);

		private static readonly FieldInfo LuggageStateField = AccessTools.Field(typeof(Luggage), "state");

		private static readonly MethodInfo LuggageOpenRpcMethod = AccessTools.Method(typeof(Luggage), "OpenLuggageRPC", (Type[])null, (Type[])null);

		private static readonly MethodInfo MenuWindowOpenMethod = AccessTools.Method(typeof(MenuWindow), "Open", (Type[])null, (Type[])null);

		private static readonly MethodInfo MenuWindowCloseMethod = AccessTools.Method(typeof(MenuWindow), "Close", (Type[])null, (Type[])null);

		private static readonly MethodInfo RespawnChestSetSpentMethod = AccessTools.PropertySetter(typeof(RespawnChest), "IsSpent");

		private static readonly MethodInfo RespawnChestSetRevivedPlayersMethod = AccessTools.PropertySetter(typeof(RespawnChest), "HasRevivedPlayers");

		private static readonly MethodInfo RespawnChestGetRevivedPlayersMethod = AccessTools.PropertyGetter(typeof(RespawnChest), "HasRevivedPlayers");

		private static readonly FieldInfo RespawnChestRevivedPlayersField = AccessTools.Field(typeof(RespawnChest), "hasRevivedPlayers");

		private static readonly MethodInfo RunManagerRpcSyncTimeMethod = AccessTools.Method(typeof(RunManager), "RPC_SyncTime", new Type[2]
		{
			typeof(float),
			typeof(bool)
		}, (Type[])null);

		private static readonly FieldInfo RunManagerTimerActiveField = AccessTools.Field(typeof(RunManager), "timerActive");

		private static readonly PropertyInfo RopeShooterAmmoProperty = AccessTools.Property(typeof(RopeShooter), "Ammo");

		private static readonly MethodInfo RopeShooterSyncRpcMethod = AccessTools.Method(typeof(RopeShooter), "Sync_Rpc", new Type[1] { typeof(bool) }, (Type[])null);

		private static readonly FieldInfo ItemTotalUsesField = AccessTools.Field(typeof(Item), "totalUses");

		private static readonly FieldInfo ItemDataField = AccessTools.Field(typeof(Item), "data");

		private static readonly FieldInfo MagicBeanVineCurrentLengthField = AccessTools.Field(typeof(MagicBeanVine), "currentLength");

		private static readonly FieldInfo MagicBeanVineInitialLengthField = AccessTools.Field(typeof(MagicBeanVine), "initialLength");

		private static readonly FieldInfo MagicBeanVineMaxLengthField = AccessTools.Field(typeof(MagicBeanVine), "maxLength");

		private static readonly FieldInfo CloudFungusAlreadyBrokeField = AccessTools.Field(typeof(CloudFungus), "alreadyBroke");

		private static readonly FieldInfo CloudFungusTimeAliveField = AccessTools.Field(typeof(CloudFungus), "timeAlive");

		private static readonly FieldInfo OptionableIntHasDataField = AccessTools.Field(typeof(OptionableIntItemData), "HasData");

		private static readonly FieldInfo OptionableIntValueField = AccessTools.Field(typeof(OptionableIntItemData), "Value");

		private static readonly FieldInfo OptionableBoolHasDataField = AccessTools.Field(typeof(OptionableBoolItemData), "HasData");

		private static readonly FieldInfo OptionableBoolValueField = AccessTools.Field(typeof(OptionableBoolItemData), "Value");

		private static readonly FieldInfo CharacterDataCheckpointFlagsField = AccessTools.Field(typeof(CharacterData), "checkpointFlags");

		private static readonly FieldInfo CheckpointFlagStatusesField = AccessTools.Field(typeof(CheckpointFlag), "currentStatuses");

		private static readonly FieldInfo CheckpointFlagPlanterField = AccessTools.Field(typeof(CheckpointFlag), "planterCharacter");

		private static readonly FieldInfo CharacterItemsCurrentSelectedSlotField = AccessTools.Field(typeof(CharacterItems), "currentSelectedSlot");

		private static readonly MethodInfo CharacterItemsEquipSlotMethod = AccessTools.Method(typeof(CharacterItems), "EquipSlot", new Type[1] { typeof(Optionable<byte>) }, (Type[])null);

		private static readonly ConstructorInfo OptionableByteConstructor = AccessTools.Constructor(typeof(Optionable<byte>), new Type[2]
		{
			typeof(byte),
			typeof(byte)
		}, false);

		private static readonly FieldInfo OptionableByteHasValueField = AccessTools.Field(typeof(Optionable<byte>), "hasValue");

		private static readonly FieldInfo OptionableByteValueField = AccessTools.Field(typeof(Optionable<byte>), "value");

		private static readonly MethodInfo MirageLuggageSetStateMethod = AccessTools.Method(typeof(MirageLuggage), "setMirageState", new Type[1] { typeof(float) }, (Type[])null);

		private static readonly FieldInfo MirageLuggageRenderersField = AccessTools.Field(typeof(MirageLuggage), "renderers");

		private static readonly MethodInfo DayNightTimeStringGetterMethod = AccessTools.PropertyGetter(typeof(DayNightManager), "timeString");

		private static readonly MethodInfo DayNightTimeStringSetterMethod = AccessTools.PropertySetter(typeof(DayNightManager), "timeString");

		private static readonly FieldInfo DayNightTimeStringField = AccessTools.Field(typeof(DayNightManager), "timeString");

		private static readonly HashSet<STATUSTYPE> SkippedSavedStatuses = new HashSet<STATUSTYPE> { (STATUSTYPE)7 };

		private static SaveManagerPlugin Instance;

		private static int? PendingSeedForLoad;

		private static float PendingSeedSetRealtime;

		private Harmony harmony;

		private ConfigEntry<bool> autoSaveEnabled;

		private ConfigEntry<float> autoSaveIntervalSeconds;

		private string saveDirectory;

		private string preferredSaveDirectory;

		private string fallbackSaveDirectory;

		private bool showUi;

		private bool isLoading;

		private float lastAutoSaveTime;

		private bool lastSceneLoadSucceeded = true;

		private Rect windowRect = new Rect(34f, 34f, 820f, 620f);

		private Vector2 fileScroll = Vector2.zero;

		private string newSaveName = "";

		private readonly List<SaveListEntry> saveEntries = new List<SaveListEntry>();

		private string statusMessage = "";

		private Color statusColor = Color.white;

		private float statusMessageUntil;

		private bool hasConfirmationPending;

		private string confirmationTitle = "";

		private string confirmationMessage = "";

		private Action confirmationAction;

		private bool stylesBuilt;

		private GUIStyle windowStyle;

		private GUIStyle sectionStyle;

		private GUIStyle titleStyle;

		private GUIStyle subtitleStyle;

		private GUIStyle normalLabelStyle;

		private GUIStyle errorLabelStyle;

		private GUIStyle softButtonStyle;

		private GUIStyle dangerButtonStyle;

		private GUIStyle textFieldStyle;

		private GUIStyle cardStyle;

		private GUIStyle cardWarningStyle;

		private Texture2D overlayTexture;

		private Texture2D windowTexture;

		private Texture2D sectionTexture;

		private Texture2D cardTexture;

		private Texture2D warningCardTexture;

		private Texture2D buttonTexture;

		private Texture2D buttonHoverTexture;

		private Texture2D dangerButtonTexture;

		private Texture2D textFieldTexture;

		private SaveManagerPausePage pauseMenuPage;

		private UIPageHandler pauseMenuPageHandler;

		private UIPage pauseMenuMainPage;

		private Button pauseMenuButtonTemplate;

		private bool quitPendingSaveDecision;

		private PauseMenuMainPage quitPendingPage;

		private bool allowVanillaQuitClick;

		private void Awake()
		{
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Expected O, but got Unknown
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			Instance = this;
			autoSaveEnabled = ((BaseUnityPlugin)this).Config.Bind<bool>("AutoSave", "Enable AutoSave", true, "Automatically create rolling autosaves");
			autoSaveIntervalSeconds = ((BaseUnityPlugin)this).Config.Bind<float>("AutoSave", "Interval Seconds", 300f, "Seconds between autosaves");
			preferredSaveDirectory = Path.Combine(Paths.GameRootPath, "PeakSaves");
			fallbackSaveDirectory = Path.Combine(Application.persistentDataPath, "PeakSaves");
			saveDirectory = preferredSaveDirectory;
			EnsureSaveDirectoryReady(showStatus: false);
			harmony = new Harmony("com.lucasandersen.peakallyouneedsavemanager");
			harmony.PatchAll();
			RefreshSaveFileList();
			SetStatus("Save manager ready.", Color.cyan, 2f);
			((BaseUnityPlugin)this).Logger.LogInfo((object)"Loaded The All You Need Save Manager 1.0.0 by Lucas Andersen");
		}

		private void OnDestroy()
		{
			try
			{
				Harmony obj = harmony;
				if (obj != null)
				{
					obj.UnpatchSelf();
				}
			}
			catch (Exception arg)
			{
				((BaseUnityPlugin)this).Logger.LogWarning((object)$"Failed to unpatch Harmony cleanly: {arg}");
			}
			DestroyUiResources();
		}

		private void Update()
		{
			if (showUi)
			{
				Cursor.visible = true;
				Cursor.lockState = (CursorLockMode)0;
			}
			if (!showUi && !isLoading && autoSaveEnabled.Value && Time.time - lastAutoSaveTime > Mathf.Max(15f, autoSaveIntervalSeconds.Value))
			{
				if (CanAutoSaveNow())
				{
					TrySaveGame("Autosave");
				}
				lastAutoSaveTime = Time.time;
			}
		}

		private bool CanAutoSaveNow()
		{
			//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)
			if (!CanSaveNow(showReason: false))
			{
				return false;
			}
			Scene activeScene = SceneManager.GetActiveScene();
			string name = ((Scene)(ref activeScene)).name;
			if (string.IsNullOrWhiteSpace(name) || !name.StartsWith("Level_", StringComparison.OrdinalIgnoreCase))
			{
				return false;
			}
			if (LoadingScreenHandler.loading)
			{
				return false;
			}
			return true;
		}

		private void OnGUI()
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Expected O, but got Unknown
			//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)
			if (showUi)
			{
				EnsureStyles();
				DrawOverlay();
				GUI.depth = -1000;
				windowRect = GUI.Window(129193, windowRect, new WindowFunction(DrawMainWindow), "PEAK ALL YOU NEED SAVE MANAGER", windowStyle);
			}
		}

		private void DrawMainWindow(int _)
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0314: Unknown result type (might be due to invalid IL or missing references)
			//IL_0319: Unknown result type (might be due to invalid IL or missing references)
			//IL_0405: Unknown result type (might be due to invalid IL or missing references)
			float num = statusMessageUntil - Time.unscaledTime;
			bool flag = IsInAirportScene();
			GUILayout.BeginVertical(Array.Empty<GUILayoutOption>());
			if (!string.IsNullOrEmpty(statusMessage) && num > 0f)
			{
				Color color = GUI.color;
				GUI.color = statusColor;
				GUILayout.Label(statusMessage, sectionStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(30f) });
				GUI.color = color;
			}
			if (isLoading)
			{
				GUILayout.Label("Loading save and synchronizing players...", sectionStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(28f) });
			}
			if (hasConfirmationPending)
			{
				DrawConfirmationPrompt();
				GUILayout.EndVertical();
				GUI.DragWindow(new Rect(0f, 0f, ((Rect)(ref windowRect)).width, 24f));
				return;
			}
			GUILayout.BeginVertical(sectionStyle, Array.Empty<GUILayoutOption>());
			GUILayout.Label("Create Save", subtitleStyle, Array.Empty<GUILayoutOption>());
			GUILayout.Space(4f);
			if (flag)
			{
				GUILayout.Label("You cannot save in the Airport.", errorLabelStyle, Array.Empty<GUILayoutOption>());
				GUILayout.Space(4f);
			}
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			GUILayout.Label("Name", normalLabelStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(55f) });
			newSaveName = GUILayout.TextField(newSaveName, textFieldStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandWidth(true) });
			GUILayout.EndHorizontal();
			GUILayout.Space(6f);
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			GUI.enabled = !isLoading && !flag;
			if (GUILayout.Button("Quick Save", softButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Height(28f),
				GUILayout.Width(120f)
			}))
			{
				TrySaveGame("Quick Save");
			}
			GUI.enabled = !isLoading && !flag && !string.IsNullOrWhiteSpace(newSaveName);
			if (GUILayout.Button("Save", softButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Height(28f),
				GUILayout.Width(80f)
			}))
			{
				string saveName = newSaveName.Trim();
				newSaveName = string.Empty;
				TrySaveGame(saveName);
			}
			GUI.enabled = true;
			GUILayout.EndHorizontal();
			GUILayout.EndVertical();
			GUILayout.Space(8f);
			GUILayout.BeginVertical(sectionStyle, Array.Empty<GUILayoutOption>());
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			GUILayout.Label("Saved Runs", subtitleStyle, Array.Empty<GUILayoutOption>());
			GUILayout.FlexibleSpace();
			GUI.enabled = !isLoading;
			if (GUILayout.Button("Refresh", softButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Width(90f),
				GUILayout.Height(24f)
			}))
			{
				RefreshSaveFileList();
			}
			GUI.enabled = true;
			GUILayout.EndHorizontal();
			GUILayout.Space(6f);
			fileScroll = GUILayout.BeginScrollView(fileScroll, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(390f) });
			if (saveEntries.Count == 0)
			{
				GUILayout.Label("No save files found.", normalLabelStyle, Array.Empty<GUILayoutOption>());
			}
			else
			{
				foreach (SaveListEntry saveEntry in saveEntries)
				{
					DrawSaveCard(saveEntry);
					GUILayout.Space(5f);
				}
			}
			GUILayout.EndScrollView();
			GUILayout.EndVertical();
			GUILayout.Space(8f);
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			GUILayout.FlexibleSpace();
			if (GUILayout.Button("Close", softButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Width(120f),
				GUILayout.Height(30f)
			}))
			{
				showUi = false;
			}
			GUILayout.EndHorizontal();
			GUILayout.EndVertical();
			GUI.DragWindow(new Rect(0f, 0f, ((Rect)(ref windowRect)).width, 24f));
		}

		private void DrawSaveCard(SaveListEntry entry)
		{
			GUIStyle obj = (entry.isCompatible ? cardStyle : cardWarningStyle);
			bool flag = CanSaveNow(showReason: false);
			GUILayout.BeginVertical(obj, Array.Empty<GUILayoutOption>());
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			GUILayout.Label(entry.fileName, titleStyle, Array.Empty<GUILayoutOption>());
			GUILayout.FlexibleSpace();
			GUILayout.Label(FormatBytes(entry.fileSize), normalLabelStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(78f) });
			GUILayout.EndHorizontal();
			if (entry.metadata != null)
			{
				string text = ((entry.metadata.savedAtUtc == default(DateTime)) ? entry.fileTime.ToString("yyyy-MM-dd HH:mm:ss", CultureInfo.InvariantCulture) : entry.metadata.savedAtUtc.ToLocalTime().ToString("yyyy-MM-dd HH:mm:ss", CultureInfo.InvariantCulture));
				int num = entry.metadata.playerCount;
				if (num <= 0)
				{
					num = 0;
				}
				string text2 = Safe(entry.metadata.levelName);
				if (entry.metadata.levelNumber.HasValue)
				{
					text2 += $" (#{entry.metadata.levelNumber.Value})";
				}
				GUILayout.Label("Saved: " + text, normalLabelStyle, Array.Empty<GUILayoutOption>());
				GUILayout.Label("Level: " + text2 + "   Segment: " + Safe(ToDisplaySegmentName(entry.metadata.currentSegmentName, entry.metadata.biomeId)), normalLabelStyle, Array.Empty<GUILayoutOption>());
				GUILayout.Label($"Seed: {entry.metadata.levelSeed}   Ascent: {entry.metadata.ascent}   Players: {num}", normalLabelStyle, Array.Empty<GUILayoutOption>());
				GUILayout.Label(FormatRunSummary(entry.metadata), normalLabelStyle, Array.Empty<GUILayoutOption>());
			}
			else
			{
				GUILayout.Label($"File Time: {entry.fileTime:yyyy-MM-dd HH:mm:ss}", normalLabelStyle, Array.Empty<GUILayoutOption>());
			}
			if (!entry.isCompatible)
			{
				GUILayout.Label("Incompatible: " + entry.incompatibilityReason, errorLabelStyle, Array.Empty<GUILayoutOption>());
			}
			GUILayout.Space(4f);
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			GUI.enabled = !isLoading && entry.isCompatible;
			if (GUILayout.Button("Load", softButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Height(24f),
				GUILayout.Width(90f)
			}))
			{
				StartLoadFromUi(entry.fullPath);
			}
			GUI.enabled = !isLoading && flag;
			if (GUILayout.Button("Overwrite", softButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Height(24f),
				GUILayout.Width(100f)
			}))
			{
				string saveNameHint = ((entry.metadata != null && !string.IsNullOrWhiteSpace(entry.metadata.saveName)) ? entry.metadata.saveName : Path.GetFileNameWithoutExtension(entry.fileName));
				string targetPath2 = entry.fullPath;
				string fileName = entry.fileName;
				RequestConfirmation("Overwrite Save?", "Overwrite '" + fileName + "' with your current run state?", delegate
				{
					TryOverwriteSave(targetPath2, saveNameHint);
				});
			}
			GUI.enabled = !isLoading;
			if (GUILayout.Button("Delete", dangerButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Height(24f),
				GUILayout.Width(90f)
			}))
			{
				string targetPath = entry.fullPath;
				string fileName2 = entry.fileName;
				RequestConfirmation("Delete Save?", "Delete '" + fileName2 + "' permanently? This cannot be undone.", delegate
				{
					TryDeleteSave(targetPath);
				});
			}
			GUI.enabled = true;
			GUILayout.EndHorizontal();
			GUILayout.EndVertical();
		}

		private void StartLoadFromUi(string fullPath)
		{
			if (!string.IsNullOrWhiteSpace(fullPath))
			{
				showUi = false;
				ClearPendingConfirmation();
				pauseMenuPage?.PrepareForLoad();
				ClosePauseMenuForLoad();
				((MonoBehaviour)this).StartCoroutine(LoadSaveRoutine(fullPath));
			}
		}

		private void ClosePauseMenuForLoad()
		{
			try
			{
				if ((Object)(object)EventSystem.current != (Object)null)
				{
					EventSystem.current.SetSelectedGameObject((GameObject)null);
				}
				PauseMainMenu val = Object.FindFirstObjectByType<PauseMainMenu>();
				if ((Object)(object)val != (Object)null)
				{
					CloseMenuWindow((MenuWindow)(object)val);
					((Component)val).gameObject.SetActive(false);
				}
				if ((Object)(object)pauseMenuPage != (Object)null)
				{
					((Component)pauseMenuPage).gameObject.SetActive(false);
				}
				if ((Object)(object)pauseMenuPageHandler != (Object)null)
				{
					((Component)pauseMenuPageHandler).gameObject.SetActive(false);
				}
				Cursor.visible = false;
				Cursor.lockState = (CursorLockMode)1;
			}
			catch (Exception ex)
			{
				((BaseUnityPlugin)this).Logger.LogWarning((object)("Failed to close pause menu before load: " + ex.Message));
			}
		}

		private void ToggleUi()
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			if (PhotonNetwork.InRoom && !PhotonNetwork.IsMasterClient)
			{
				SetStatus("Only the host can open Save Manager.", Color.yellow, 2.5f);
				return;
			}
			showUi = !showUi;
			if (showUi)
			{
				RefreshSaveFileList();
				Cursor.visible = true;
				Cursor.lockState = (CursorLockMode)0;
			}
			else
			{
				ClearPendingConfirmation();
			}
		}

		private void RequestConfirmation(string title, string message, Action confirmedAction)
		{
			if (confirmedAction != null)
			{
				hasConfirmationPending = true;
				confirmationTitle = (string.IsNullOrWhiteSpace(title) ? "Are you sure?" : title);
				confirmationMessage = (string.IsNullOrWhiteSpace(message) ? "Please confirm this action." : message);
				confirmationAction = confirmedAction;
			}
		}

		private void ClearPendingConfirmation()
		{
			hasConfirmationPending = false;
			confirmationTitle = string.Empty;
			confirmationMessage = string.Empty;
			confirmationAction = null;
		}

		private void ExecutePendingConfirmation()
		{
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			Action action = confirmationAction;
			ClearPendingConfirmation();
			if (action == null)
			{
				return;
			}
			try
			{
				action();
			}
			catch (Exception arg)
			{
				((BaseUnityPlugin)this).Logger.LogError((object)$"Confirmation action failed: {arg}");
				SetStatus("Action failed. Check BepInEx log.", Color.red, 4f);
			}
		}

		private void DrawConfirmationPrompt()
		{
			GUILayout.Space(8f);
			GUILayout.BeginVertical(sectionStyle, Array.Empty<GUILayoutOption>());
			GUILayout.Label(confirmationTitle, subtitleStyle, Array.Empty<GUILayoutOption>());
			GUILayout.Space(4f);
			GUILayout.Label(confirmationMessage, normalLabelStyle, Array.Empty<GUILayoutOption>());
			GUILayout.Space(10f);
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			GUILayout.FlexibleSpace();
			GUI.enabled = !isLoading;
			if (GUILayout.Button("Cancel", softButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Height(30f),
				GUILayout.Width(120f)
			}))
			{
				ClearPendingConfirmation();
			}
			GUI.enabled = !isLoading;
			if (GUILayout.Button("Confirm", dangerButtonStyle, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Height(30f),
				GUILayout.Width(120f)
			}))
			{
				ExecutePendingConfirmation();
			}
			GUI.enabled = true;
			GUILayout.EndHorizontal();
			GUILayout.EndVertical();
		}

		internal static void TryAttachPauseMenuButton(PauseMenuMainPage pauseMenuPage)
		{
			Instance?.AttachPauseMenuButton(pauseMenuPage);
		}

		private void AttachPauseMenuButton(PauseMenuMainPage pauseMenuPage)
		{
			//IL_0222: Unknown result type (might be due to invalid IL or missing references)
			//IL_022c: Expected O, but got Unknown
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_012f: 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_014e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0153: Unknown result type (might be due to invalid IL or missing references)
			//IL_0168: 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)
			if ((Object)(object)pauseMenuPage == (Object)null)
			{
				return;
			}
			try
			{
				object? obj = AccessTools.Field(typeof(PauseMenuMainPage), "m_settingsButton")?.GetValue(pauseMenuPage);
				Button val = (Button)((obj is Button) ? obj : null);
				if ((Object)(object)val == (Object)null || (Object)(object)((Component)val).transform == (Object)null || (Object)(object)((Component)val).transform.parent == (Object)null)
				{
					return;
				}
				Transform parent = ((Component)val).transform.parent;
				Transform val2 = parent.Find("PeakSaveManagerButton");
				Button component;
				if ((Object)(object)val2 == (Object)null)
				{
					GameObject val3 = Object.Instantiate<GameObject>(((Component)val).gameObject, parent, false);
					((Object)val3).name = "PeakSaveManagerButton";
					Transform transform = ((Component)val).transform;
					RectTransform val4 = (RectTransform)(object)((transform is RectTransform) ? transform : null);
					Transform transform2 = val3.transform;
					RectTransform val5 = (RectTransform)(object)((transform2 is RectTransform) ? transform2 : null);
					if ((Object)(object)val4 != (Object)null && (Object)(object)val5 != (Object)null)
					{
						val5.anchorMin = val4.anchorMin;
						val5.anchorMax = val4.anchorMax;
						val5.pivot = val4.pivot;
						val5.sizeDelta = val4.sizeDelta;
						((Transform)val5).localScale = ((Transform)val4).localScale;
						Vector2 anchoredPosition = val4.anchoredPosition;
						Rect rect = val4.rect;
						val5.anchoredPosition = anchoredPosition + new Vector2(0f, 0f - Mathf.Max(50f, ((Rect)(ref rect)).height + 8f));
					}
					val3.transform.SetSiblingIndex(((Component)val).transform.GetSiblingIndex() + 1);
					MonoBehaviour[] componentsInChildren = val3.GetComponentsInChildren<MonoBehaviour>(true);
					foreach (MonoBehaviour val6 in componentsInChildren)
					{
						if ((Object)(object)val6 != (Object)null && ((object)val6).GetType().Name == "LocalizedText")
						{
							Object.Destroy((Object)(object)val6);
						}
					}
					SetPauseMenuButtonText(val3, "SAVE MANAGER");
					component = val3.GetComponent<Button>();
				}
				else
				{
					component = ((Component)val2).GetComponent<Button>();
				}
				if (!((Object)(object)component == (Object)null))
				{
					((UnityEventBase)component.onClick).RemoveAllListeners();
					((UnityEvent)component.onClick).AddListener((UnityAction)delegate
					{
						OpenPauseMenuSavePage(pauseMenuPage);
					});
					((Selectable)component).interactable = !PhotonNetwork.InRoom || PhotonNetwork.IsMasterClient;
				}
			}
			catch (Exception ex)
			{
				((BaseUnityPlugin)this).Logger.LogWarning((object)("Failed to attach pause menu save button: " + ex.Message));
			}
		}

		private void OpenPauseMenuSavePage(PauseMenuMainPage pauseMainPage)
		{
			//IL_001e: 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_00ac: Expected O, but got Unknown
			if ((Object)(object)pauseMainPage == (Object)null)
			{
				return;
			}
			if (PhotonNetwork.InRoom && !PhotonNetwork.IsMasterClient)
			{
				SetStatus("Only the host can open Save Manager.", Color.yellow, 2.5f);
				return;
			}
			UIPageHandler pageHandler = ((UIPage)pauseMainPage).GetPageHandler<UIPageHandler>();
			if ((Object)(object)pageHandler == (Object)null)
			{
				((BaseUnityPlugin)this).Logger.LogWarning((object)"Pause menu page handler not found.");
				return;
			}
			object? obj = AccessTools.Field(typeof(PauseMenuMainPage), "m_settingsButton")?.GetValue(pauseMainPage);
			Button settingsButtonTemplate = (Button)((obj is Button) ? obj : null);
			SaveManagerPausePage saveManagerPausePage = EnsurePauseMenuSavePage(pageHandler, (UIPage)(object)pauseMainPage, settingsButtonTemplate);
			if ((Object)(object)saveManagerPausePage == (Object)null)
			{
				((BaseUnityPlugin)this).Logger.LogWarning((object)"Save manager pause page could not be created.");
				return;
			}
			saveManagerPausePage.RefreshFromSource();
			pageHandler.TransistionToPage((UIPage)(object)saveManagerPausePage, (PageTransistion)new SetActivePageTransistion());
			Cursor.visible = true;
			Cursor.lockState = (CursorLockMode)0;
		}

		private SaveManagerPausePage EnsurePauseMenuSavePage(UIPageHandler pageHandler, UIPage mainPage, Button settingsButtonTemplate)
		{
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: 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)
			//IL_0126: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)pageHandler == (Object)null || (Object)(object)mainPage == (Object)null)
			{
				return null;
			}
			if ((Object)(object)pauseMenuPage != (Object)null && (Object)(object)pauseMenuPageHandler == (Object)(object)pageHandler)
			{
				pauseMenuPage.Initialize(this, pageHandler, mainPage, settingsButtonTemplate);
				return pauseMenuPage;
			}
			SaveManagerPausePage saveManagerPausePage = pageHandler.GetPage<SaveManagerPausePage>() as SaveManagerPausePage;
			if ((Object)(object)saveManagerPausePage != (Object)null)
			{
				pauseMenuPage = saveManagerPausePage;
				pauseMenuPageHandler = pageHandler;
				pauseMenuMainPage = mainPage;
				pauseMenuButtonTemplate = settingsButtonTemplate;
				pauseMenuPage.Initialize(this, pageHandler, mainPage, settingsButtonTemplate);
				return pauseMenuPage;
			}
			GameObject val = new GameObject("PauseMenuSaveManagerPage", new Type[3]
			{
				typeof(RectTransform),
				typeof(Image),
				typeof(SaveManagerPausePage)
			});
			RectTransform component = val.GetComponent<RectTransform>();
			((Transform)component).SetParent(((Component)pageHandler).transform, false);
			component.anchorMin = Vector2.zero;
			component.anchorMax = Vector2.one;
			component.offsetMin = Vector2.zero;
			component.offsetMax = Vector2.zero;
			((Graphic)val.GetComponent<Image>()).color = new Color(0.02f, 0.05f, 0.1f, 0.75f);
			SaveManagerPausePage component2 = val.GetComponent<SaveManagerPausePage>();
			AccessTools.Field(typeof(UIPage), "pageHandler")?.SetValue(component2, pageHandler);
			component2.Initialize(this, pageHandler, mainPage, settingsButtonTemplate);
			val.SetActive(false);
			object obj = AccessTools.Field(typeof(UIPageHandler), "_pages")?.GetValue(pageHandler);
			if (obj != null)
			{
				obj.GetType().GetMethod("Remove", new Type[1] { typeof(Type) })?.Invoke(obj, new object[1] { typeof(SaveManagerPausePage) });
				MethodInfo method = obj.GetType().GetMethod("Add", new Type[2]
				{
					typeof(Type),
					typeof(UIPage)
				});
				if (method != null)
				{
					method.Invoke(obj, new object[2]
					{
						typeof(SaveManagerPausePage),
						component2
					});
				}
				else
				{
					obj.GetType().GetMethod("Add")?.Invoke(obj, new object[2]
					{
						typeof(SaveManagerPausePage),
						component2
					});
				}
			}
			pauseMenuPage = component2;
			pauseMenuPageHandler = pageHandler;
			pauseMenuMainPage = mainPage;
			pauseMenuButtonTemplate = settingsButtonTemplate;
			return component2;
		}

		internal static bool TryInterceptPauseQuit(PauseMenuMainPage page)
		{
			if ((Object)(object)Instance != (Object)null)
			{
				return Instance.InterceptPauseQuit(page);
			}
			return false;
		}

		private bool InterceptPauseQuit(PauseMenuMainPage page)
		{
			//IL_0180: Unknown result type (might be due to invalid IL or missing references)
			//IL_018a: Expected O, but got Unknown
			//IL_01a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ae: Expected O, but got Unknown
			if (allowVanillaQuitClick || (Object)(object)page == (Object)null)
			{
				return false;
			}
			if (!CanSaveNow(showReason: false))
			{
				return false;
			}
			FieldInfo fieldInfo = AccessTools.Field(typeof(PauseMenuMainPage), "confirmWindow");
			FieldInfo fieldInfo2 = AccessTools.Field(typeof(PauseMenuMainPage), "m_confirmOkButton");
			FieldInfo fieldInfo3 = AccessTools.Field(typeof(PauseMenuMainPage), "m_confirmCancelButton");
			FieldInfo fieldInfo4 = AccessTools.Field(typeof(PauseMenuMainPage), "confirmText");
			MenuWindow confirmWindow = default(MenuWindow);
			ref MenuWindow reference = ref confirmWindow;
			object? obj = fieldInfo?.GetValue(page);
			reference = (MenuWindow)((obj is MenuWindow) ? obj : null);
			object? obj2 = fieldInfo2?.GetValue(page);
			Button val = (Button)((obj2 is Button) ? obj2 : null);
			object? obj3 = fieldInfo3?.GetValue(page);
			Button val2 = (Button)((obj3 is Button) ? obj3 : null);
			object? obj4 = fieldInfo4?.GetValue(page);
			LocalizedText val3 = (LocalizedText)((obj4 is LocalizedText) ? obj4 : null);
			if ((Object)(object)confirmWindow == (Object)null || (Object)(object)val == (Object)null || (Object)(object)val2 == (Object)null)
			{
				return false;
			}
			quitPendingSaveDecision = true;
			quitPendingPage = page;
			OpenMenuWindow(confirmWindow);
			if (val3 != null)
			{
				val3.SetText("Would you like to save your game before quitting?");
			}
			SetPauseMenuButtonText(((Component)val).gameObject, "YES");
			SetPauseMenuButtonText(((Component)val2).gameObject, "NO");
			((UnityEventBase)val.onClick).RemoveAllListeners();
			((UnityEvent)val.onClick).AddListener((UnityAction)delegate
			{
				CloseMenuWindow(confirmWindow);
				OpenPauseMenuSavePage(page);
			});
			((UnityEventBase)val2.onClick).RemoveAllListeners();
			((UnityEvent)val2.onClick).AddListener((UnityAction)delegate
			{
				CloseMenuWindow(confirmWindow);
				quitPendingSaveDecision = false;
				quitPendingPage = null;
				ContinueWithVanillaQuit(page);
			});
			return true;
		}

		private void ContinueWithVanillaQuit(PauseMenuMainPage page)
		{
			if ((Object)(object)page == (Object)null)
			{
				return;
			}
			try
			{
				allowVanillaQuitClick = true;
				MethodInfo methodInfo = AccessTools.Method(typeof(PauseMenuMainPage), "Quit", (Type[])null, (Type[])null);
				if (methodInfo != null)
				{
					methodInfo.Invoke(page, null);
				}
				else
				{
					AccessTools.Method(typeof(PauseMenuMainPage), "OnQuitClicked", (Type[])null, (Type[])null)?.Invoke(page, null);
				}
			}
			finally
			{
				allowVanillaQuitClick = false;
			}
		}

		private static void SetPauseMenuButtonText(GameObject buttonObject, string text)
		{
			if ((Object)(object)buttonObject == (Object)null)
			{
				return;
			}
			TMP_Text componentInChildren = buttonObject.GetComponentInChildren<TMP_Text>(true);
			if ((Object)(object)componentInChildren != (Object)null)
			{
				componentInChildren.text = text;
				componentInChildren.enableAutoSizing = true;
				componentInChildren.fontSizeMin = 13f;
				componentInChildren.fontSizeMax = 21f;
				componentInChildren.fontStyle = (FontStyles)16;
				componentInChildren.overflowMode = (TextOverflowModes)1;
				return;
			}
			Text componentInChildren2 = buttonObject.GetComponentInChildren<Text>(true);
			if ((Object)(object)componentInChildren2 != (Object)null)
			{
				componentInChildren2.text = text;
				componentInChildren2.fontStyle = (FontStyle)0;
				componentInChildren2.resizeTextForBestFit = true;
				componentInChildren2.resizeTextMinSize = 13;
				componentInChildren2.resizeTextMaxSize = 21;
			}
		}

		private static void OpenMenuWindow(MenuWindow window)
		{
			if ((Object)(object)window == (Object)null)
			{
				return;
			}
			try
			{
				MenuWindowOpenMethod?.Invoke(window, null);
			}
			catch
			{
				((Component)window).gameObject.SetActive(true);
			}
		}

		private static void CloseMenuWindow(MenuWindow window)
		{
			if ((Object)(object)window == (Object)null)
			{
				return;
			}
			try
			{
				MenuWindowCloseMethod?.Invoke(window, null);
			}
			catch
			{
				((Component)window).gameObject.SetActive(false);
			}
		}

		private static int GetLuggageState(Luggage luggage)
		{
			if ((Object)(object)luggage == (Object)null || LuggageStateField == null)
			{
				return 0;
			}
			try
			{
				object value = LuggageStateField.GetValue(luggage);
				return (value != null) ? Convert.ToInt32(value, CultureInfo.InvariantCulture) : 0;
			}
			catch
			{
				return 0;
			}
		}

		private static void SetLuggageStateRaw(Luggage luggage, int rawState)
		{
			if ((Object)(object)luggage == (Object)null || LuggageStateField == null)
			{
				return;
			}
			int num = Mathf.Max(0, rawState);
			try
			{
				Type fieldType = LuggageStateField.FieldType;
				if (fieldType != null && fieldType.IsEnum)
				{
					Array values = Enum.GetValues(fieldType);
					if (values != null && values.Length > 0)
					{
						int num2 = (from object value in values
							select Convert.ToInt32(value, CultureInfo.InvariantCulture)).DefaultIfEmpty(0).Max();
						num = Mathf.Clamp(num, 0, num2);
					}
				}
				object value2 = ((fieldType != null && fieldType.IsEnum) ? Enum.ToObject(fieldType, num) : ((object)num));
				LuggageStateField.SetValue(luggage, value2);
			}
			catch
			{
			}
		}

		private static PhotonView GetPhotonView(Component component)
		{
			if ((Object)(object)component == (Object)null)
			{
				return null;
			}
			PhotonView component2 = component.GetComponent<PhotonView>();
			if ((Object)(object)component2 != (Object)null)
			{
				return component2;
			}
			return component.GetComponentInParent<PhotonView>();
		}

		private static void SetRespawnChestState(RespawnChest respawnChest, bool isSpent, bool hasRevivedPlayers)
		{
			if ((Object)(object)respawnChest == (Object)null)
			{
				return;
			}
			try
			{
				RespawnChestSetSpentMethod?.Invoke(respawnChest, new object[1] { isSpent });
				SetRespawnChestHasRevivedPlayers(respawnChest, hasRevivedPlayers);
			}
			catch
			{
			}
		}

		private static bool GetRespawnChestHasRevivedPlayers(RespawnChest respawnChest)
		{
			if ((Object)(object)respawnChest == (Object)null)
			{
				return false;
			}
			try
			{
				if (RespawnChestGetRevivedPlayersMethod?.Invoke(respawnChest, null) is bool result)
				{
					return result;
				}
				object obj = RespawnChestRevivedPlayersField?.GetValue(respawnChest);
				if (obj is bool)
				{
					return (bool)obj;
				}
			}
			catch
			{
			}
			return false;
		}

		private static void SetRespawnChestHasRevivedPlayers(RespawnChest respawnChest, bool hasRevivedPlayers)
		{
			if ((Object)(object)respawnChest == (Object)null)
			{
				return;
			}
			try
			{
				if (RespawnChestSetRevivedPlayersMethod != null)
				{
					RespawnChestSetRevivedPlayersMethod.Invoke(respawnChest, new object[1] { hasRevivedPlayers });
				}
				else
				{
					RespawnChestRevivedPlayersField?.SetValue(respawnChest, hasRevivedPlayers);
				}
			}
			catch
			{
			}
		}

		private static string GetDayNightTimeString(DayNightManager dayNight)
		{
			if ((Object)(object)dayNight == (Object)null)
			{
				return string.Empty;
			}
			try
			{
				if ((DayNightTimeStringGetterMethod?.Invoke(dayNight, null) ?? DayNightTimeStringField?.GetValue(dayNight)) is string result)
				{
					return result;
				}
			}
			catch
			{
			}
			return string.Empty;
		}

		private static void SetDayNightTimeString(DayNightManager dayNight, string timeString)
		{
			if ((Object)(object)dayNight == (Object)null || string.IsNullOrWhiteSpace(timeString))
			{
				return;
			}
			try
			{
				if (DayNightTimeStringSetterMethod != null)
				{
					DayNightTimeStringSetterMethod.Invoke(dayNight, new object[1] { timeString });
				}
				else
				{
					DayNightTimeStringField?.SetValue(dayNight, timeString);
				}
			}
			catch
			{
			}
		}

		private bool CanSaveNow(bool showReason)
		{
			//IL_0010: 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)
			if (IsInAirportScene())
			{
				if (showReason)
				{
					SetStatus("You cannot save in the Airport.", Color.yellow, 3f);
				}
				return false;
			}
			if (PhotonNetwork.InRoom && !PhotonNetwork.IsMasterClient)
			{
				if (showReason)
				{
					SetStatus("Only host can save shared runs.", Color.yellow, 3f);
				}
				return false;
			}
			return true;
		}

		private bool TrySaveGame(string saveName)
		{
			//IL_00f7: 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_00ac: Unknown result type (might be due to invalid IL or missing references)
			if (!CanSaveNow(showReason: true))
			{
				return false;
			}
			try
			{
				if (!EnsureSaveDirectoryReady(showStatus: true))
				{
					return false;
				}
				string text = NormalizeSaveDisplayName(saveName);
				SaveEnvelope saveEnvelope = CaptureSnapshot(text);
				if (saveEnvelope.players == null || saveEnvelope.players.Count == 0)
				{
					SetStatus("Could not find an active player to save. Try again in-run.", Color.yellow, 4f);
					((BaseUnityPlugin)this).Logger.LogWarning((object)"Save aborted: snapshot captured 0 players.");
					return false;
				}
				string text2 = ResolveSavePathForName(text);
				string contents = JsonConvert.SerializeObject((object)saveEnvelope, (Formatting)1);
				File.WriteAllText(text2, contents);
				if (text.Equals("Autosave", StringComparison.OrdinalIgnoreCase))
				{
					CleanupLegacyAutosaves(text2);
				}
				RefreshSaveFileList();
				SetStatus("Saved: " + text, Color.green, 3f);
				((BaseUnityPlugin)this).Logger.LogInfo((object)("Saved run to " + text2));
				return true;
			}
			catch (Exception ex)
			{
				((BaseUnityPlugin)this).Logger.LogError((object)$"Save failed: {ex}");
				SetStatus(BuildSaveFailureStatus(ex), Color.red, 6f);
				return false;
			}
		}

		private bool TryOverwriteSave(string fullPath, string saveNameHint)
		{
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: 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_00c9: Unknown result type (might be due to invalid IL or missing references)
			if (!CanSaveNow(showReason: true))
			{
				return false;
			}
			if (string.IsNullOrWhiteSpace(fullPath))
			{
				SetStatus("Invalid save path.", Color.red, 4f);
				return false;
			}
			try
			{
				if (!EnsureSaveDirectoryReady(showStatus: true))
				{
					return false;
				}
				string text = NormalizeSaveDisplayName(string.IsNullOrWhiteSpace(saveNameHint) ? Path.GetFileNameWithoutExtension(fullPath) : saveNameHint.Trim());
				SaveEnvelope saveEnvelope = CaptureSnapshot(text);
				if (saveEnvelope.players == null || saveEnvelope.players.Count == 0)
				{
					SetStatus("Could not find an active player to overwrite from. Try again in-run.", Color.yellow, 4f);
					((BaseUnityPlugin)this).Logger.LogWarning((object)("Overwrite aborted for '" + fullPath + "': snapshot captured 0 players."));
					return false;
				}
				string contents = JsonConvert.SerializeObject((object)saveEnvelope, (Formatting)1);
				File.WriteAllText(fullPath, contents);
				RefreshSaveFileList();
				SetStatus("Overwrote save: " + text, Color.green, 3f);
				((BaseUnityPlugin)this).Logger.LogInfo((object)("Overwrote run at " + fullPath));
				return true;
			}
			catch (Exception ex)
			{
				((BaseUnityPlugin)this).Logger.LogError((object)$"Overwrite failed for '{fullPath}': {ex}");
				SetStatus(BuildSaveFailureStatus(ex), Color.red, 6f);
				return false;
			}
		}

		internal void UiRefreshSaveList()
		{
			RefreshSaveFileList();
		}

		internal List<SaveListEntry> UiGetSaveEntries()
		{
			return new List<SaveListEntry>(saveEntries);
		}

		internal void UiQuickSave()
		{
			bool saveSucceeded = TrySaveGame("Quick Save");
			MaybeCompletePendingQuitAfterSave(saveSucceeded);
		}

		internal void UiNamedSave(string saveName)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			if (string.IsNullOrWhiteSpace(saveName))
			{
				SetStatus("Enter a save name first.", Color.yellow, 3f);
				return;
			}
			bool saveSucceeded = TrySaveGame(saveName.Trim());
			MaybeCompletePendingQuitAfterSave(saveSucceeded);
		}

		internal void UiLoadSave(string fullPath)
		{
			StartLoadFromUi(fullPath);
		}

		internal void UiOverwriteSave(string fullPath, string saveNameHint)
		{
			bool saveSucceeded = TryOverwriteSave(fullPath, saveNameHint);
			MaybeCompletePendingQuitAfterSave(saveSucceeded);
		}

		internal void UiDeleteSave(string fullPath)
		{
			TryDeleteSave(fullPath);
		}

		internal bool UiCanSaveNow(bool showReason = false)
		{
			return CanSaveNow(showReason);
		}

		internal bool UiIsLoading()
		{
			return isLoading;
		}

		internal string UiCurrentStatus()
		{
			if (string.IsNullOrWhiteSpace(statusMessage))
			{
				return string.Empty;
			}
			if (statusMessageUntil <= Time.unscaledTime)
			{
				return string.Empty;
			}
			return statusMessage;
		}

		internal bool UiHasPendingQuitSaveDecision()
		{
			return quitPendingSaveDecision;
		}

		internal void UiQuickSaveAndQuit()
		{
			if (CanSaveNow(showReason: true) && TrySaveGame("Quick Save"))
			{
				CompletePendingQuit();
			}
		}

		internal void UiNamedSaveAndQuit(string saveName)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			if (CanSaveNow(showReason: true))
			{
				if (string.IsNullOrWhiteSpace(saveName))
				{
					SetStatus("Enter a save name before Save & Quit.", Color.yellow, 3f);
				}
				else if (TrySaveGame(saveName.Trim()))
				{
					CompletePendingQuit();
				}
			}
		}

		internal void UiQuitWithoutSaving()
		{
			CompletePendingQuit();
		}

		internal void UiCancelPendingQuit()
		{
			quitPendingSaveDecision = false;
			quitPendingPage = null;
		}

		private void MaybeCompletePendingQuitAfterSave(bool saveSucceeded)
		{
			if (saveSucceeded && quitPendingSaveDecision)
			{
				CompletePendingQuit();
			}
		}

		private void CompletePendingQuit()
		{
			PauseMenuMainPage page = quitPendingPage;
			quitPendingSaveDecision = false;
			quitPendingPage = null;
			ContinueWithVanillaQuit(page);
		}

		private SaveEnvelope CaptureSnapshot(string saveName)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: 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)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Expected I4, but got Unknown
			Scene activeScene = SceneManager.GetActiveScene();
			string name = ((Scene)(ref activeScene)).name;
			LevelGeneration val = Object.FindFirstObjectByType<LevelGeneration>();
			int levelSeed = (((Object)(object)val != (Object)null) ? val.seed : 0);
			int currentSegment = 0;
			Segment val2 = (Segment)0;
			string currentSegmentName = ((object)(Segment)(ref val2)).ToString();
			if (MapHandler.Exists)
			{
				MapHandler val3 = Object.FindFirstObjectByType<MapHandler>();
				if ((Object)(object)val3 != (Object)null)
				{
					Segment currentSegment2 = val3.GetCurrentSegment();
					currentSegment = (int)currentSegment2;
					currentSegmentName = ((object)(Segment)(ref currentSegment2)).ToString();
				}
			}
			int? dailyLevelIndex = null;
			string biomeId = string.Empty;
			try
			{
				NextLevelService service = GameHandler.GetService<NextLevelService>();
				if (service != null && service.HasReceivedLevelIndex)
				{
					dailyLevelIndex = service.NextLevelIndexOrFallback;
					biomeId = SingletonAsset<MapBaker>.Instance.GetBiomeID(dailyLevelIndex.Value + NextLevelService.debugLevelIndexOffset);
				}
			}
			catch (Exception ex)
			{
				((BaseUnityPlugin)this).Logger.LogWarning((object)("Could not capture NextLevelService metadata: " + ex.Message));
			}
			string text = ResolveLevelName(name, dailyLevelIndex);
			int? levelNumber = ParseLevelNumber(text);
			CaptureRunMetadata(out var runDay, out var runTimeSeconds, out var runTimerActive, out var timeOfDay, out var inGameTime);
			SaveEnvelope saveEnvelope = new SaveEnvelope
			{
				pluginGuid = "com.lucasandersen.peakallyouneedsavemanager",
				pluginVersion = "1.0.0",
				metadata = new SaveMetadata
				{
					saveName = saveName,
					savedAtUtc = DateTime.UtcNow,
					sceneName = name,
					levelName = text,
					levelNumber = levelNumber,
					dailyLevelIndex = dailyLevelIndex,
					biomeId = biomeId,
					levelSeed = levelSeed,
					currentSegment = currentSegment,
					currentSegmentName = currentSegmentName,
					ascent = Ascents.currentAscent,
					runDay = runDay,
					runTimeSeconds = runTimeSeconds,
					runTimerActive = runTimerActive,
					timeOfDay = timeOfDay,
					inGameTime = inGameTime
				}
			};
			CapturePlayers(saveEnvelope.players);
			saveEnvelope.metadata.playerCount = saveEnvelope.players.Count;
			CaptureCampfires(saveEnvelope.campfires);
			CaptureLuggageStates(saveEnvelope.luggageStates);
			CaptureContainerStates(saveEnvelope.containerStates);
			CaptureGroundItems(saveEnvelope.groundItems);
			CaptureWorldObjects(saveEnvelope.worldObjects);
			return saveEnvelope;
		}

		private static void CaptureRunMetadata(out int? runDay, out float? runTimeSeconds, out bool? runTimerActive, out float? timeOfDay, out string inGameTime)
		{
			runDay = null;
			runTimeSeconds = null;
			runTimerActive = null;
			timeOfDay = null;
			inGameTime = string.Empty;
			try
			{
				DayNightManager val = DayNightManager.instance ?? Object.FindFirstObjectByType<DayNightManager>();
				if ((Object)(object)val != (Object)null)
				{
					runDay = Mathf.Max(0, val.dayCount);
					timeOfDay = val.timeOfDay;
					string dayNightTimeString = GetDayNightTimeString(val);
					if (!string.IsNullOrWhiteSpace(dayNightTimeString))
					{
						inGameTime = dayNightTimeString;
					}
					else
					{
						inGameTime = val.FloatToTimeString(val.timeOfDay);
					}
				}
			}
			catch (Exception ex)
			{
				SaveManagerPlugin instance = Instance;
				if (instance != null)
				{
					((BaseUnityPlugin)instance).Logger.LogWarning((object)("Could not capture day/night metadata: " + ex.Message));
				}
			}
			try
			{
				RunManager val2 = RunManager.Instance ?? Object.FindFirstObjectByType<RunManager>();
				if ((Object)(object)val2 != (Object)null)
				{
					runTimeSeconds = Mathf.Max(0f, val2.timeSinceRunStarted);
					runTimerActive = TryGetRunTimerActive(val2);
				}
			}
			catch (Exception ex2)
			{
				SaveManagerPlugin instance2 = Instance;
				if (instance2 != null)
				{
					((BaseUnityPlugin)instance2).Logger.LogWarning((object)("Could not capture run timer metadata: " + ex2.Message));
				}
			}
		}

		private static bool? TryGetRunTimerActive(RunManager runManager)
		{
			if ((Object)(object)runManager == (Object)null || RunManagerTimerActiveField == null)
			{
				return null;
			}
			try
			{
				object value = RunManagerTimerActiveField.GetValue(runManager);
				if (value is bool)
				{
					return (bool)value;
				}
			}
			catch
			{
			}
			return null;
		}

		private void CapturePlayers(List<PlayerSnapshot> output)
		{
			Player[] array = Object.FindObjectsByType<Player>((FindObjectsSortMode)0);
			foreach (Player player in array)
			{
				try
				{
					output.Add(CapturePlayer(player));
				}
				catch (Exception ex)
				{
					((BaseUnityPlugin)this).Logger.LogWarning((object)("Failed to snapshot player: " + ex.Message));
				}
			}
			if (output.Count > 0)
			{
				return;
			}
			Character[] array2 = Object.FindObjectsByType<Character>((FindObjectsSortMode)0);
			foreach (Character val in array2)
			{
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				Player val2 = ((Component)val).GetComponent<Player>() ?? ((Component)val).GetComponentInParent<Player>();
				if (!((Object)(object)val2 == (Object)null))
				{
					try
					{
						output.Add(CapturePlayer(val2));
					}
					catch (Exception ex2)
					{
						((BaseUnityPlugin)this).Logger.LogWarning((object)("Failed to snapshot fallback player: " + ex2.Message));
					}
					if (output.Count > 0)
					{
						break;
					}
				}
			}
			if (output.Count > 0)
			{
				return;
			}
			foreach (Player item in EnumeratePlayersFromHandler())
			{
				if (!((Object)(object)item == (Object)null))
				{
					try
					{
						output.Add(CapturePlayer(item));
					}
					catch (Exception ex3)
					{
						((BaseUnityPlugin)this).Logger.LogWarning((object)("Failed to snapshot handler fallback player: " + ex3.Message));
					}
					if (output.Count > 0)
					{
						break;
					}
				}
			}
		}

		[IteratorStateMachine(typeof(<EnumeratePlayersFromHandler>d__155))]
		private static IEnumerable<Player> EnumeratePlayersFromHandler()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <EnumeratePlayersFromHandler>d__155(-2);
		}

		private PlayerSnapshot CapturePlayer(Player player)
		{
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_012b: 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_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: 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)
			string text = "Unknown";
			int actorNumber = 0;
			PhotonView photonView = GetPhotonView((Component)(object)player);
			if ((Object)(object)photonView == (Object)null && (Object)(object)player != (Object)null && (Object)(object)player.character != (Object)null)
			{
				photonView = GetPhotonView((Component)(object)player.character);
			}
			if ((Object)(object)photonView != (Object)null)
			{
				Player owner = photonView.Owner;
				if (owner != null)
				{
					text = owner.NickName;
					actorNumber = owner.ActorNumber;
				}
				else
				{
					actorNumber = photonView.OwnerActorNr;
				}
			}
			Character character = player.character;
			Vector3 source = (((Object)(object)character != (Object)null) ? GetCharacterPosition(character) : ((Component)player).transform.position);
			Vector3 source2 = (((Object)(object)character != (Object)null) ? ((Component)character).transform.eulerAngles : ((Component)player).transform.eulerAngles);
			CaptureCharacterVelocity(character, out var velocity, out var angularVelocity);
			InventorySnapshot inventory;
			try
			{
				inventory = CaptureInventory(player, character);
			}
			catch (Exception ex)
			{
				SaveManagerPlugin instance = Instance;
				if (instance != null)
				{
					((BaseUnityPlugin)instance).Logger.LogWarning((object)("Inventory capture fallback for player '" + text + "': " + ex.Message));
				}
				inventory = new InventorySnapshot();
			}
			return new PlayerSnapshot
			{
				playerName = text,
				actorNumber = actorNumber,
				position = new Vector3Snapshot(source),
				rotation = new Vector3Snapshot(source2),
				velocity = new Vector3Snapshot(velocity),
				angularVelocity = new Vector3Snapshot(angularVelocity),
				character = CaptureCharacter(character),
				inventory = inventory
			};
		}

		private static CharacterSnapshot CaptureCharacter(Character character)
		{
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			CharacterSnapshot characterSnapshot = new CharacterSnapshot();
			if ((Object)(object)character == (Object)null)
			{
				return characterSnapshot;
			}
			characterSnapshot.dead = character.data.dead;
			characterSnapshot.passedOut = character.data.passedOut;
			characterSnapshot.fullyPassedOut = character.data.fullyPassedOut;
			characterSnapshot.isGrounded = character.data.isGrounded;
			characterSnapshot.isClimbing = character.data.isClimbing;
			characterSnapshot.isRopeClimbing = character.data.isRopeClimbing;
			characterSnapshot.isVineClimbing = character.data.isVineClimbing;
			characterSnapshot.isSprinting = character.data.isSprinting;
			characterSnapshot.currentStamina = character.data.currentStamina;
			characterSnapshot.extraStamina = character.data.extraStamina;
			characterSnapshot.sinceGrounded = character.data.sinceGrounded;
			characterSnapshot.lookValues = new Vector2Snapshot(character.data.lookValues);
			characterSnapshot.checkpointFlagPaths = CaptureCharacterCheckpointPaths(character);
			characterSnapshot.statuses = CaptureCharacterStatuses(character);
			return characterSnapshot;
		}

		private static List<string> CaptureCharacterCheckpointPaths(Character character)
		{
			List<string> list = new List<string>();
			if ((Object)(object)character == (Object)null || (Object)(object)character.data == (Object)null || CharacterDataCheckpointFlagsField == null)
			{
				return list;
			}
			try
			{
				if (CharacterDataCheckpointFlagsField.GetValue(character.data) is IEnumerable enumerable)
				{
					foreach (object item in enumerable)
					{
						CheckpointFlag val = (CheckpointFlag)((item is CheckpointFlag) ? item : null);
						if (val != null && (Object)(object)val != (Object)null)
						{
							string text = BuildTransformPath(((Component)val).transform);
							if (!string.IsNullOrWhiteSpace(text))
							{
								list.Add(text);
							}
						}
					}
				}
			}
			catch
			{
			}
			return list;
		}

		private static void CaptureCharacterVelocity(Character character, out Vector3 velocity, out Vector3 angularVelocity)
		{
			//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_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: 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_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: 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_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			velocity = Vector3.zero;
			angularVelocity = Vector3.zero;
			if (!((Object)(object)character == (Object)null))
			{
				Rigidbody val = ((character.refs != null && (Object)(object)character.refs.hip != (Object)null) ? character.refs.hip.Rig : null);
				if ((Object)(object)val != (Object)null)
				{
					velocity = val.linearVelocity;
					angularVelocity = val.angularVelocity;
				}
				else if ((Object)(object)character.data != (Object)null)
				{
					velocity = character.data.avarageVelocity;
					angularVelocity = character.data.avarageLastFrameVelocity;
				}
			}
		}

		private static List<CharacterStatusSnapshot> CaptureCharacterStatuses(Character character)
		{
			//IL_0053: 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_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			List<CharacterStatusSnapshot> list = new List<CharacterStatusSnapshot>();
			if ((Object)(object)character == (Object)null || character.refs == null || (Object)(object)character.refs.afflictions == (Object)null)
			{
				return list;
			}
			CharacterAfflictions afflictions = character.refs.afflictions;
			Array values = Enum.GetValues(typeof(STATUSTYPE));
			for (int i = 0; i < values.Length; i++)
			{
				STATUSTYPE val = (STATUSTYPE)values.GetValue(i);
				if (!SkippedSavedStatuses.Contains(val))
				{
					float currentStatus = afflictions.GetCurrentStatus(val);
					if (!(currentStatus <= 0f))
					{
						list.Add(new CharacterStatusSnapshot
						{
							statusType = ((object)(STATUSTYPE)(ref val)).ToString(),
							amount = currentStatus
						});
					}
				}
			}
			return list;
		}

		private static InventorySnapshot CaptureInventory(Player player, Character character)
		{
			InventorySnapshot inventorySnapshot = new InventorySnapshot();
			if ((Object)(object)player == (Object)null)
			{
				return inventorySnapshot;
			}
			if (player.itemSlots != null)
			{
				for (int i = 0; i < player.itemSlots.Length; i++)
				{
					inventorySnapshot.mainSlots.Add(CaptureItemSlot(player.itemSlots[i]));
				}
			}
			inventorySnapshot.tempSlot = CaptureItemSlot(player.tempFullSlot);
			inventorySnapshot.hasBackpack = player.backpackSlot != null && player.backpackSlot.hasBackpack;
			if (inventorySnapshot.hasBackpack && TryGetBackpackData(player, out var backpackData) && backpackData != null && backpackData.itemSlots != null)
			{
				for (int j = 0; j < backpackData.itemSlots.Length; j++)
				{
					inventorySnapshot.backpackSlots.Add(CaptureItemSlot(backpackData.itemSlots[j]));
				}
			}
			CaptureEquippedSelection(player, character, inventorySnapshot);
			return inventorySnapshot;
		}

		private static void CaptureEquippedSelection(Player player, Character character, InventorySnapshot snapshot)
		{
			if (snapshot == null)
			{
				return;
			}
			Item val = (((Object)(object)character != (Object)null && (Object)(object)character.data != (Object)null) ? character.data.currentItem : null);
			if ((Object)(object)val != (Object)null)
			{
				snapshot.heldItemId = val.itemID;
			}
			if (TryGetCharacterSelectedSlot(character, out var selectedSlot))
			{
				snapshot.selectedSlotId = selectedSlot;
				if ((Object)(object)player != (Object)null && player.itemSlots != null && selectedSlot >= 0 && selectedSlot < player.itemSlots.Length)
				{
					snapshot.equippedMainSlotIndex = selectedSlot;
				}
			}
			if (!snapshot.equippedMainSlotIndex.HasValue && snapshot.heldItemId != ushort.MaxValue && (Object)(object)player != (Object)null && player.itemSlots != null)
			{
				for (int i = 0; i < player.itemSlots.Length; i++)
				{
					ItemSlot val2 = player.itemSlots[i];
					if (val2 != null && (Object)(object)val2.prefab != (Object)null && val2.prefab.itemID == snapshot.heldItemId)
					{
						snapshot.equippedMainSlotIndex = i;
						break;
					}
				}
			}
			if (snapshot.heldItemId != ushort.MaxValue && (Object)(object)player != (Object)null && player.tempFullSlot != null && (Object)(object)player.tempFullSlot.prefab != (Object)null && player.tempFullSlot.prefab.itemID == snapshot.heldItemId)
			{
				snapshot.equippedTempSlot = true;
			}
			if (snapshot.heldItemId == ushort.MaxValue || !((Object)(object)player != (Object)null) || !TryGetBackpackData(player, out var backpackData) || backpackData == null || backpackData.itemSlots == null)
			{
				return;
			}
			for (int j = 0; j < backpackData.itemSlots.Length; j++)
			{
				ItemSlot val3 = backpackData.itemSlots[j];
				if (val3 != null && (Object)(object)val3.prefab != (Object)null && val3.prefab.itemID == snapshot.heldItemId)
				{
					snapshot.equippedBackpackSlotIndex = j;
					break;
				}
			}
		}

		private static ItemSlotSnapshot CaptureItemSlot(ItemSlot slot)
		{
			if (slot == null || (Object)(object)slot.prefab == (Object)null)
			{
				return ItemSlotSnapshot.Empty();
			}
			ItemSlotSnapshot itemSlotSnapshot = new ItemSlotSnapshot
			{
				itemId = slot.prefab.itemID
			};
			CaptureItemUsageData(slot.data, itemSlotSnapshot);
			return itemSlotSnapshot;
		}

		private static void CaptureItemUsageData(ItemInstanceData data, ItemSlotSnapshot snapshot)
		{
			if (data != null && snapshot != null)
			{
				if (TryReadItemUsageInt(data, (DataEntryKey)2, out var value))
				{
					snapshot.itemUses = value;
				}
				if (TryReadItemUsageInt(data, (DataEntryKey)12, out var value2))
				{
					snapshot.petterItemUses = value2;
				}
				if (TryReadItemUsageFloat(data, (DataEntryKey)11, out var value3))
				{
					snapshot.useRemainingPercentage = value3;
				}
				if (TryReadItemUsageBool(data, (DataEntryKey)8, out var value4))
				{
					snapshot.used = value4;
				}
				if (TryReadItemUsageFloat(data, (DataEntryKey)10, out var value5))
				{
					snapshot.fuel = value5;
				}
				if (TryReadItemUsageInt(data, (DataEntryKey)1, out var value6))
				{
					snapshot.cookedAmount = value6;
				}
				if (TryReadItemUsageBool(data, (DataEntryKey)3, out var value7))
				{
					snapshot.flareActive = value7;
				}
				if (TryReadItemUsageFloat(data, (DataEntryKey)13, out var value8))
				{
					snapshot.screamTime = value8;
				}
				if (TryReadItemUsageBool(data, (DataEntryKey)5, out var value9))
				{
					snapshot.spawnedBees = value9;
				}
				CaptureGenericItemData(data, snapshot.dataEntries);
			}
		}

		private static void CaptureItemUsageData(ItemInstanceData data, GroundItemSnapshot snapshot)
		{
			if (data != null && snapshot != null)
			{
				if (TryReadItemUsageInt(data, (DataEntryKey)2, out var value))
				{
					snapshot.itemUses = value;
				}
				if (TryReadItemUsageInt(data, (DataEntryKey)12, out var value2))
				{
					snapshot.petterItemUses = value2;
				}
				if (TryReadItemUsageFloat(data, (DataEntryKey)11, out var value3))
				{
					snapshot.useRemainingPercentage = value3;
				}
				if (TryReadItemUsageBool(data, (DataEntryKey)8, out var value4))
				{
					snapshot.used = value4;
				}
				if (TryReadItemUsageFloat(data, (DataEntryKey)10, out var value5))
				{
					snapshot.fuel = value5;
				}
				if (TryReadItemUsageInt(data, (DataEntryKey)1, out var value6))
				{
					snapshot.cookedAmount = value6;
				}
				if (TryReadItemUsageBool(data, (DataEntryKey)3, out var value7))
				{
					snapshot.flareActive = value7;
				}
				if (TryReadItemUsageFloat(data, (DataEntryKey)13, out var value8))
				{
					snapshot.screamTime = value8;
				}
				if (TryReadItemUsageBool(data, (DataEntryKey)5, out var value9))
				{
					snapshot.spawnedBees = value9;
				}
				CaptureGenericItemData(data, snapshot.dataEntries);
			}
		}

		private static bool TryReadItemUsageInt(ItemInstanceData data, DataEntryKey key, out int value)
		{
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			value = 0;
			if (!TryGetRawDataEntry(data, key, out var value2) || value2 == null)
			{
				return false;
			}
			OptionableIntItemData val = (OptionableIntItemData)(object)((value2 is OptionableIntItemData) ? value2 : null);
			if (val != null && TryReadOptionableInt(val, out var value3))
			{
				value = value3;
				return true;
			}
			IntItemData val2 = (IntItemData)(object)((value2 is IntItemData) ? value2 : null);
			if (val2 != null)
			{
				value = val2.Value;
				return true;
			}
			FloatItemData val3 = (FloatItemData)(object)((value2 is FloatItemData) ? value2 : null);
			if (val3 != null)
			{
				value = Mathf.RoundToInt(val3.Value);
				return true;
			}
			BoolItemData val4 = (BoolItemData)(object)((value2 is BoolItemData) ? value2 : null);
			if (val4 != null)
			{
				value = (val4.Value ? 1 : 0);
				return true;
			}
			return false;
		}

		private static bool TryReadItemUsageFloat(ItemInstanceData data, DataEntryKey key, out float value)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			value = 0f;
			if (!TryGetRawDataEntry(data, key, out var value2) || value2 == null)
			{
				return false;
			}
			OptionableIntItemData val = (OptionableIntItemData)(object)((value2 is OptionableIntItemData) ? value2 : null);
			if (val != null && TryReadOptionableInt(val, out var value3))
			{
				value = value3;
				return true;
			}
			FloatItemData val2 = (FloatItemData)(object)((value2 is FloatItemData) ? value2 : null);
			if (val2 != null)
			{
				value = val2.Value;
				return true;
			}
			IntItemData val3 = (IntItemData)(object)((value2 is IntItemData) ? value2 : null);
			if (val3 != null)
			{
				value = val3.Value;
				return true;
			}
			return false;
		}

		private static bool TryReadItemUsageBool(ItemInstanceData data, DataEntryKey key, out bool value)
		{
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			value = false;
			if (!TryGetRawDataEntry(data, key, out var value2) || value2 == null)
			{
				return false;
			}
			OptionableBoolItemData val = (OptionableBoolItemData)(object)((value2 is OptionableBoolItemData) ? value2 : null);
			if (val != null && TryReadOptionableBool(val, out var value3))
			{
				value = value3;
				return true;
			}
			BoolItemData val2 = (BoolItemData)(object)((value2 is BoolItemData) ? value2 : null);
			if (val2 != null)
			{
				value = val2.Value;
				return true;
			}
			IntItemData val3 = (IntItemData)(object)((value2 is IntItemData) ? value2 : null);
			if (val3 != null)
			{
				value = val3.Value > 0;
				return true;
			}
			return false;
		}

		private static bool TryReadOptionableInt(OptionableIntItemData data, out int value)
		{
			value = 0;
			if (data == null)
			{
				return false;
			}
			bool flag = true;
			if (OptionableIntHasDataField != null)
			{
				try
				{
					object value2 = OptionableIntHasDataField.GetValue(data);
					if (value2 is bool)
					{
						bool flag2 = (bool)value2;
						flag = flag2;
					}
				}
				catch
				{
				}
			}
			if (!flag)
			{
				return false;
			}
			if (OptionableIntValueField != null)
			{
				try
				{
					object value3 = OptionableIntValueField.GetValue(data);
					if (value3 is int)
					{
						int num = (int)value3;
						value = num;
						return true;
					}
				}
				catch
				{
				}
			}
			return false;
		}

		private static bool TryReadOptionableBool(OptionableBoolItemData data, out bool value)
		{
			value = false;
			if (data == null)
			{
				return false;
			}
			bool flag = true;
			if (OptionableBoolHasDataField != null)
			{
				try
				{
					object value2 = OptionableBoolHasDataField.GetValue(data);
					if (value2 is bool)
					{
						bool flag2 = (bool)value2;
						flag = flag2;
					}
				}
				catch
				{
				}
			}
			if (!flag)
			{
				return false;
			}
			if (OptionableBoolValueField != null)
			{
				try
				{
					object value3 = OptionableBoolValueField.GetValue(data);
					if (value3 is bool)
					{
						bool flag3 = (bool)value3;
						value = flag3;
						return true;
					}
				}
				catch
				{
				}
			}
			return false;
		}

		private static bool TryGetRawDataEntry(ItemInstanceData data, DataEntryKey key, out DataEntryValue value)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			value = null;
			if (data == null || data.data == null)
			{
				return false;
			}
			try
			{
				if (data.data.TryGetValue(key, out var value2) && value2 != null)
				{
					value = value2;
					return true;
				}
			}
			catch
			{
			}
			return false;
		}

		private static void CaptureGenericItemData(ItemInstanceData data, List<ItemDataEntrySnapshot> output)
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			if (data == null || output == null || data.data == null)
			{
				return;
			}
			output.Clear();
			foreach (KeyValuePair<DataEntryKey, DataEntryValue> datum in data.data)
			{
				if (TryCreateItemDataEntrySnapshot(datum.Key, datum.Value, out var snapshot))
				{
					output.Add(snapshot);
				}
			}
		}

		private static bool TryCreateItemDataEntrySnapshot(DataEntryKey key, DataEntryValue value, out ItemDataEntrySnapshot snapshot)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Expected I4, but got Unknown
			//IL_0166: Unknown result type (might be due to invalid IL or missing references)
			snapshot = null;
			if (value == null)
			{
				return false;
			}
			snapshot = new ItemDataEntrySnapshot
			{
				keyValue = (int)key,
				keyName = ((object)(DataEntryKey)(ref key)).ToString(),
				valueType = ((object)value).GetType().AssemblyQualifiedName,
				hasValue = true
			};
			IntItemData val = (IntItemData)(object)((value is IntItemData) ? value : null);
			if (val == null)
			{
				FloatItemData val2 = (FloatItemData)(object)((value is FloatItemData) ? value : null);
				if (val2 == null)
				{
					BoolItemData val3 = (BoolItemData)(object)((value is BoolItemData) ? value : null);
					if (val3 == null)
					{
						OptionableIntItemData val4 = (OptionableIntItemData)(object)((value is OptionableIntItemData) ? value : null);
						if (val4 == null)
						{
							OptionableBoolItemData val5 = (OptionableBoolItemData)(object)((value is OptionableBoolItemData) ? value : null);
							if (val5 == null)
							{
								ColorItemData val6 = (ColorItemData)(object)((value is ColorItemData) ? value : null);
								if (val6 == null)
								{
									BackpackData val7 = (BackpackData)(object)((value is BackpackData) ? value : null);
									if (val7 != null)
									{
										if (val7.itemSlots != null)
										{
											for (int i = 0; i < val7.itemSlots.Length; i++)
											{
												snapshot.backpackSlots.Add(CaptureItemSlot(val7.itemSlots[i]));
											}
										}
										return true;
									}
									try
									{
										snapshot.serializedJson = JsonConvert.SerializeObject((object)value, (Formatting)0);
										return true;
									}
									catch
									{
										snapshot.serializedJson = ((object)value).ToString();
										snapshot.stringValue = ((object)value).ToString();
										return true;
									}
								}
								snapshot.hasColorValue = true;
								snapshot.colorValue = new Vector4Snapshot(new Vector4(val6.Value.r, val6.Value.g, val6.Value.b, val6.Value.a));
								return true;
							}
							snapshot.hasValue = TryReadOptionableBool(val5, out var value2);
							if (snapshot.hasValue)
							{
								snapshot.boolValue = value2;
							}
							return true;
						}
						snapshot.hasValue = TryReadOptionableInt(val4, out var value3);
						if (snapshot.hasValue)
						{
							snapshot.intValue = value3;
						}
						return true;
					}
					snapshot.boolValue = val3.Value;
					return true;
				}
				snapshot.floatValue = val2.Value;
				return true;
			}
			snapshot.intValue = val.Value;
			return true;
		}

		private static void ApplyGenericItemData(ItemInstanceData data, List<ItemDataEntrySnapshot> snapshots)
		{
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			if (data == null || snapshots == null || snapshots.Count == 0)
			{
				return;
			}
			for (int i = 0; i < snapshots.Count; i++)
			{
				ItemDataEntrySnapshot itemDataEntrySnapshot = snapshots[i];
				if (itemDataEntrySnapshot == null || !TryResolveDataEntryKey(itemDataEntrySnapshot, out var key) || !TryCreateDataEntryValue(itemDataEntrySnapshot, out var value) || value == null)
				{
					continue;
				}
				try
				{
					if (data.data == null)
					{
						data.data = new Dictionary<DataEntryKey, DataEntryValue>();
					}
					data.data[key] = value;
				}
				catch
				{
				}
			}
		}

		private static bool TryResolveDataEntryKey(ItemDataEntrySnapshot entry, out DataEntryKey key)
		{
			key = (DataEntryKey)0;
			if (entry == null)
			{
				return false;
			}
			if (!string.IsNullOrWhiteSpace(entry.keyName) && Enum.TryParse<DataEntryKey>(entry.keyName, ignoreCase: true, out key))
			{
				return true;
			}
			key = (DataEntryKey)(byte)entry.keyValue;
			return true;
		}

		private static bool TryCreateDataEntryValue(ItemDataEntrySnapshot entry, out DataEntryValue value)
		{
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Expected O, but got Unknown
			//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_008d: Expected O, but got Unknown
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Expected O, but got Unknown
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Expected O, but got Unknown
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Expected O, but got Unknown
			//IL_01c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c8: Expected O, but got Unknown
			//IL_0166: Unknown result type (might be due to invalid IL or missing references)
			//IL_0159: 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_0172: Unknown result type (might be due to invalid IL or missing references)
			//IL_0173: Unknown result type (might be due to invalid IL or missing references)
			//IL_0179: Unknown result type (might be due to invalid IL or missing references)
			//IL_017f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0194: Unknown result type (might be due to invalid IL or missing references)
			//IL_019a: Unknown result type (might be due to invalid IL or missing references)
			//IL_019f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a5: Expected O, but got Unknown
			value = null;
			if (entry == null)
			{
				return false;
			}
			Type type = ResolveDataEntryValueType(entry.valueType);
			if (type == null || !typeof(DataEntryValue).IsAssignableFrom(type))
			{
				return false;
			}
			try
			{
				if (type == typeof(IntItemData))
				{
					value = (DataEntryValue)new IntItemData
					{
						Value = entry.intValue.GetValueOrDefault()
					};
					return true;
				}
				if (type == typeof(FloatItemData))
				{
					value = (DataEntryValue)new FloatItemData
					{
						Value = entry.floatValue.GetValueOrDefault()
					};
					return true;
				}
				if (type == typeof(BoolItemData))
				{
					value = (DataEntryValue)new BoolItemData
					{
						Value = entry.boolValue.GetValueOrDefault()
					};
					return true;
				}
				if (type == typeof(OptionableIntItemData))
				{
					value = (DataEntryValue)new OptionableIntItemData
					{
						HasData = entry.hasValue,
						Value = entry.intValue.GetValueOrDefault()
					};
					return true;
				}
				if (type == typeof(OptionableBoolItemData))
				{
					value = (DataEntryValue)new OptionableBoolItemData
					{
						HasData = entry.hasValue,
						Value = entry.boolValue.GetValueOrDefault()
					};
					return true;
				}
				if (type == typeof(ColorItemData))
				{
					Vector4 val = ((entry.colorValue != null) ? entry.colorValue.ToUnity() : Vector4.zero);
					value = (DataEntryValue)new ColorItemData
					{
						Value = new Color(val.x, val.y, val.z, entry.hasColorValue ? val.w : 1f)
					};
					return true;
				}
				if (type == typeof(BackpackData))
				{
					BackpackData val2 = new BackpackData();
					((DataEntryValue)val2).Init();
					if (entry.backpackSlots != null)
					{
						int num = ((val2.itemSlots != null) ? val2.itemSlots.Length : 0);
						Item val3 = default(Item);
						for (int i = 0; i < entry.backpackSlots.Count && i < num; i++)
						{
							ItemSlotSnapshot itemSlotSnapshot = entry.backpackSlots[i];
							if (itemSlotSnapshot != null && itemSlotSnapshot.HasItem() && ItemDatabase.TryGetItem(itemSlotSnapshot.itemId, ref val3) && (Object)(object)val3 != (Object)null)
							{
								val2.AddItem(val3, CreateItemInstanceData(itemSlotSnapshot), (byte)i);
							}
						}
					}
					value = (DataEntryValue)(object)val2;
					return true;
				}
				if (string.IsNullOrWhiteSpace(entry.serializedJson))
				{
					return false;
				}
				object obj = JsonConvert.DeserializeObject(entry.serializedJson, type);
				value = (DataEntryValue)((obj is DataEntryValue) ? obj : null);
				return value != null;
			}
			catch
			{
				return false;
			}
		}

		private static Type ResolveDataEntryValueType(string assemblyQualifiedTypeName)
		{
			if (string.IsNullOrWhiteSpace(assemblyQualifiedTypeName))
			{
				return null;
			}
			Type type = Type.GetType(assemblyQualifiedTypeName, throwOnError: false);
			if (type != null)
			{
				return type;
			}
			string text = assemblyQualifiedTypeName;
			int num = assemblyQualifiedTypeName.IndexOf(',');
			if (num >= 0)
			{
				text = assemblyQualifiedTypeName.Substring(0, num).Trim();
			}
			return AccessTools.TypeByName(text);
		}

		private void CaptureCampfires(List<CampfireSnapshot> output)
		{
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Expected I4, but got Unknown
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Expected I4, but got Unknown
			MapHandler val = Object.FindFirstObjectByType<MapHandler>();
			if ((Object)(object)val == (Object)null || val.segments == null)
			{
				return;
			}
			for (int i = 0; i < val.segments.Length; i++)
			{
				try
				{
					MapSegment val2 = val.segments[i];
					if (val2 != null && !((Object)(object)val2.segmentCampfire == (Object)null))
					{
						Campfire componentInChildren = val2.segmentCampfire.GetComponentInChildren<Campfire>(true);
						if (!((Object)(object)componentInChildren == (Object)null))
						{
							output.Add(new CampfireSnapshot
							{
								segmentIndex = i,
								campfireName = ((Object)componentInChildren).name,
								state = (int)componentInChildren.state,
								beenBurningFor = componentInChildren.beenBurningFor,
								advanceToSegment = (int)componentInChildren.advanceToSegment
							});
						}
					}
				}
				catch (Exception ex)
				{
					((BaseUnityPlugin)this).Logger.LogWarning((object)$"Could not snapshot campfire for segment {i}: {ex.Message}");
				}
			}
		}

		private void CaptureLuggageStates(List<LuggageSnapshot> output)
		{
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			if (output == null)
			{
				return;
			}
			Luggage[] array = Object.FindObjectsByType<Luggage>((FindObjectsSortMode)0);
			foreach (Luggage val in array)
			{
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				try
				{
					LuggageSnapshot luggageSnapshot = new LuggageSnapshot
					{
						objectName = NormalizeObjectName(((Object)val).name),
						objectPath = BuildTransformPath(((Component)val).transform),
						position = new Vector3Snapshot(((Component)val).transform.position),
						state = GetLuggageState(val)
					};
					RespawnChest val2 = (RespawnChest)(object)((val is RespawnChest) ? val : null);
					if (val2 != null)
					{
						luggageSnapshot.isRespawnChest = true;
						luggageSnapshot.respawnChestSpent = val2.IsSpent;
						luggageSnapshot.respawnChestRevivedPlayers = GetRespawnChestHasRevivedPlayers(val2);
					}
					output.Add(luggageSnapshot);
				}
				catch (Exception ex)
				{
					((BaseUnityPlugin)this).Logger.LogWarning((object)("Failed to capture luggage state: " + ex.Message));
				}
			}
		}

		private void CaptureContainerStates(List<ContainerSnapshot> output)
		{
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_0155: Unknown result type (might be due to invalid IL or missing references)
			if (output == null)
			{
				return;
			}
			output.Clear();
			Luggage[] array = Object.FindObjectsByType<Luggage>((FindObjectsSortMode)0);
			foreach (Luggage val in array)
			{
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				try
				{
					ContainerSnapshot containerSnapshot = new ContainerSnapshot
					{
						containerType = ((object)val).GetType().FullName,
						objectName = NormalizeObjectName(((Object)val).name),
						objectPath = BuildTransformPath(((Component)val).transform),
						position = new Vector3Snapshot(((Component)val).transform.position),
						state = GetLuggageState(val)
					};
					RespawnChest val2 = (RespawnChest)(object)((val is RespawnChest) ? val : null);
					if (val2 != null)
					{
						containerSnapshot.boolA = val2.IsSpent;
						containerSnapshot.boolB = GetRespawnChestHasRevivedPlayers(val2);
					}
					output.Add(containerSnapshot);
				}
				catch (Exception ex)
				{
					((BaseUnityPlugin)this).Logger.LogWarning((object)("Failed to capture container state for '" + ((Object)val).name + "': " + ex.Message));
				}
			}
			MirageLuggage[] array2 = Object.FindObjectsByType<MirageLuggage>((FindObjectsSortMode)0);
			foreach (MirageLuggage val3 in array2)
			{
				if (!((Object)(object)val3 == (Object)null))
				{
					try
					{
						ContainerSnapshot item = new ContainerSnapshot
						{
							containerType = ((object)val3).GetType().FullName,
							objectName = NormalizeObjectName(((Object)val3).name),
							objectPath = BuildTransformPath(((Component)val3).transform),
							position = new Vector3Snapshot(((Component)val3).transform.position),
							state = GetMirageLuggageVisualState(val3),
							boolA = ((Component)val3).gameObject.activeSelf
						};
						output.Add(item);
					}
					catch (Exception ex2)
					{
						((BaseUnityPlugin)this).Logger.LogWarning((object)("Failed to capture MirageLuggage state: " + ex2.Message));
					}
				}
			}
		}

		private void CaptureGroundItems(List<GroundItemSnapshot> output)
		{
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: 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)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			if (output == null)
			{
				return;
			}
			Item[] array = Object.FindObjectsByType<Item>((FindObjectsSortMode)0);
			foreach (Item val in array)
			{
				if (!IsGroundItemCandidate(val))
				{
					continue;
				}
				Transform transform = ((Component)val).transform;
				GroundItemSnapshot groundItemSnapshot = new GroundItemSnapshot
				{
					itemId = val.itemID,
					objectName = NormalizeObjectName(((Object)val).name),
					objectPath = BuildTransformPath(transform),
					position = new Vector3Snapshot(transform.position),
					rotation = new Vector3Snapshot(transform.eulerAngles),
					velocity = (((Object)(object)val.rig != (Object)null) ? new Vector3Snapshot(val.rig.linearVelocity) : new Vector3Snapshot(Vector3.zero)),
					angularVelocity = (((Object)(object)val.rig != (Object)null) ? new Vector3Snapshot(val.rig.angularVelocity) : new Vector3Snapshot(Vector3.zero)),
					isKinematic = ((Object)(object)val.rig != (Object)null && val.rig.isKinematic)
				};
				if (TryGetItemInstanceData(val, out var data))
				{
					CaptureItemUsageData(data, groundItemSnapshot);
				}
				else if (ItemTotalUsesField != null)
				{
					try
					{
						object value = ItemTotalUsesField.GetValue(val);
						if (value is int)
						{
							int num = (int)value;
							if (num >= 0)
							{
								groundItemSnapshot.itemUses = num;
							}
						}
					}
					catch
					{
					}
				}
				output.Add(groundItemSnapshot);
			}
		}

		private void CaptureWorldObjects(List<WorldObjectSnapshot> output)
		{
			if (output != null)
			{
				ShittyPiton[] array = Object.FindObjectsByType<ShittyPiton>((FindObjectsSortMode)0);
				if (array != null && array.Length != 0)
				{
					CaptureWorldObjectSnapshots<ShittyPiton>(array, "Piton", output, (Action<ShittyPiton, WorldObjectSnapshot>)delegate
					{
					});
				}
				else
				{
					CaptureWorldObjectSnapshots<ClimbingSpikeComponent>(Object.FindObjectsByType<ClimbingSpikeComponent>((FindObjectsSortMode)0), "PitonLegacy", output, (Action<ClimbingSpikeComponent, WorldObjectSnapshot>)delegate
					{
					});
				}
				CaptureWorldObjectSnapshots<RopeAnchor>(Object.FindObjectsByType<RopeAnchor>((FindObjectsSortMode)0), "RopeAnchor", output, (Action<RopeAnchor, WorldObjectSnapshot>)delegate(RopeAnchor component, WorldObjectSnapshot snapshot)
				{
					snapshot.boolA = component.Ghost;
				});
				CaptureWorldObjectSnapshots<Rope>(Object.FindObjectsByType<Rope>((FindObjectsSortMode)0), "Rope", output, (Action<Rope, WorldObjectSnapshot>)delegate(Rope component, WorldObjectSnapshot snapshot)
				{
					snapshot.boolA = component.antigrav;
					snapshot.floatA = component.Segments;
				});
				CaptureWorldObjectSnapshots<RopeAnchorWithRope>(Object.FindObjectsByType<RopeAnchorWithRope>((FindObjectsSortMode)0), "RopeAnchorWithRope", output, (Action<RopeAnchorWithRope, WorldObjectSnapshot>)delegate(RopeAnchorWithRope component, WorldObjectSnapshot snapshot)
				{
					snapshot.floatA = component.ropeSegmentLength;
					snapshot.boolA = (Object)(object)component.ropeInstance != (Object)null || (Object)(object)component.rope != (Object)null;
				});
				CaptureWorldObjectSnapshots<ScoutCannon>(Object.FindObjectsByType<ScoutCannon>((FindObjectsSortMode)0), "ScoutCannon", output, (Action<ScoutCannon, WorldObjectSnapshot>)delegate(ScoutCannon component, WorldObjectSnapshot snapshot)
				{
					snapshot.boolA = component.lit;
				});
				CaptureWorldObjectSnapshots<Campfire>(FindNonSegmentCampfires(), "PortableStove", output, (Action<Campfire, WorldObjectSnapshot>)delegate(Campfire component, WorldObjectSnapshot snapshot)
				{
					//IL_0002: Unknown result type (might be due to invalid IL or missing references)
					//IL_000e: Expected I4, but got Unknown
					//IL_0016: Unknown result type (might be due to invalid IL or missing references)
					//IL_001c: Invalid comparison between Unknown and I4
					snapshot.floatA = Mathf.Clamp((int)component.state, 0, 2);
					snapshot.boolA = (int)component.state == 1;
					snapshot.floatB = Mathf.Max(0f, component.beenBurningFor);
				});
				CaptureWorldObjectSnapshots<MagicBeanVine>(Object.FindObjectsByType<MagicBeanVine>((FindObjectsSortMode)0), "MagicBeanVine", output, (Action<MagicBeanVine, WorldObjectSnapshot>)delegate(MagicBeanVine component, WorldObjectSnapshot snapshot)
				{
					snapshot.floatA = Mathf.Max(0f, GetMagicBeanVineCurrentLength(component));
				});
				CaptureWorldObjectSnapshots<CloudFungus>(Object.FindObjectsByType<CloudFungus>((FindObjectsSortMode)0), "CloudFungus", output, (Action<CloudFungus, WorldObjectSnapshot>)delegate(CloudFungus component, WorldObjectSnapshot snapshot)
				{
					snapshot.boolA = GetCloudFungusAlreadyBroke(component);
					snapshot.floatA = Mathf.Max(0f, GetCloudFungusTimeAlive(component));
				});
				CaptureWorldObjectSnapshots<CheckpointFlag>(Object.FindObjectsByType<CheckpointFlag>((FindObjectsSortMode)0), "CheckpointFlag", output, (Action<CheckpointFlag, WorldObjectSnapshot>)CaptureCheckpointFlagState);
				CaptureWorldObjectSnapshots<CheckpointConstructable>(Object.FindObjectsByType<CheckpointConstructable>((FindObjectsSortMode)0), "CheckpointConstructable", output, (Action<CheckpointConstructable, WorldObjectSnapshot>)delegate
				{
				});
				CaptureWorldObjectSnapshots<WobbleSpinBounce>(FindBounceFungusObjects(), "BounceFungus", output, (Action<WobbleSpinBounce, WorldObjectSnapshot>)delegate
				{
				});
				CaptureWorldObjectSnapshots<ShelfShroom>(Object.FindObjectsByType<ShelfShroom>((FindObjectsSortMode)0), "ShelfShroom", output, (Action<ShelfShroom, WorldObjectSnapshot>)delegate
				{
				});
				CaptureWorldObjectSnapshots<RopeShooter>(Object.FindObjectsByType<RopeShooter>((FindObjectsSortMode)0).Where(IsGroundRopeShooterCandidate).ToArray(), "ChainLauncher", output, (Action<RopeShooter, WorldObjectSnapshot>)delegate(RopeShooter component, WorldObjectSnapshot snapshot)
				{
					int chainLauncherAmmo = GetChainLauncherAmmo(component);
					snapshot.boolA = chainLauncherAmmo > 0;
					snapshot.floatA = chainLauncherAmmo;
				});
			}
		}

		private static void CaptureWorldObjectSnapshots<T>(T[] components, string kind, List<WorldObjectSnapshot> output, Action<T, WorldObjectSnapshot> applyExtra) where T : Component
		{
			//IL_0060: 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)
			if (components == null || output == null)
			{
				return;
			}
			foreach (T val in components)
			{
				if (!((Object)(object)val == (Object)null))
				{
					Transform transform = ((Component)val).transform;
					WorldObjectSnapshot worldObjectSnapshot = new WorldObjectSnapshot
					{
						kind = kind,
						objectName = NormalizeObjectName(((Object)(object)val).name),
						objectPath = BuildTransformPath(transform),
						position = new Vector3Snapshot(transform.position),
						rotation = new Vector3Snapshot(transform.eulerAngles)
					};
					applyExtra?.Invoke(val, worldObjectSnapshot);
					output.Add(worldObjectSnapshot);
				}
			}
		}

		private static void CaptureCheckpointFlagState(CheckpointFlag flag, WorldObjectSnapshot snapshot)
		{
			if ((Object)(object)flag == (Object)null || snapshot == null)
			{
				return;
			}
			float[] checkpointStatuses = GetCheckpointStatuses(flag);
			if (checkpointStatuses != null && checkpointStatuses.Length != 0)
			{
				snapshot.floatListA = new List<float>(checkpointStatuses.Length);
				for (int i = 0; i < checkpointStatuses.Length; i++)
				{
					snapshot.floatListA.Add(Mathf.Max(0f, checkpointStatuses[i]));
				}
			}
			Character checkpointPlanter = GetCheckpointPlanter(flag);
			if (!((Object)(object)checkpointPlanter == (Object)null))
			{
				PhotonView photonView = GetPhotonView((Component)(object)checkpointPlanter);
				Player val = (((Object)(object)photonView != (Object)null) ? photonView.Owner : null);
				if (val != null)
				{
					snapshot.intA = val.ActorNumber;
					snapshot.stringA = val.NickName;
				}
				else
				{
					snapshot.stringA = NormalizeObjectName(((Object)checkpointPlanter).name);
				}
				snapshot.stringB = BuildTransformPath(((Component)checkpointPlanter).transform);
			}
		}

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

		[IteratorStateMachine(typeof(<LoadSceneRoutine>d__186))]
		private IEnumerator LoadSceneRoutine(string sceneName, int ascent)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <LoadSceneRoutine>d__186(0)
			{
				<>4__this = this,
				sceneName = sceneName,
				ascent = ascent
			};
		}

		private int CountMatchedPlayers(List<PlayerSnapshot> players)
		{
			if (players == null || players.Count == 0)
			{
				return 0;
			}
			Player[] array = Object.FindObjectsByType<Player>((FindObjectsSortMode)0);
			if (array.Length == 0)
			{
				return 0;
			}
			int num = 0;
			for (int i = 0; i < players.Count; i++)
			{
				PlayerSnapshot snapshot = players[i];
				if (array.Any(delegate(Player player)
				{
					PhotonView photonView = GetPhotonView((Component)(object)player);
					if ((Object)(object)photonView == (Object)null)
					{
						return false;
					}
					Player owner = photonView.Owner;
					if (snapshot.actorNumber > 0 && owner != null && owner.ActorNumber == snapshot.actorNumber)
					{
						return true;
					}
					return owner != null && string.Equals(owner.NickName, snapshot.playerName, StringComparison.OrdinalIgnoreCase);
				}))
				{
					num++;
				}
			}
			return num;
		}

		[IteratorStateMachine(typeof(<WaitForPlayersRoutine>d__188))]
		private static IEnumerator WaitForPlayersRoutine(List<PlayerSnapshot> players, float timeoutSeconds)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <WaitForPlayersRoutine>d__188(0)
			{
				players = players,
				timeoutSeconds = timeoutSeconds
			};
		}

		[IteratorStateMachine(typeof(<ApplyPlayerSnapshotRoutine>d__189))]
		private IEnumerator ApplyPlayerSnapshotRoutine(Player player, PlayerSnapshot snapshot)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <ApplyPlayerSnapshotRoutine>d__189(0)
			{
				<>4__this = this,
				player = player,
				snapshot = snapshot
			};
		}

		private void ApplyCharacterSnapshot(Character character, CharacterSnapshot snapshot)
		{
			if (!((Object)(object)character == (Object)null) && snapshot != null)
			{
				character.data.dead = snapshot.dead;
				character.data.passedOut = snapshot.passedOut;
				character.data.fullyPassedOut = snapshot.fullyPassedOut;
				character.data.isGrounded = snapshot.isGrounded;
				character.data.isClimbing = snapshot.isClimbing;
				character.data.isRopeClimbing = snapshot.isRopeClimbing;
				character.data.isVineClimbing = snapshot.isVineClimbing;
				character.data.isSprinting = snapshot.isSprinting;
				character.data.currentStamina = snapshot.currentStamina;
				character.SetExtraStamina(snapshot.extraStamina);
				character.data.sinceGrounded = snapshot.sinceGrounded;
				ApplyCharacterStatuses(character, snapshot.statuses);
				ApplyCharacterCheckpointFlags(character, snapshot.checkpointFlagPaths);
			}
		}

		private static void ApplyCharacterStatuses(Character character, List<CharacterStatusSnapshot> statusSnapshots)
		{
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)character == (Object)null || character.refs == null || (Object)(object)character.refs.afflictions == (Object)null)
			{
				return;
			}
			CharacterAfflictions afflictions = character.refs.afflictions;
			afflictions.ClearAllStatus(false);
			if (statusSnapshots == null || statusSnapshots.Count == 0)
			{
				afflictions.PushStatuses((Player)null);
				return;
			}
			for (int i = 0; i < statusSnapshots.Count; i++)
			{
				CharacterStatusSnapshot characterStatusSnapshot = statusSnapshots[i];
				if (characterStatusSnapshot != null && !string.IsNullOrWhiteSpace(characterStatusSnapshot.statusType) && Enum.TryParse<STATUSTYPE>(characterStatusSnapshot.statusType, ignoreCase: true, out STATUSTYPE result) && !SkippedSavedStatuses.Contains(result))
				{
					float num = Mathf.Max(0f, characterStatusSnapshot.amount);
					afflictions.SetStatus(result, num, false);
				}
			}
			afflictions.PushStatuses((Player)null);
		}

		private static void ApplyCharacterCheckpointFlags(Character character, List<string> checkpointFlagPaths)
		{
			if ((Object)(object)character == (Object)null || (Object)(object)character.data == (Object)null || CharacterDataCheckpointFlagsField == null)
			{
				return;
			}
			try
			{
				if (!(CharacterDataCheckpointFlagsField.GetValue(character.data) is IList list))
				{
					return;
				}
				list.Clear();
				if (checkpointFlagPaths == null || checkpointFlagPaths.Count == 0)
				{
					return;
				}
				CheckpointFlag[] array = Object.FindObjectsByType<CheckpointFlag>((FindObjectsSortMode)0);
				Dictionary<string, CheckpointFlag> dictionary = new Dictionary<string, CheckpointFlag>(StringComparer.OrdinalIgnoreCase);
				foreach (CheckpointFlag val in array)
				{
					if (!((Object)(object)val == (Object)null))
					{
						string text = BuildTransformPath(((Component)val).transform);
						if (!string.IsNullOrWhiteSpace(text) && !dictionary.ContainsKey(text))
						{
							dictionary[text] = val;
						}
					}
				}
				for (int j = 0; j < checkpointFlagPaths.Count; j++)
				{
					string text2 = checkpointFlagPaths[j];
					if (!string.IsNullOrWhiteSpace(text2) && dictionary.TryGetValue(text2, out var value) && (Object)(object)value != (Object)null)
					{
						list.Add(value);
					}
				}
			}
			catch
			{
			}
		}

		private static void ApplyCharacterVelocity(Character character, Vector3Snapshot velocitySnapshot, Vector3Snapshot angularVelocitySnapshot)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: 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_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: 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_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: 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_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)character == (Object)null || (Object)(object)character.data == (Object)null)
			{
				return;
			}
			Vector3 val = velocitySnapshot?.ToUnity() ?? Vector3.zero;
			Vector3 angularVelocity = angularVelocitySnapshot?.ToUnity() ?? Vector3.zero;
			character.data.avarageVelocity = val;
			character.data.avarageLastFrameVelocity = val;
			Rigidbody val2 = ((character.refs != null && (Object)(object)character.refs.hip != (Object)null) ? character.refs.hip.Rig : null);
			if ((Object)(object)val2 == (Object)null)
			{
				return;
			}
			try
			{
				val2.linearVelocity = val;
				val2.angularVelocity = angularVelocity;
			}
			catch
			{
			}
		}

		private static void ApplyEquippedSelection(Player player, Character character, InventorySnapshot snapshot)
		{
			if ((Object)(object)player == (Object)null || (Object)(object)character == (Object)null || snapshot == null)
			{
				return;
			}
			CharacterItems val = ((character.refs != null) ? character.refs.items : null);
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			int? num = null;
			if (snapshot.selectedSlotId.HasValue && IsValidMainSlot(player, snapshot.selectedSlotId.Value))
			{
				num = snapshot.selectedSlotId.Value;
			}
			else if (snapshot.equippedMainSlotIndex.HasValue && IsValidMainSlot(player, snapshot.equippedMainSlotIndex.Value))
			{
				num = snapshot.equippedMainSlotIndex.Value;
			}
			else if (snapshot.heldItemId != ushort.MaxValue && player.itemSlots != null)
			{
				for (int i = 0; i < player.itemSlots.Length; i++)
				{
					ItemSlot val2 = player.itemSlots[i];
					if (val2 != null && (Object)(object)val2.prefab != (Object)null && val2.prefab.itemID == snapshot.heldItemId)
					{
						num = i;
						break;
					}
				}
			}
			if (num.HasValue)
			{
				TryEquipSlot(val, (byte)num.Value);
			}
			Item val3 = default(Item);
			if (snapshot.heldItemId != ushort.MaxValue && ItemDatabase.TryGetItem(snapshot.heldItemId, ref val3) && (Object)(object)val3 != (Object)null)
			{
				character.data.currentItem = val3;
			}
		}

		private static bool IsValidMainSlot(Player player, int slotIndex)
		{
			if ((Object)(object)player != (Object)null && player.itemSlots != null && slotIndex >= 0)
			{
				return slotIndex < player.itemSlots.Length;
			}
			return false;
		}

		private static bool TryEquipSlot(CharacterItems items, byte slotId)
		{
			if ((Object)(object)items == (Object)null || CharacterItemsEquipSlotMethod == null)
			{
				return false;
			}
			object obj = CreateOptionableByte(slotId, hasValue: true);
			if (obj == null)
			{
				return false;
			}
			try
			{
				CharacterItemsEquipSlotMethod.Invoke(items, new object[1] { obj });
				return true;
			}
			catch
			{
				return false;
			}
		}

		private static object CreateOptionableByte(byte value, bool hasValue)
		{
			if (OptionableByteConstructor == null)
			{
				return null;
			}
			try
			{
				return OptionableByteConstructor.Invoke(new object[2]
				{
					value,
					hasValue ? ((byte)1) : ((byte)0)
				});
			}
			catch
			{
				return null;
			}
		}

		private static bool TryGetCharacterSelectedSlot(Character character, out int selectedSlot)
		{
			selectedSlot = -1;
			CharacterItems val = (((Object)(object)character != (Object)null && character.refs != null) ? character.refs.items : null);
			if ((Object)(object)val == (Object)null || CharacterItemsCurrentSelectedSlotField == null)
			{
				return false;
			}
			try
			{
				if (TryReadOptionableByte(CharacterItemsCurrentSelectedSlotField.GetValue(val), out var value))
				{
					selectedSlot = value;
					return true;
				}
			}
			catch
			{
			}
			return false;
		}

		private static bool TryReadOptionableByte(object optionableValue, out byte value)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			value = 0;
			if (optionableValue == null)
			{
				return false;
			}
			if (optionableValue is Optionable<byte> val)
			{
				if (!val.IsSome)
				{
					return false;
				}
				value = val.Value;
				return true;
			}
			try
			{
				if (OptionableByteHasValueField != null)
				{
					object value2 = OptionableByteHasValueField.GetValue(optionableValue);
					int num2;
					if (!(value2 is byte b))
					{
						bool flag = default(bool);
						int num;
						if (value2 is bool)
						{
							flag = (bool)value2;
							num = 1;
						}
						else
						{
							num = 0;
						}
						num2 = num & (flag ? 1 : 0);
					}
					else
					{
						num2 = ((b > 0) ? 1 : 0);
					}
					if (num2 == 0)
					{
						return false;
					}
				}
				if (OptionableByteValueField != null)
				{
					object value3 = OptionableByteValueField.GetValue(optionableValue);
					if (value3 is byte b2)
					{
						value = b2;
						return true;
					}
					if (value3 is int)
					{
						int num3 = (int)value3;
						if (num3 >= 0 && num3 <= 255)
						{
							value = (byte)num3;
							return true;
						}
					}
				}
			}
			catch
			{
			}
			return false;
		}

		private void ApplyInventory(Player player, Character character, InventorySnapshot snapshot)
		{
			//IL_0193: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)player == (Object)null || snapshot == null)
			{
				return;
			}
			if (player.itemSlots != null)
			{
				for (int i = 0; i < player.itemSlots.Length; i++)
				{
					player.itemSlots[i].EmptyOut();
				}
			}
			ItemSlot tempFullSlot = player.tempFullSlot;
			if (tempFullSlot != null)
			{
				tempFullSlot.EmptyOut();
			}
			ClearBackpackSlot(player);
			if (player.backpackSlot != null)
			{
				player.backpackSlot.hasBackpack = false;
			}
			int num = ((player.itemSlots != null) ? player.itemSlots.Length : 0);
			for (int j = 0; j < snapshot.mainSlots.Count && j < num; j++)
			{
				SetItemSlot(player.itemSlots[j], snapshot.mainSlots[j]);
			}
			SetItemSlot(player.tempFullSlot, snapshot.tempSlot);
			if (snapshot.hasBackpack && player.backpackSlot != null)
			{
				player.backpackSlot.hasBackpack = true;
				ItemInstanceData instanceData = CreateItemInstanceData();
				if (!SetBackpackSlotInstanceData(player, instanceData))
				{
					instanceData = GetBackpackSlotInstanceData(player);
				}
				if (TryEnsureBackpackData(instanceData, out var backpackData))
				{
					int num2 = ((backpackData.itemSlots != null) ? backpackData.itemSlots.Length : 0);
					for (int k = 0; k < snapshot.backpackSlots.Count && k < num2; k++)
					{
						ItemSlotSnapshot itemSlotSnapshot = snapshot.backpackSlots[k];
						if (itemSlotSnapshot.HasItem())
						{
							Item val = null;
							if (ItemDatabase.TryGetItem(itemSlotSnapshot.itemId, ref val) && (Object)(object)val != (Object)null)
							{
								backpackData.AddItem(val, CreateItemInstanceData(itemSlotSnapshot), (byte)k);
							}
						}
					}
				}
			}
			if (player.itemSlots != null)
			{
				byte[] array = IBinarySerializable.ToManagedArray<InventorySyncData>(new InventorySyncData(player.itemSlots, player.backpackSlot, player.tempFullSlot));
				PhotonView photonView = GetPhotonView((Component)(object)player);
				if ((Object)(object)photonView != (Object)null)
				{
					photonView.RPC("SyncInventoryRPC", (RpcTarget)0, new object[2] { array, true });
				}
			}
			ApplyEquippedSelection(player, character, snapshot);
		}

		private static void SetItemSlot(ItemSlot slot, ItemSlotSnapshot snapshot)
		{
			if (slot != null && snapshot != null && snapshot.HasItem())
			{
				Item val = null;
				if (ItemDatabase.TryGetItem(snapshot.itemId, ref val) && (Object)(object)val != (Object)null)
				{
					slot.SetItem(val, CreateItemInstanceData(snapshot));
				}
			}
		}

		private static ItemInstanceData CreateItemInstanceData()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Expected O, but got Unknown
			//IL_0011: Expected O, but got Unknown
			ItemInstanceData val = new ItemInstanceData(Guid.NewGuid());
			ItemInstanceDataHandler.AddInstanceData(val);
			return val;
		}

		private static ItemInstanceData CreateItemInstanceData(ItemSlotSnapshot snapshot)
		{
			ItemInstanceData obj = CreateItemInstanceData();
			ApplyItemUsageData(obj, snapshot);
			return obj;
		}

		private static void ApplyItemUsageData(ItemInstanceData data, ItemSlotSnapshot snapshot)
		{
			//IL_0025: 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_0042: Expected O, but got Unknown
			//IL_0053: 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_0074: Expected O, but got Unknown
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Expected O, but got Unknown
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Expected O, but got Unknown
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Expected O, but got Unknown
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: Expected O, but got Unknown
			//IL_0147: 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_0162: Expected O, but got Unknown
			//IL_0173: 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_0198: Expected O, but got Unknown
			//IL_01a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c3: Expected O, but got Unknown
			if (data != null && snapshot != null)
			{
				ApplyGenericItemData(data, snapshot.dataEntries);
				int? itemUses = snapshot.itemUses;
				if (itemUses.HasValue)
				{
					data.RegisterEntry<IntItemData>((DataEntryKey)2, new IntItemData
					{
						Value = Mathf.Max(0, itemUses.Value)
					});
				}
				if (snapshot.petterItemUses.HasValue)
				{
					data.RegisterEntry<IntItemData>((DataEntryKey)12, new IntItemData
					{
						Value = Mathf.Max(0, snapshot.petterItemUses.Value)
					});
				}
				if (snapshot.useRemainingPercentage.HasValue)
				{
					data.RegisterEntry<FloatItemData>((DataEntryKey)11, new FloatItemData
					{
						Value = Mathf.Clamp01(snapshot.useRemainingPercentage.Value)
					});
				}
				if (snapshot.used.HasValue)
				{
					data.RegisterEntry<BoolItemData>((DataEntryKey)8, new BoolItemData
					{
						Value = snapshot.used.Value
					});
				}
				if (snapshot.fuel.HasValue)
				{
					data.RegisterEntry<FloatItemData>((DataEntryKey)10, new FloatItemData
					{
						Value = Mathf.Max(0f, snapshot.fuel.Value)
					});
				}
				if (snapshot.cookedAmount.HasValue)
				{
					data.RegisterEntry<IntItemData>((DataEntryKey)1, new IntItemData
					{
						Value = Mathf.Max(0, snapshot.cookedAmount.Value)
					});
				}
				if (snapshot.flareActive.HasValue)
				{
					data.RegisterEntry<BoolItemData>((DataEntryKey)3, new BoolItemData
					{
						Value = snapshot.flareActive.Value
					});
				}
				if (snapshot.screamTime.HasValue)
				{
					data.RegisterEntry<FloatItemData>((DataEntryKey)13, new FloatItemData
					{
						Value = Mathf.Max(0f, snapshot.screamTime.Value)
					});
				}
				if (snapshot.spawnedBees.HasValue)
				{
					data.RegisterEntry<BoolItemData>((DataEntryKey)5, new BoolItemData
					{
						Value = snapshot.spawnedBees.Value
					});
				}
			}
		}

		private static bool TryEnsureBackpackData(ItemInstanceData instanceData, out BackpackData backpackData)
		{
			backpackData = null;
			if (instanceData == null)
			{
				return false;
			}
			if (instanceData.TryGetDataEntry<BackpackData>((DataEntryKey)7, ref backpackData) && backpackData != null)
			{
				if (backpackData.itemSlots == null || backpackData.itemSlots.Length == 0)
				{
					((DataEntryValue)backpackData).Init();
				}
				return true;
			}
			backpackData = instanceData.RegisterNewEntry<BackpackData>((DataEntryKey)7);
			if (backpackData == null)
			{
				return false;
			}
			((DataEntryValue)backpackData).Init();
			return true;
		}

		private void RestoreRunMetadata(SaveMetadata metadata)
		{
			if (metadata == null)
			{
				return;
			}
			try
			{
				DayNightManager val = DayNightManager.instance ?? Object.FindFirstObjectByType<DayNightManager>();
				if ((Object)(object)val != (Object)null)
				{
					if (metadata.runDay.HasValue)
					{
						val.dayCount = Mathf.Max(0, metadata.runDay.Value);
					}
					if (metadata.timeOfDay.HasValue)
					{
						val.setTimeOfDay(metadata.timeOfDay.Value);
					}
					string timeString = ((!string.IsNullOrWhiteSpace(metadata.inGameTime)) ? metadata.inGameTime : (metadata.timeOfDay.HasValue ? val.FloatToTimeString(metadata.timeOfDay.Value) : string.Empty));
					SetDayNightTimeString(val, timeString);
					val.UpdateCycle();
				}
			}
			catch (Exception ex)
			{
				((BaseUnityPlugin)this).Logger.LogWarning((object)("Failed to restore day/night metadata: " + ex.Message));
			}
			if (!metadata.runTimeSeconds.HasValue)
			{
				return;
			}
			try
			{
				RunManager val2 = RunManager.Instance ?? Object.FindFirstObjectByType<RunManager>();
				if (!((Object)(object)val2 == (Object)null))
				{
					float num = Mathf.Max(0f, metadata.runTimeSeconds.Value);
					bool valueOrDefault = metadata.runTimerActive.GetValueOrDefault(true);
					if (RunManagerRpcSyncTimeMethod != null)
					{
						RunManagerRpcSyncTimeMethod.Invoke(val2, new object[2] { num, valueOrDefault });
					}
					else
					{
						val2.timeSinceRunStarted = num;
						RunManagerTimerActiveField?.SetValue(val2, valueOrDefault);
					}
				}
			}
			catch (Exception ex2)
			{
				((BaseUnityPlugin)this).Logger.LogWarning((object)("Failed to restore run timer metadata: " + ex2.Message));
			}
		}

		private void RestoreCampfires(List<CampfireSnapshot> campfireSnapshots)
		{
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Expected I4, but got Unknown
			if (campfireSnapshots == null || campfireSnapshots.Count == 0)
			{
				return;
			}
			MapHandler val = Object.FindFirstObjectByType<MapHandler>();
			if ((Object)(object)val == (Object)null || val.segments == null)
			{
				return;
			}
			foreach (CampfireSnapshot campfireSnapshot in campfireSnapshots)
			{
				if (campfireSnapshot.segmentIndex < 0 || campfireSnapshot.segmentIndex >= val.segments.Length)
				{
					continue;
				}
				MapSegment val2 = val.segments[campfireSnapshot.segmentIndex];
				if (val2 == null || (Object)(object)val2.segmentCampfire == (Object)null)
				{
					continue;
				}
				Campfire componentInChildren = val2.segmentCampfire.GetComponentInChildren<Campfire>(true);
				if ((Object)(object)componentInChildren == (Object)null)
				{
					continue;
				}
				FireState val3 = (componentInChildren.state = (FireState)Mathf.Clamp(campfireSnapshot.state, 0, 2));
				componentInChildren.beenBurningFor = Mathf.Max(0f, campfireSnapshot.beenBurningFor);
				componentInChildren.advanceToSegment = ClampSegment(campfireSnapshot.advanceToSegment);
				switch ((int)val3)
				{
				case 0:
					if ((Object)(object)componentInChildren.fireParticles != (Object)null)
					{
						componentInChildren.fireParticles.Stop();
					}
					if ((Object)(object)componentInChildren.smokeParticlesLit != (Object)null)
					{
						componentInChildren.smokeParticlesLit.Stop();
					}
					if ((Object)(object)componentInChildren.smokeParticlesOff != (Object)null)
					{
						componentInChildren.smokeParticlesOff.Play();
					}
					break;
				case 1:
					if ((Object)(object)componentInChildren.fireParticles != (Object)null)
					{
						componentInChildren.fireParticles.Play();
					}
					if ((Object)(object)componentInChildren.smokeParticlesOff != (Object)null)
					{
						componentInChildren.smokeParticlesOff.Stop();
					}
					if ((Object)(object)componentInChildren.smokeParticlesLit != (Object)null)
					{
						componentInChildren.smokeParticlesLit.Play();
					}
					break;
				case 2:
					if ((Object)(object)componentInChildren.fireParticles != (Object)null)
					{
						componentInChildren.fireParticles.Stop();
					}
					if ((Object)(object)componentInChildren.smokeParticlesOff != (Object)null)
					{
						componentInChildren.smokeParticlesOff.Stop();
					}
					if ((Object)(object)componentInChildren.smokeParticlesLit != (Object)null)
					{
						componentInChildren.smokeParticlesLit.Stop();
					}
					CampfireHideLogsMethod?.Invoke(componentInChildren, null);
					break;
				}
				CampfireUpdateLitMethod?.Invoke(componentInChildren, null);
			}
		}

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

		private void RestoreContainerStates(List<ContainerSnapshot> containerSnapshots, List<LuggageSnapshot> legacyLuggageSnapshots)
		{
			if (containerSnapshots == null || containerSnapshots.Count == 0)
			{
				RestoreLuggageStates(legacyLuggageSnapshots);
				return;
			}
			List<Luggage> list = new List<Luggage>(from luggage in Object.FindObjectsByType<Luggage>((FindObjectsSortMode)0)
				where (Object)(object)luggage != (Object)null
				select luggage);
			for (int i = 0; i < containerSnapshots.Count; i++)
			{
				ContainerSnapshot containerSnapshot = containerSnapshots[i];
				if (containerSnapshot != null && IsLuggageContainerSnapshot(containerSnapshot))
				{
					Luggage val = FindLuggageForContainerSnapshot(containerSnapshot, list, 400f) ?? FindLuggageForContainerSnapshot(containerSnapshot, list, float.MaxValue);
					if (!((Object)(object)val == (Object)null))
					{
						list.Remove(val);
						ApplyContainerSnapshot(val, containerSnapshot);
					}
				}
			}
			List<MirageLuggage> list2 = new List<MirageLuggage>(from mirage in Object.FindObjectsByType<MirageLuggage>((FindObjectsSortMode)0)
				where (Object)(object)mirage != (Object)null
				select mirage);
			for (int j = 0; j < containerSnapshots.Count; j++)
			{
				ContainerSnapshot containerSnapshot2 = containerSnapshots[j];
				if (containerSnapshot2 != null && IsMirageContainerSnapshot(containerSnapshot2))
				{
					MirageLuggage val2 = FindMirageForContainerSnapshot(containerSnapshot2, list2, 400f) ?? FindMirageForContainerSnapshot(containerSnapshot2, list2, float.MaxValue);
					if (!((Object)(object)val2 == (Object)null))
					{
						list2.Remove(val2);
						ApplyMirageContainerSnapshot(val2, containerSnapshot2);
					}
				}
			}
		}

		private void RestoreLuggageStates(List<LuggageSnapshot> luggageSnapshots)
		{
			if (luggageSnapshots == null || luggageSnapshots.Count == 0)
			{
				return;
			}
			Luggage[] array = Object.FindObjectsByType<Luggage>((FindObjectsSortMode)0);
			if (array.Length == 0)
			{
				return;
			}
			List<Luggage> list = new List<Luggage>(array);
			for (int i = 0; i < luggageSnapshots.Count; i++)
			{
				LuggageSnapshot luggageSnapshot = luggageSnapshots[i];
				if (luggageSnapshot == null)
				{
					continue;
				}
				Luggage val = FindLuggageForSnapshot(luggageSnapshot, list, 400f);
				if ((Object)(object)val == (Object)null)
				{
					val = FindLuggageForSnapshot(luggageSnapshot, list, float.MaxValue);
					if ((Object)(object)val == (Object)null)
					{
						continue;
					}
				}
				list.Remove(val);
				ApplyLuggageSnapshot(val, luggageSnapshot);
			}
		}

		private static bool IsLuggageContainerSnapshot(ContainerSnapshot snapshot)
		{
			if (snapshot == null)
			{
				return false;
			}
			string containerType = snapshot.containerType;
			if (string.IsNullOrWhiteSpace(containerType))
			{
				return true;
			}
			if (containerType.Equals(typeof(Luggage).FullName, StringComparison.OrdinalIgnoreCase) || containerType.Equals(typeof(LuggageCursed).FullName, StringComparison.OrdinalIgnoreCase) || containerType.Equals(typeof(RespawnChest).FullName, StringComparison.OrdinalIgnoreCase))
			{
				return true;
			}
			if (!containerType.EndsWith(".Luggage", StringComparison.OrdinalIgnoreCase) && !containerType.EndsWith(".LuggageCursed", StringComparison.OrdinalIgnoreCase))
			{
				return containerType.EndsWith(".RespawnChest", StringComparison.OrdinalIgnoreCase);
			}
			return true;
		}

		private static bool IsMirageContainerSnapshot(ContainerSnapshot snapshot)
		{
			if (snapshot == null || string.IsNullOrWhiteSpace(snapshot.containerType))
			{
				return false;
			}
			if (!snapshot.containerType.Equals(typeof(MirageLuggage).FullName, StringComparison.OrdinalIgnoreCase))
			{
				return snapshot.containerType.EndsWith(".MirageLuggage", StringComparison.OrdinalIgnoreCase);
			}
			return true;
		}

		private static Luggage FindLuggageForContainerSnapshot(ContainerSnapshot snapshot, List<Luggage> candidates, float maxDistanceSquared)
		{
			if (snapshot == null)
			{
				return null;
			}
			return FindLuggageForSnapshot(new LuggageSnapshot
			{
				objectName = snapshot.objectName,
				objectPath = snapshot.objectPath,
				position = (snapshot.position ?? new Vector3Snapshot()),
				state = snapshot.state,
				isRespawnChest = (snapshot.boolA || snapshot.boolB)
			}, candidates, maxDistanceSquared);
		}

		private static MirageLuggage FindMirageForContainerSnapshot(ContainerSnapshot snapshot, List<MirageLuggage> candidates, float maxDistanceSquared)
		{
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			if (snapshot == null || candidates == null || candidates.Count == 0)
			{
				return null;
			}
			if (!string.IsNullOrWhiteSpace(snapshot.objectPath))
			{
				for (int i = 0; i < candidates.Count; i++)
				{
					MirageLuggage val = candidates[i];
					if (!((Object)(object)val == (Object)null) && string.Equals(BuildTransformPath(((Component)val).transform), snapshot.objectPath, StringComparison.OrdinalIgnoreCase))
					{
						return val;
					}
				}
			}
			MirageLuggage result = null;
			float num = maxDistanceSquared;
			Vector3 val2 = ((snapshot.position != null) ? snapshot.position.ToUnity() : Vector3.zero);
			string text = NormalizeObjectName(snapshot.objectName);
			for (int j = 0; j < candidates.Count; j++)
			{
				MirageLuggage val3 = candidates[j];
				if ((Object)(object)val3 == (Object)null)
				{
					continue;
				}
				string a = NormalizeObjectName(((Object)val3).name);
				if (string.IsNullOrWhiteSpace(text) || string.Equals(a, text, StringComparison.OrdinalIgnoreCase))
				{
					Vector3 val4 = ((Component)val3).transform.position - val2;
					float sqrMagnitude = ((Vector3)(ref val4)).sqrMagnitude;
					if (sqrMagnitude <= num)
					{
						num = sqrMagnitude;
						result = val3;
					}
				}
			}
			return result;
		}

		private static void ApplyContainerSnapshot(Luggage luggage, ContainerSnapshot snapshot)
		{
			if ((Object)(object)luggage == (Object)null || snapshot == null)
			{
				return;
			}
			int num = Mathf.Max(0, snapshot.state);
			SetLuggageStateRaw(luggage, num);
			if (num > 0)
			{
				try
				{
					PhotonView photonView = GetPhotonView((Component)(object)luggage);
					if ((Object)(object)photonView != (Object)null)
					{
						photonView.RPC("OpenLuggageRPC", (RpcTarget)0, new object[1] { false });
					}
					else
					{
						LuggageOpenRpcMethod?.Invoke(luggage, new object[1] { false });
					}
				}
				catch
				{
				}
			}
			RespawnChest val = (RespawnChest)(object)((luggage is RespawnChest) ? luggage : null);
			if (val != null)
			{
				SetRespawnChestState(val, snapshot.boolA, snapshot.boolB);
			}
		}

		private static void ApplyMirageContainerSnapshot(MirageLuggage mirage, ContainerSnapshot snapshot)
		{
			if ((Object)(object)mirage == (Object)null || snapshot == null)
			{
				return;
			}
			((Component)mirage).gameObject.SetActive(snapshot.boolA);
			if (!(MirageLuggageSetStateMethod != null))
			{
				return;
			}
			try
			{
				float num = Mathf.Clamp01((snapshot.state > 0) ? 1f : snapshot.floatA);
				MirageLuggageSetStateMethod.Invoke(mirage, new object[1] { num });
			}
			catch
			{
			}
		}

		private static Luggage FindClosestLuggage(Vector3 targetPosition, List<Luggage> candidates, float maxDistanceSquared)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: 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_002a: Unknown result type (might be due to invalid IL or missing references)
			Luggage result = null;
			float num = maxDistanceSquared;
			for (int i = 0; i < candidates.Count; i++)
			{
				Luggage val = candidates[i];
				if (!((Object)(object)val == (Object)null))
				{
					Vector3 val2 = ((Component)val).transform.position - targetPosition;
					float sqrMagnitude = ((Vector3)(ref val2)).sqrMagnitude;
					if (sqrMagnitude <= num)
					{
						num = sqrMagnitude;
						result = val;
					}
				}
			}
			return result;
		}

		private static Luggage FindLuggageForSnapshot(LuggageSnapshot snapshot, List<Luggage> candidates, float maxDistanceSquared)
		{
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: 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_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			if (snapshot == null || candidates == null || candidates.Count == 0)
			{
				return null;
			}
			if (!string.IsNullOrWhiteSpace(snapshot.objectPath))
			{
				for (int i = 0; i < candidates.Count; i++)
				{
					Luggage val = candidates[i];
					if (!((Object)(object)val == (Object)null) && string.Equals(BuildTransformPath(((Component)val).transform), snapshot.objectPath, StringComparison.OrdinalIgnoreCase))
					{
						return val;
					}
				}
			}
			if (!string.IsNullOrWhiteSpace(snapshot.objectName))
			{
				Luggage val2 = null;
				float num = maxDistanceSquared;
				Vector3 val3 = snapshot.position.ToUnity();
				string text = NormalizeObjectName(snapshot.objectName);
				for (int j = 0; j < candidates.Count; j++)
				{
					Luggage val4 = candidates[j];
					if ((Object)(object)val4 == (Object)null)
					{
						continue;
					}
					string a = NormalizeObjectName(((Object)val4).name);
					if (string.IsNullOrWhiteSpace(text) || string.Equals(a, text, StringComparison.OrdinalIgnoreCase))
					{
						Vector3 val5 = ((Component)val4).transform.position - val3;
						float sqrMagnitude = ((Vector3)(ref val5)).sqrMagnitude;
						if (sqrMagnitude <= num)
						{
							num = sqrMagnitude;
							val2 = val4;
						}
					}
				}
				if ((Object)(object)val2 != (Object)null)
				{
					return val2;
				}
			}
			return FindClosestLuggage(snapshot.position.ToUnity(), candidates, maxDistanceSquared);
		}

		private void ApplyLuggageSnapshot(Luggage luggage, LuggageSnapshot snapshot)
		{
			if ((Object)(object)luggage == (Object)null || snapshot == null)
			{
				return;
			}
			int num = Mathf.Max(0, snapshot.state);
			SetLuggageStateRaw(luggage, num);
			if (num > 0)
			{
				try
				{
					PhotonView photonView = GetPhotonView((Component)(object)luggage);
					if ((Object)(object)photonView != (Object)null)
					{
						photonView.RPC("OpenLuggageRPC", (RpcTarget)0, new object[1] { false });
					}
					else
					{
						LuggageOpenRpcMethod?.Invoke(luggage, new object[1] { false });
					}
				}
				catch (Exception ex)
				{
					((BaseUnityPlugin)this).Logger.LogWarning((object)("Failed to restore luggage open state: " + ex.Message));
				}
			}
			if (snapshot.isRespawnChest)
			{
				RespawnChest val = (RespawnChest)(object)((luggage is RespawnChest) ? luggage : null);
				if (val != null)
				{
					SetRespawnChestState(val, snapshot.respawnChestSpent, snapshot.respawnChestRevivedPlayers);
				}
			}
		}

		private void RestoreGroundItems(List<GroundItemSnapshot> itemSnapshots)
		{
			if (itemSnapshots == null)
			{
				return;
			}
			List<Item> list = new List<Item>(Object.FindObjectsByType<Item>((FindObjectsSortMode)0).Where(IsGroundItemCandidate));
			for (int i = 0; i < itemSnapshots.Count; i++)
			{
				GroundItemSnapshot groundItemSnapshot = itemSnapshots[i];
				if (groundItemSnapshot == null || groundItemSnapshot.itemId == ushort.MaxValue)
				{
					continue;
				}
				Item val = FindGroundItemForSnapshot(groundItemSnapshot, list, 16f);
				if ((Object)(object)val != (Object)null)
				{
					list.Remove(val);
					ApplyGroundItemSnapshot(val, groundItemSnapshot);
					continue;
				}
				Item val2 = TrySpawnGroundItem(groundItemSnapshot);
				if ((Object)(object)val2 != (Object)null)
				{
					ApplyGroundItemSnapshot(val2, groundItemSnapshot);
				}
			}
			for (int j = 0; j < list.Count; j++)
			{
				Item val3 = list[j];
				if ((Object)(object)val3 == (Object)null)
				{
					continue;
				}
				try
				{
					if (!PhotonNetwork.InRoom)
					{
						goto IL_00e7;
					}
					PhotonView photonView = GetPhotonView((Component)(object)val3);
					if (!((Object)(object)photonView != (Object)null) || photonView.ViewID <= 0)
					{
						goto IL_00e7;
					}
					PhotonNetwork.Destroy(((Component)val3).gameObject);
					goto end_IL_00b5;
					IL_00e7:
					Object.Destroy((Object)(object)((Component)val3).gameObject);
					end_IL_00b5:;
				}
				catch (Exception ex)
				{
					((BaseUnityPlugin)this).Logger.LogWarning((object)("Failed to remove extra ground item: " + ex.Message));
				}
			}
		}

		private static Item FindGroundItemForSnapshot(GroundItemSnapshot snapshot, List<Item> candidates, float maxDistanceSquared)
		{
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: 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)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0149: 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_014f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0154: Unknown result type (might be due to invalid IL or missing references)
			if (snapshot == null || candidates == null || candidates.Count == 0)
			{
				return null;
			}
			if (!string.IsNullOrWhiteSpace(snapshot.objectPath))
			{
				for (int i = 0; i < candidates.Count; i++)
				{
					Item val = candidates[i];
					if (!((Object)(object)val == (Object)null) && val.itemID == snapshot.itemId && string.Equals(BuildTransformPath(((Component)val).transform), snapshot.objectPath, StringComparison.OrdinalIgnoreCase))
					{
						return val;
					}
				}
			}
			Item val2 = null;
			float num = maxDistanceSquared;
			Vector3 val3 = snapshot.position.ToUnity();
			string text = NormalizeObjectName(snapshot.objectName);
			Vector3 val5;
			for (int j = 0; j < candidates.Count; j++)
			{
				Item val4 = candidates[j];
				if ((Object)(object)val4 == (Object)null || val4.itemID != snapshot.itemId)
				{
					continue;
				}
				string a = NormalizeObjectName(((Object)val4).name);
				if (string.IsNullOrWhiteSpace(text) || string.Equals(a, text, StringComparison.OrdinalIgnoreCase))
				{
					val5 = ((Component)val4).transform.position - val3;
					float sqrMagnitude = ((Vector3)(ref val5)).sqrMagnitude;
					if (sqrMagnitude <= num)
					{
						num = sqrMagnitude;
						val2 = val4;
					}
				}
			}
			if ((Object)(object)val2 != (Object)null)
			{
				return val2;
			}
			for (int k = 0; k < candidates.Count; k++)
			{
				Item val6 = candidates[k];
				if (!((Object)(object)val6 == (Object)null) && val6.itemID == snapshot.itemId)
				{
					val5 = ((Component)val6).transform.position - val3;
					float sqrMagnitude2 = ((Vector3)(ref val5)).sqrMagnitude;
					if (sqrMagnitude2 <= num)
					{
						num = sqrMagnitude2;
						val2 = val6;
					}
				}
			}
			return val2;
		}

		private static void ApplyGroundItemSnapshot(Item item, GroundItemSnapshot snapshot)
		{
			//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_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: 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)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)item == (Object)null || snapshot == null)
			{
				return;
			}
			Vector3 val = snapshot.position.ToUnity();
			Quaternion val2 = Quaternion.Euler(snapshot.rotation.ToUnity());
			Transform transform = ((Component)item).transform;
			transform.position = val;
			transform.rotation = val2;
			try
			{
				item.SetKinematicNetworked(snapshot.isKinematic, val, val2);
			}
			catch
			{
				if ((Object)(object)item.rig != (Object)null)
				{
					item.rig.isKinematic = snapshot.isKinematic;
				}
			}
			if ((Object)(object)item.rig != (Object)null)
			{
				try
				{
					item.rig.linearVelocity = ((snapshot.velocity != null) ? snapshot.velocity.ToUnity() : Vector3.zero);
					item.rig.angularVelocity = ((snapshot.angularVelocity != null) ? snapshot.angularVelocity.ToUnity() : Vector3.zero);
				}
				catch
				{
				}
			}
			ApplyItemUsageData(item, snapshot);
		}

		private static void ApplyItemUsageData(Item item, GroundItemSnapshot snapshot)
		{
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Expected O, but got Unknown
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Expected O, but got Unknown
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Expected O, but got Unknown
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Expected O, but got Unknown
			//IL_00f5: 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_011a: Expected O, but got Unknown
			//IL_012a: Unknown result type (might be due to invalid IL or missing references)
			//IL_012f: Unknown result type (might be due to invalid IL or missing references)
			//IL_014b: Expected O, but got Unknown
			//IL_015b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0160: Unknown result type (might be due to invalid IL or missing references)
			//IL_0176: Expected O, but got Unknown
			//IL_0187: Unknown result type (might be due to invalid IL or missing references)
			//IL_018c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ac: Expected O, but got Unknown
			//IL_01bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d7: Expected O, but got Unknown
			if ((Object)(object)item == (Object)null || snapshot == null)
			{
				return;
			}
			ItemInstanceData val = EnsureItemInstanceData(item);
			if (val != null)
			{
				ApplyGenericItemData(val, snapshot.dataEntries);
				if (snapshot.itemUses.HasValue)
				{
					val.RegisterEntry<IntItemData>((DataEntryKey)2, new IntItemData
					{
						Value = Mathf.Max(0, snapshot.itemUses.Value)
					});
				}
				if (snapshot.petterItemUses.HasValue)
				{
					val.RegisterEntry<IntItemData>((DataEntryKey)12, new IntItemData
					{
						Value = Mathf.Max(0, snapshot.petterItemUses.Value)
					});
				}
				if (snapshot.useRemainingPercentage.HasValue)
				{
					val.RegisterEntry<FloatItemData>((DataEntryKey)11, new FloatItemData
					{
						Value = Mathf.Clamp01(snapshot.useRemainingPercentage.Value)
					});
				}
				if (snapshot.used.HasValue)
				{
					val.RegisterEntry<BoolItemData>((DataEntryKey)8, new BoolItemData
					{
						Value = snapshot.used.Value
					});
				}
				if (snapshot.fuel.HasValue)
				{
					val.RegisterEntry<FloatItemData>((DataEntryKey)10, new FloatItemData
					{
						Value = Mathf.Max(0f, snapshot.fuel.Value)
					});
				}
				if (snapshot.cookedAmount.HasValue)
				{
					val.RegisterEntry<IntItemData>((DataEntryKey)1, new IntItemData
					{
						Value = Mathf.Max(0, snapshot.cookedAmount.Value)
					});
				}
				if (snapshot.flareActive.HasValue)
				{
					val.RegisterEntry<BoolItemData>((DataEntryKey)3, new BoolItemData
					{
						Value = snapshot.flareActive.Value
					});
				}
				if (snapshot.screamTime.HasValue)
				{
					val.RegisterEntry<FloatItemData>((DataEntryKey)13, new FloatItemData
					{
						Value = Mathf.Max(0f, snapshot.screamTime.Value)
					});
				}
				if (snapshot.spawnedBees.HasValue)
				{
					val.RegisterEntry<BoolItemData>((DataEntryKey)5, new BoolItemData
					{
						Value = snapshot.spawnedBees.Value
					});
				}
			}
			if (snapshot.useRemainingPercentage.HasValue)
			{
				try
				{
					item.SetUseRemainingPercentage(snapshot.useRemainingPercentage.Value);
				}
				catch
				{
				}
			}
			if (!snapshot.itemUses.HasValue || !(ItemTotalUsesField != null))
			{
				return;
			}
			try
			{
				ItemTotalUsesField.SetValue(item, Mathf.Max(0, snapshot.itemUses.Value));
			}
			catch
			{
			}
		}

		private static bool TryGetItemInstanceData(Item item, out ItemInstanceData data)
		{
			data = null;
			if ((Object)(object)item == (Object)null || ItemDataField == null)
			{
				return false;
			}
			try
			{
				object? value = ItemDataField.GetValue(item);
				data = (ItemInstanceData)((value is ItemInstanceData) ? value : null);
				return data != null;
			}
			catch
			{
				return false;
			}
		}

		private static ItemInstanceData EnsureItemInstanceData(Item item)
		{
			if ((Object)(object)item == (Object)null)
			{
				return null;
			}
			if (TryGetItemInstanceData(item, out var data))
			{
				return data;
			}
			data = CreateItemInstanceData();
			if (ItemDataField != null)
			{
				try
				{
					ItemDataField.SetValue(item, data);
				}
				catch
				{
				}
			}
			return data;
		}

		private Item TrySpawnGroundItem(GroundItemSnapshot snapshot)
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: 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_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: 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)
			try
			{
				Item val = null;
				if (!ItemDatabase.TryGetItem(snapshot.itemId, ref val) || (Object)(object)val == (Object)null)
				{
					return null;
				}
				Vector3 val2 = snapshot.position.ToUnity();
				Quaternion val3 = Quaternion.Euler(snapshot.rotation.ToUnity());
				GameObject val4 = null;
				if (PhotonNetwork.InRoom)
				{
					string[] array = new string[2]
					{
						"0_Items/" + ((Object)val).name,
						((Object)val).name
					};
					for (int i = 0; i < array.Length; i++)
					{
						if (!((Object)(object)val4 == (Object)null))
						{
							break;
						}
						try
						{
							val4 = PhotonNetwork.Instantiate(array[i], val2, val3, (byte)0, (object[])null);
						}
						catch
						{
						}
					}
				}
				if ((Object)(object)val4 == (Object)null)
				{
					val4 = Object.Instantiate<GameObject>(((Component)val).gameObject, val2, val3);
				}
				return ((Object)(object)val4 != (Object)null) ? val4.GetComponent<Item>() : null;
			}
			catch (Exception ex)
			{
				((BaseUnityPlugin)this).Logger.LogWarning((object)$"Failed to spawn ground item {snapshot?.itemId}: {ex.Message}");
				return null;
			}
		}

		private void RestoreWorldObjects(List<WorldObjectSnapshot> snapshots, int formatVersion)
		{
			if (snapshots == null || snapshots.Count == 0)
			{
				return;
			}
			RestoreWorldObjectType<ShittyPiton>(snapshots, "Piton", Object.FindObjectsByType<ShittyPiton>((FindObjectsSortMode)0), (Action<ShittyPiton, WorldObjectSnapshot>)delegate(ShittyPiton component, WorldObjectSnapshot snapshot)
			{
				ApplyTransformSnapshot(((Component)component).transform, snapshot.position, snapshot.rotation);
			}, removeExtras: true);
			RestoreWorldObjectType<ClimbingSpikeComponent>(snapshots, "PitonLegacy", Object.FindObjectsByType<ClimbingSpikeComponent>((FindObjectsSortMode)0), (Action<ClimbingSpikeComponent, WorldObjectSnapshot>)delegate(ClimbingSpikeComponent component, WorldObjectSnapshot snapshot)
			{
				ApplyTransformSnapshot(((Component)component).transform, snapshot.position, snapshot.rotation);
			}, removeExtras: true);
			RestoreWorldObjectType<RopeAnchor>(snapshots, "RopeAnchor", Object.FindObjectsByType<RopeAnchor>((FindObjectsSortMode)0), (Action<RopeAnchor, WorldObjectSnapshot>)delegate(RopeAnchor component, WorldObjectSnapshot snapshot)
			{
				ApplyTransformSnapshot(((Component)component).transform, snapshot.position, snapshot.rotation);
				component.Ghost = snapshot.boolA;
			}, removeExtras: true);
			RestoreWorldObjectType<Rope>(snapshots, "Rope", Object.FindObjectsByType<Rope>((FindObjectsSortMode)0), (Action<Rope, WorldObjectSnapshot>)delegate(Rope component, WorldObjectSnapshot snapshot)
			{
				ApplyTransformSnapshot(((Component)component).transform, snapshot.position, snapshot.rotation);
				component.antigrav = snapshot.boolA;
				if (snapshot.floatA > 0f)
				{
					component.Segments = snapshot.floatA;
				}
			}, removeExtras: true);
			RestoreWorldObjectType<RopeAnchorWithRope>(snapshots, "RopeAnchorWithRope", Object.FindObjectsByType<RopeAnchorWithRope>((FindObjectsSortMode)0), (Action<RopeAnchorWithRope, WorldObjectSnapshot>)delegate(RopeAnchorWithRope component, WorldObjectSnapshot snapshot)
			{
				ApplyTransformSnapshot(((Component)component).transform, snapshot.position, snapshot.rotation);
				if (snapshot.floatA > 0f)
				{
					component.ropeSegmentLength = snapshot.floatA;
				}
				if (snapshot.boolA && (Object)(object)component.ropeInstance == (Object)null)
				{
					component.SpawnRope();
				}
			}, removeExtras: true);
			RestoreWorldObjectType<ScoutCannon>(snapshots, "ScoutCannon", Object.FindObjectsByType<ScoutCannon>((FindObjectsSortMode)0), (Action<ScoutCannon, WorldObjectSnapshot>)delegate(ScoutCannon component, WorldObjectSnapshot snapshot)
			{
				ApplyTransformSnapshot(((Component)component).transform, snapshot.position, snapshot.rotation);
				if (snapshot.boolA && !component.lit)
				{
					component.RPCA_Light();
				}
			}, removeExtras: true);
			RestoreWorldObjectType<Campfire>(snapshots, "PortableStove", FindNonSegmentCampfires(), (Action<Campfire, WorldObjectSnapshot>)delegate(Campfire component, WorldObjectSnapshot snapshot)
			{
				//IL_0029: Unknown result type (might be due to invalid IL or missing references)
				//IL_002b: 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_0047: Unknown result type (might be due to invalid IL or missing references)
				//IL_0059: Expected I4, but got Unknown
				ApplyTransformSnapshot(((Component)component).transform, snapshot.position, snapshot.rotation);
				FireState val = (component.state = (FireState)Mathf.Clamp(Mathf.RoundToInt(snapshot.floatA), 0, 2));
				component.beenBurningFor = Mathf.Max(0f, snapshot.floatB);
				switch ((int)val)
				{
				case 0:
					if ((Object)(object)component.fireParticles != (Object)null)
					{
						component.fireParticles.Stop();
					}
					if ((Object)(object)component.smokeParticlesLit != (Object)null)
					{
						component.smokeParticlesLit.Stop();
					}
					if ((Object)(object)component.smokeParticlesOff != (Object)null)
					{
						component.smokeParticlesOff.Play();
					}
					break;
				case 1:
					if ((Object)(object)component.fireParticles != (Object)null)
					{
						component.fireParticles.Play();
					}
					if ((Object)(object)component.smokeParticlesOff != (Object)null)
					{
						component.smokeParticlesOff.Stop();
					}
					if ((Object)(object)component.smokeParticlesLit != (Object)null)
					{
						component.smokeParticlesLit.Play();
					}
					break;
				case 2:
					if ((Object)(object)component.fireParticles != (Object)null)
					{
						component.fireParticles.Stop();
					}
					if ((Object)(object)component.smokeParticlesOff != (Object)null)
					{
						component.smokeParticlesOff.Stop();
					}
					if ((Object)(object)component.smokeParticlesLit != (Object)null)
					{
						component.smokeParticlesLit.Stop();
					}
					CampfireHideLogsMethod?.Invoke(component, null);
					break;
				}
				CampfireUpdateLitMethod?.Invoke(component, null);
			}, removeExtras: true);
			RestoreWorldObjectType<MagicBeanVine>(snapshots, "MagicBeanVine", Object.FindObjectsByType<MagicBeanVine>((FindObjectsSortMode)0), (Action<MagicBeanVine, WorldObjectSnapshot>)delegate(MagicBeanVine component, WorldObjectSnapshot snapshot)
			{
				ApplyTransformSnapshot(((Component)component).transform, snapshot.position, snapshot.rotation);
				if (snapshot.floatA > 0f)
				{
					float num = Mathf.Max(0f, GetMagicBeanVineInitialLength(component));
					float num2 = GetMagicBeanVineMaxLength(component);
					if (num2 <= 0f)
					{
						num2 = snapshot.floatA;
					}
					SetMagicBeanVineCurrentLength(component, Mathf.Clamp(snapshot.floatA, num, num2));
				}
			}, removeExtras: true);
			RestoreWorldObjectType<CloudFungus>(snapshots, "CloudFungus", Object.FindObjectsByType<CloudFungus>((FindObjectsSortMode)0), (Action<CloudFungus, WorldObjectSnapshot>)delegate(CloudFungus component, WorldObjectSnapshot snapshot)
			{
				ApplyTransformSnapshot(((Component)component).transform, snapshot.position, snapshot.rotation);
				SetCloudFungusAlreadyBroke(component, snapshot.boolA);
				SetCloudFungusTimeAlive(component, Mathf.Max(0f, snapshot.floatA));
			}, removeExtras: true);
			RestoreWorldObjectType<CheckpointFlag>(snapshots, "CheckpointFlag", Object.FindObjectsByType<CheckpointFlag>((FindObjectsSortMode)0), (Action<CheckpointFlag, WorldObjectSnapshot>)delegate(CheckpointFlag component, WorldObjectSnapshot snapshot)
			{
				ApplyCheckpointFlagSnapshot(component, snapshot);
			}, removeExtras: true);
			RestoreWorldObjectType<CheckpointConstructable>(snapshots, "CheckpointConstructable", Object.FindObjectsByType<CheckpointConstructable>((FindObjectsSortMode)0), (Action<CheckpointConstructable, WorldObjectSnapshot>)delegate(CheckpointConstructable component, WorldObjectSnapshot snapshot)
			{
				ApplyTransformSnapshot(((Component)component).transform, snapshot.position, snapshot.rotation);
			}, removeExtras: true);
			RestoreWorldObjectType<WobbleSpinBounce>(snapshots, "BounceFungus", FindBounceFungusObjects(), (Action<WobbleSpinBounce, WorldObjectSnapshot>)delegate(WobbleSpinBounce component, WorldObjectSnapshot snapshot)
			{
				ApplyTransformSnapshot(((Component)component).transform, snapshot.position, snapshot.rotation);
			}, removeExtras: true);
			if (formatVersion >= 5)
			{
				RestoreWorldObjectType<ShelfShroom>(snapshots, "ShelfShroom", Object.FindObjectsByType<ShelfShroom>((FindObjectsSortMode)0), (Action<ShelfShroom, WorldObjectSnapshot>)delegate(ShelfShroom component, WorldObjectSnapshot snapshot)
				{
					ApplyTransformSnapshot(((Component)component).transform, snapshot.position, snapshot.rotation);
				}, removeExtras: true);
			}
			RopeShooter[] candidates = Object.FindObjectsByType<RopeShooter>((FindObjectsSortMode)0).Where(IsGroundRopeShooterCandidate).ToArray();
			RestoreWorldObjectType<RopeShooter>(snapshots, "ChainLauncher", candidates, (Action<RopeShooter, WorldObjectSnapshot>)delegate(RopeShooter component, WorldObjectSnapshot snapshot)
			{
				ApplyTransformSnapshot(((Component)component).transform, snapshot.position, snapshot.rotation);
				int ammo = ((snapshot.floatA > 0f) ? Mathf.Max(0, Mathf.RoundToInt(snapshot.floatA)) : (snapshot.boolA ? 1 : 0));
				SetChainLauncherAmmo(component, ammo);
			}, removeExtras: true);
		}

		private static void RestoreShelfShrooms(List<WorldObjectSnapshot> snapshots, bool hasShelfSnapshotSupport)
		{
			if (!hasShelfSnapshotSupport)
			{
				return;
			}
			List<WorldObjectSnapshot> list = snapshots.Where((WorldObjectSnapshot snapshot) => snapshot != null && string.Equals(snapshot.kind, "ShelfShroom", StringComparison.OrdinalIgnoreCase)).ToList();
			List<ShelfShroom> list2 = (from component in Object.FindObjectsByType<ShelfShroom>((FindObjectsSortMode)0)
				where (Object)(object)component != (Object)null
				select component).ToList();
			for (int i = 0; i < list.Count; i++)
			{
				WorldObjectSnapshot worldObjectSnapshot = list[i];
				ShelfShroom val = FindWorldObjectForSnapshot<ShelfShroom>(worldObjectSnapshot, list2, 16f);
				if (!((Object)(object)val == (Object)null))
				{
					list2.Remove(val);
					ApplyTransformSnapshot(((Component)val).transform, worldObjectSnapshot.position, worldObjectSnapshot.rotation);
				}
			}
			for (int j = 0; j < list2.Count; j++)
			{
				ShelfShroom val2 = list2[j];
				if ((Object)(object)val2 == (Object)null)
				{
					continue;
				}
				try
				{
					GameObject gameObject = ((Component)val2).gameObject;
					if (!PhotonNetwork.InRoom)
					{
						goto IL_0101;
					}
					PhotonView component2 = gameObject.GetComponent<PhotonView>();
					if (!((Object)(object)component2 != (Object)null) || component2.ViewID <= 0)
					{
						goto IL_0101;
					}
					PhotonNetwork.Destroy(gameObject);
					goto end_IL_00cb;
					IL_0101:
					Object.Destroy((Object)(object)gameObject);
					end_IL_00cb:;
				}
				catch
				{
				}
			}
		}

		private void RestoreWorldObjectType<T>(List<WorldObjectSnapshot> snapshots, string kind, T[] candidates, Action<T, WorldObjectSnapshot> applySnapshot, bool removeExtras = true) where T : Component
		{
			if (snapshots == null || applySnapshot == null)
			{
				return;
			}
			List<T> list = ((candidates != null) ? new List<T>(candidates.Where((T c) => (Object)(object)c != (Object)null)) : new List<T>());
			for (int i = 0; i < snapshots.Count; i++)
			{
				WorldObjectSnapshot worldObjectSnapshot = snapshots[i];
				if (worldObjectSnapshot != null && string.Equals(worldObjectSnapshot.kind, kind, StringComparison.OrdinalIgnoreCase))
				{
					T val = FindWorldObjectForSnapshot(worldObjectSnapshot, list, 16f);
					if ((Object)(object)val == (Object)null)
					{
						val = TrySpawnWorldObjectFromSnapshot<T>(worldObjectSnapshot);
					}
					if (!((Object)(object)val == (Object)null))
					{
						list.Remove(val);
						applySnapshot(val, worldObjectSnapshot);
					}
				}
			}
			if (removeExtras)
			{
				DestroyExtraTrackedObjects(list);
			}
		}

		private static void DestroyExtraTrackedObjects<T>(List<T> remainingCandidates) where T : Component
		{
			if (remainingCandidates == null || remainingCandidates.Count == 0)
			{
				return;
			}
			for (int i = 0; i < remainingCandidates.Count; i++)
			{
				T val = remainingCandidates[i];
				if (!((Object)(object)val == (Object)null))
				{
					TryDestroyTrackedComponent((Component)(object)val);
				}
			}
		}

		private static void TryDestroyTrackedComponent(Component component)
		{
			if ((Object)(object)component == (Object)null)
			{
				return;
			}
			try
			{
				GameObject gameObject = component.gameObject;
				if (PhotonNetwork.InRoom)
				{
					PhotonView component2 = gameObject.GetComponent<PhotonView>();
					if ((Object)(object)component2 != (Object)null && component2.ViewID > 0)
					{
						PhotonNetwork.Destroy(gameObject);
						return;
					}
				}
				Object.Destroy((Object)(object)gameObject);
			}
			catch
			{
			}
		}

		private void ApplyCheckpointFlagSnapshot(CheckpointFlag flag, WorldObjectSnapshot snapshot)
		{
			if ((Object)(object)flag == (Object)null || snapshot == null)
			{
				return;
			}
			ApplyTransformSnapshot(((Component)flag).transform, snapshot.position, snapshot.rotation);
			if (snapshot.floatListA != null && snapshot.floatListA.Count > 0)
			{
				float[] array = new float[snapshot.floatListA.Count];
				for (int i = 0; i < snapshot.floatListA.Count; i++)
				{
					array[i] = Mathf.Max(0f, snapshot.floatListA[i]);
				}
				SetCheckpointStatuses(flag, array);
			}
			Character val = FindCheckpointOwner(snapshot);
			if ((Object)(object)val != (Object)null)
			{
				SetCheckpointPlanter(flag, val);
			}
		}

		private Character FindCheckpointOwner(WorldObjectSnapshot snapshot)
		{
			if (snapshot == null)
			{
				return null;
			}
			Player[] array = Object.FindObjectsByType<Player>((FindObjectsSortMode)0);
			if (array == null || array.Length == 0)
			{
				return null;
			}
			foreach (Player val in array)
			{
				if (!((Object)(object)val == (Object)null) && !((Object)(object)val.character == (Object)null))
				{
					PhotonView val2 = GetPhotonView((Component)(object)val.character) ?? GetPhotonView((Component)(object)val);
					Player val3 = (((Object)(object)val2 != (Object)null) ? val2.Owner : null);
					if (snapshot.intA > 0 && val3 != null && val3.ActorNumber == snapshot.intA)
					{
						return val.character;
					}
				}
			}
			if (!string.IsNullOrWhiteSpace(snapshot.stringA))
			{
				foreach (Player val4 in array)
				{
					if (!((Object)(object)val4 == (Object)null) && !((Object)(object)val4.character == (Object)null))
					{
						PhotonView val5 = GetPhotonView((Component)(object)val4.character) ?? GetPhotonView((Component)(object)val4);
						Player val6 = (((Object)(object)val5 != (Object)null) ? val5.Owner : null);
						if (val6 != null && string.Equals(val6.NickName, snapshot.stringA, StringComparison.OrdinalIgnoreCase))
						{
							return val4.character;
						}
					}
				}
			}
			if (!string.IsNullOrWhiteSpace(snapshot.stringB))
			{
				foreach (Player val7 in array)
				{
					if (!((Object)(object)val7 == (Object)null) && !((Object)(object)val7.character == (Object)null) && string.Equals(BuildTransformPath(((Component)val7.character).transform), snapshot.stringB, StringComparison.OrdinalIgnoreCase))
					{
						return val7.character;
					}
				}
			}
			return null;
		}

		private static T FindWorldObjectForSnapshot<T>(WorldObjectSnapshot snapshot, List<T> candidates, float maxDistanceSquared) where T : Component
		{
			//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_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			if (snapshot == null || candidates == null || candidates.Count == 0)
			{
				return default(T);
			}
			if (!string.IsNullOrWhiteSpace(snapshot.objectPath))
			{
				for (int i = 0; i < candidates.Count; i++)
				{
					T val = candidates[i];
					if (!((Object)(object)val == (Object)null) && string.Equals(BuildTransformPath(((Component)val).transform), snapshot.objectPath, StringComparison.OrdinalIgnoreCase))
					{
						return val;
					}
				}
			}
			T result = default(T);
			float num = maxDistanceSquared;
			Vector3 val2 = snapshot.position.ToUnity();
			string text = NormalizeObjectName(snapshot.objectName);
			for (int j = 0; j < candidates.Count; j++)
			{
				T val3 = candidates[j];
				if (!((Object)(object)val3 == (Object)null) && (string.IsNullOrWhiteSpace(text) || string.Equals(NormalizeObjectName(((Object)(object)val3).name), text, StringComparison.OrdinalIgnoreCase)))
				{
					Vector3 val4 = ((Component)val3).transform.position - val2;
					float sqrMagnitude = ((Vector3)(ref val4)).sqrMagnitude;
					if (sqrMagnitude <= num)
					{
						num = sqrMagnitude;
						result = val3;
					}
				}
			}
			return result;
		}

		private static T TrySpawnWorldObjectFromSnapshot<T>(WorldObjectSnapshot snapshot) where T : Component
		{
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			//IL_0057: 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_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			if (snapshot == null || !PhotonNetwork.InRoom || !PhotonNetwork.IsMasterClient)
			{
				return default(T);
			}
			string text = NormalizeObjectName(snapshot.objectName);
			if (string.IsNullOrWhiteSpace(text))
			{
				return default(T);
			}
			Vector3 val = snapshot.position.ToUnity();
			Quaternion val2 = Quaternion.Euler(snapshot.rotation.ToUnity());
			string[] array = new string[2]
			{
				"0_Items/" + text,
				text
			};
			for (int i = 0; i < array.Length; i++)
			{
				try
				{
					GameObject val3 = PhotonNetwork.Instantiate(array[i], val, val2, (byte)0, (object[])null);
					if (!((Object)(object)val3 == (Object)null))
					{
						T component = val3.GetComponent<T>();
						if ((Object)(object)component != (Object)null)
						{
							return component;
						}
					}
				}
				catch
				{
				}
			}
			GameObject val4 = FindLoadedPrefabForComponent<T>(text);
			if ((Object)(object)val4 != (Object)null)
			{
				GameObject val5 = Object.Instantiate<GameObject>(val4, val, val2);
				if ((Object)(object)val5 != (Object)null)
				{
					T component2 = val5.GetComponent<T>();
					if ((Object)(object)component2 != (Object)null)
					{
						return component2;
					}
				}
			}
			return default(T);
		}

		private static void ApplyTransformSnapshot(Transform transform, Vector3Snapshot position, Vector3Snapshot rotation)
		{
			//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)
			if (!((Object)(object)transform == (Object)null) && position != null && rotation != null)
			{
				transform.position = position.ToUnity();
				transform.eulerAngles = rotation.ToUnity();
			}
		}

		private static GameObject FindLoadedPrefabForComponent<T>(string prefabName) where T : Component
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			if (string.IsNullOrWhiteSpace(prefabName))
			{
				return null;
			}
			string text = NormalizeObjectName(prefabName);
			GameObject val = null;
			GameObject val2 = null;
			GameObject[] array = Resources.FindObjectsOfTypeAll<GameObject>();
			foreach (GameObject val3 in array)
			{
				if ((Object)(object)val3 == (Object)null)
				{
					continue;
				}
				Scene scene = val3.scene;
				if (!((Scene)(ref scene)).IsValid() && !((Object)(object)val3.GetComponent<T>() == (Object)null))
				{
					string text2 = NormalizeObjectName(((Object)val3).name);
					if (string.Equals(text2, text, StringComparison.OrdinalIgnoreCase))
					{
						val = val3;
						break;
					}
					if ((Object)(object)val2 == (Object)null && (text2.IndexOf(text, StringComparison.OrdinalIgnoreCase) >= 0 || text.IndexOf(text2, StringComparison.OrdinalIgnoreCase) >= 0))
					{
						val2 = val3;
					}
				}
			}
			return val ?? val2;
		}

		private static bool TryGetBackpackData(Player player, out BackpackData backpackData)
		{
			backpackData = null;
			if ((Object)(object)player == (Object)null)
			{
				return false;
			}
			ItemInstanceData backpackSlotInstanceData = GetBackpackSlotInstanceData(player);
			if (backpackSlotInstanceData == null || backpackSlotInstanceData.data == null)
			{
				return false;
			}
			if (!backpackSlotInstanceData.data.TryGetValue((DataEntryKey)7, out var value))
			{
				return false;
			}
			backpackData = (BackpackData)(object)((value is BackpackData) ? value : null);
			return backpackData != null;
		}

		private static ItemInstanceData GetBackpackSlotInstanceData(Player player)
		{
			if ((Object)(object)player == (Object)null || player.backpackSlot == null)
			{
				return null;
			}
			ItemSlot backpackSlot = (ItemSlot)(object)player.backpackSlot;
			if (backpackSlot != null)
			{
				return backpackSlot.data;
			}
			object backpackSlot2 = player.backpackSlot;
			Type type = backpackSlot2.GetType();
			PropertyInfo property = type.GetProperty("data", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			if (property != null && typeof(ItemInstanceData).IsAssignableFrom(property.PropertyType))
			{
				try
				{
					object? value = property.GetValue(backpackSlot2, null);
					return (ItemInstanceData)((value is ItemInstanceData) ? value : null);
				}
				catch
				{
				}
			}
			FieldInfo field = type.GetField("data", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			if (field != null && typeof(ItemInstanceData).IsAssignableFrom(field.FieldType))
			{
				try
				{
					object? value2 = field.GetValue(backpackSlot2);
					return (ItemInstanceData)((value2 is ItemInstanceData) ? value2 : null);
				}
				catch
				{
				}
			}
			return null;
		}

		private static bool SetBackpackSlotInstanceData(Player player, ItemInstanceData instanceData)
		{
			if ((Object)(object)player == (Object)null || player.backpackSlot == null)
			{
				return false;
			}
			ItemSlot backpackSlot = (ItemSlot)(object)player.backpackSlot;
			if (backpackSlot != null)
			{
				backpackSlot.data = instanceData;
				return true;
			}
			object backpackSlot2 = player.backpackSlot;
			Type type = backpackSlot2.GetType();
			PropertyInfo property = type.GetProperty("data", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			if (property != null && property.CanWrite && typeof(ItemInstanceData).IsAssignableFrom(property.PropertyType))
			{
				try
				{
					property.SetValue(backpackSlot2, instanceData, null);
					return true;
				}
				catch
				{
				}
			}
			FieldInfo field = type.GetField("data", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			if (field != null && typeof(ItemInstanceData).IsAssignableFrom(field.FieldType))
			{
				try
				{
					field.SetValue(backpackSlot2, instanceData);
					return true;
				}
				catch
				{
				}
			}
			return false;
		}

		private static void ClearBackpackSlot(Player player)
		{
			if ((Object)(object)player == (Object)null || player.backpackSlot == null)
			{
				return;
			}
			ItemSlot backpackSlot = (ItemSlot)(object)player.backpackSlot;
			if (backpackSlot != null)
			{
				backpackSlot.EmptyOut();
				return;
			}
			object backpackSlot2 = player.backpackSlot;
			MethodInfo method = backpackSlot2.GetType().GetMethod("EmptyOut", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, Type.EmptyTypes, null);
			if (method != null)
			{
				try
				{
					method.Invoke(backpackSlot2, null);
					return;
				}
				catch
				{
				}
			}
			SetBackpackSlotInstanceData(player, null);
		}

		private Player FindPlayer(PlayerSnapshot snapshot)
		{
			Player[] source = Object.FindObjectsByType<Player>((FindObjectsSortMode)0);
			if (snapshot.actorNumber > 0)
			{
				Player val = ((IEnumerable<Player>)source).FirstOrDefault((Func<Player, bool>)delegate(Player p)
				{
					PhotonView photonView2 = GetPhotonView((Component)(object)p);
					Player val3 = (((Object)(object)photonView2 != (Object)null) ? photonView2.Owner : null);
					return val3 != null && val3.ActorNumber == snapshot.actorNumber;
				});
				if ((Object)(object)val != (Object)null)
				{
					return val;
				}
			}
			return ((IEnumerable<Player>)source).FirstOrDefault((Func<Player, bool>)delegate(Player p)
			{
				PhotonView photonView = GetPhotonView((Component)(object)p);
				Player val2 = (((Object)(object)photonView != (Object)null) ? photonView.Owner : null);
				return val2 != null && string.Equals(val2.NickName, snapshot.playerName, StringComparison.OrdinalIgnoreCase);
			});
		}

		private void RefreshSaveFileList()
		{
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			saveEntries.Clear();
			try
			{
				if (!EnsureSaveDirectoryReady(showStatus: false))
				{
					return;
				}
				foreach (FileInfo item in from file in new DirectoryInfo(saveDirectory).GetFiles("*.json", SearchOption.TopDirectoryOnly)
					orderby file.LastWriteTimeUtc descending
					select file)
				{
					saveEntries.Add(BuildSaveListEntry(item));
				}
			}
			catch (Exception ex)
			{
				((BaseUnityPlugin)this).Logger.LogError((object)$"Failed to refresh save file list: {ex}");
				SetStatus(BuildSaveFailureStatus(ex), Color.red, 6f);
			}
		}

		private SaveListEntry BuildSaveListEntry(FileInfo fileInfo)
		{
			SaveListEntry saveListEntry = new SaveListEntry
			{
				fileName = fileInfo.Name,
				fullPath = fileInfo.FullName,
				fileTime = fileInfo.LastWriteTime,
				fileSize = fileInfo.Length,
				isCompatible = false,
				incompatibilityReason = "Unknown format"
			};
			try
			{
				JObject val = JObject.Parse(File.ReadAllText(fileInfo.FullName));
				JToken obj = val["magic"];
				if (!string.Equals((obj != null) ? Extensions.Value<string>((IEnumerable<JToken>)obj) : null, "PEAK_SAVE_MANAGER", StringComparison.Ordinal))
				{
					if (val["names"] != null && val["posX"] != null)
					{
						saveListEntry.incompatibilityReason = "Legacy save format (old/other plugin)";
					}
					else
					{
						saveListEntry.incompatibilityReason = "Not a PEAK Save Manager file";
					}
					return saveListEntry;
				}
				JToken obj2 = val["formatVersion"];
				int num = ((obj2 != null) ? Extensions.Value<int>((IEnumerable<JToken>)obj2) : (-1));
				if (num < 1 || num > 6)
				{
					saveListEntry.incompatibilityReason = $"Unsupported format version: {num}";
					return saveListEntry;
				}
				SaveEnvelope saveEnvelope = ((JToken)val).ToObject<SaveEnvelope>();
				if (saveEnvelope == null || saveEnvelope.metadata == null || saveEnvelope.players == null)
				{
					saveListEntry.incompatibilityReason = "Missing required save data";
					return saveListEntry;
				}
				if (saveEnvelope.players.Count == 0)
				{
					saveListEntry.incompatibilityReason = "Save has no player snapshots";
					return saveListEntry;
				}
				saveListEntry.isCompatible = true;
				saveListEntry.incompatibilityReason = null;
				saveListEntry.metadata = saveEnvelope.metadata;
				saveListEntry.metadata.currentSegmentName = NormalizeSegmentName(saveListEntry.metadata.currentSegmentName);
				if (string.IsNullOrWhiteSpace(saveListEntry.metadata.saveName))
				{
					string name = fileInfo.Name;
					name = ((!name.EndsWith(".peaksave.json", StringComparison.OrdinalIgnoreCase)) ? Path.GetFileNameWithoutExtension(name) : name.Substring(0, name.Length - ".peaksave.json".Length));
					saveListEntry.metadata.saveName = name;
				}
				if (saveListEntry.metadata.playerCount <= 0)
				{
					saveListEntry.metadata.playerCount = saveEnvelope.players.Count;
				}
				if (!saveListEntry.metadata.levelNumber.HasValue)
				{
					saveListEntry.metadata.levelNumber = ParseLevelNumber(saveListEntry.metadata.levelName);
				}
			}
			catch (Exception ex)
			{
				saveListEntry.incompatibilityReason = "Corrupted JSON: " + ex.GetType().Name;
			}
			return saveListEntry;
		}

		private static bool TryReadSaveEnvelope(string fullPath, out SaveEnvelope envelope, out string reason)
		{
			envelope = null;
			reason = string.Empty;
			if (!File.Exists(fullPath))
			{
				reason = "File not found";
				return false;
			}
			try
			{
				JObject val = JObject.Parse(File.ReadAllText(fullPath));
				JToken obj = val["magic"];
				if (!string.Equals((obj != null) ? Extensions.Value<string>((IEnumerable<JToken>)obj) : null, "PEAK_SAVE_MANAGER", StringComparison.Ordinal))
				{
					reason = "Wrong save format";
					return false;
				}
				JToken obj2 = val["formatVersion"];
				int num = ((obj2 != null) ? Extensions.Value<int>((IEnumerable<JToken>)obj2) : (-1));
				if (num < 1 || num > 6)
				{
					reason = $"Unsupported save format version {num}";
					return false;
				}
				envelope = ((JToken)val).ToObject<SaveEnvelope>();
				if (envelope == null || envelope.metadata == null || envelope.players == null)
				{
					reason = "Missing required save sections";
					return false;
				}
				if (envelope.players.Count == 0)
				{
					reason = "Save has no player snapshots";
					return false;
				}
				SaveEnvelope saveEnvelope = envelope;
				if (saveEnvelope.campfires == null)
				{
					saveEnvelope.campfires = new List<CampfireSnapshot>();
				}
				saveEnvelope = envelope;
				if (saveEnvelope.luggageStates == null)
				{
					saveEnvelope.luggageStates = new List<LuggageSnapshot>();
				}
				saveEnvelope = envelope;
				if (saveEnvelope.containerStates == null)
				{
					saveEnvelope.containerStates = new List<ContainerSnapshot>();
				}
				saveEnvelope = envelope;
				if (saveEnvelope.groundItems == null)
				{
					saveEnvelope.groundItems = new List<GroundItemSnapshot>();
				}
				saveEnvelope = envelope;
				if (saveEnvelope.worldObjects == null)
				{
					saveEnvelope.worldObjects = new List<WorldObjectSnapshot>();
				}
				envelope.metadata.currentSegmentName = NormalizeSegmentName(envelope.metadata.currentSegmentName);
				for (int i = 0; i < envelope.players.Count; i++)
				{
					PlayerSnapshot playerSnapshot = envelope.players[i];
					if (playerSnapshot != null)
					{
						PlayerSnapshot playerSnapshot2 = playerSnapshot;
						if (playerSnapshot2.velocity == null)
						{
							playerSnapshot2.velocity = new Vector3Snapshot();
						}
						playerSnapshot2 = playerSnapshot;
						if (playerSnapshot2.angularVelocity == null)
						{
							playerSnapshot2.angularVelocity = new Vector3Snapshot();
						}
						playerSnapshot2 = playerSnapshot;
						if (playerSnapshot2.character == null)
						{
							playerSnapshot2.character = new CharacterSnapshot();
						}
						CharacterSnapshot character = playerSnapshot.character;
						if (character.checkpointFlagPaths == null)
						{
							character.checkpointFlagPaths = new List<string>();
						}
						character = playerSnapshot.character;
						if (character.statuses == null)
						{
							character.statuses = new List<CharacterStatusSnapshot>();
						}
						playerSnapshot2 = playerSnapshot;
						if (playerSnapshot2.inventory == null)
						{
							playerSnapshot2.inventory = new InventorySnapshot();
						}
						InventorySnapshot inventory = playerSnapshot.inventory;
						if (inventory.mainSlots == null)
						{
							inventory.mainSlots = new List<ItemSlotSnapshot>();
						}
						inventory = playerSnapshot.inventory;
						if (inventory.backpackSlots == null)
						{
							inventory.backpackSlots = new List<ItemSlotSnapshot>();
						}
						inventory = playerSnapshot.inventory;
						if (inventory.tempSlot == null)
						{
							inventory.tempSlot = ItemSlotSnapshot.Empty();
						}
						NormalizeSlotData(playerSnapshot.inventory.tempSlot);
						for (int j = 0; j < playerSnapshot.inventory.mainSlots.Count; j++)
						{
							NormalizeSlotData(playerSnapshot.inventory.mainSlots[j]);
						}
						for (int k = 0; k < playerSnapshot.inventory.backpackSlots.Count; k++)
						{
							NormalizeSlotData(playerSnapshot.inventory.backpackSlots[k]);
						}
					}
				}
				for (int l = 0; l < envelope.groundItems.Count; l++)
				{
					GroundItemSnapshot groundItemSnapshot = envelope.groundItems[l];
					if (groundItemSnapshot != null)
					{
						GroundItemSnapshot groundItemSnapshot2 = groundItemSnapshot;
						if (groundItemSnapshot2.velocity == null)
						{
							groundItemSnapshot2.velocity = new Vector3Snapshot();
						}
						groundItemSnapshot2 = groundItemSnapshot;
						if (groundItemSnapshot2.angularVelocity == null)
						{
							groundItemSnapshot2.angularVelocity = new Vector3Snapshot();
						}
						groundItemSnapshot2 = groundItemSnapshot;
						if (groundItemSnapshot2.dataEntries == null)
						{
							groundItemSnapshot2.dataEntries = new List<ItemDataEntrySnapshot>();
						}
					}
				}
				for (int m = 0; m < envelope.containerStates.Count; m++)
				{
					ContainerSnapshot containerSnapshot = envelope.containerStates[m];
					if (containerSnapshot != null)
					{
						ContainerSnapshot containerSnapshot2 = containerSnapshot;
						if (containerSnapshot2.position == null)
						{
							containerSnapshot2.position = new Vector3Snapshot();
						}
					}
				}
				for (int n = 0; n < envelope.luggageStates.Count; n++)
				{
					LuggageSnapshot luggageSnapshot = envelope.luggageStates[n];
					if (luggageSnapshot != null)
					{
						LuggageSnapshot luggageSnapshot2 = luggageSnapshot;
						if (luggageSnapshot2.position == null)
						{
							luggageSnapshot2.position = new Vector3Snapshot();
						}
					}
				}
				for (int num2 = 0; num2 < envelope.worldObjects.Count; num2++)
				{
					WorldObjectSnapshot worldObjectSnapshot = envelope.worldObjects[num2];
					if (worldObjectSnapshot != null)
					{
						WorldObjectSnapshot worldObjectSnapshot2 = worldObjectSnapshot;
						if (worldObjectSnapshot2.floatListA == null)
						{
							worldObjectSnapshot2.floatListA = new List<float>();
						}
					}
				}
				return true;
			}
			catch (JsonException)
			{
				reason = "Corrupted JSON";
				return false;
			}
			catch (Exception ex)
			{
				reason = ex.GetType().Name;
				return false;
			}
		}

		private static void NormalizeSlotData(ItemSlotSnapshot snapshot)
		{
			if (snapshot != null)
			{
				if (snapshot.dataEntries == null)
				{
					snapshot.dataEntries = new List<ItemDataEntrySnapshot>();
				}
			}
		}

		private void TryDeleteSave(string fullPath)
		{
			//IL_0012: 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)
			try
			{
				File.Delete(fullPath);
				RefreshSaveFileList();
				SetStatus("Deleted save file.", Color.yellow, 2.5f);
			}
			catch (Exception arg)
			{
				((BaseUnityPlugin)this).Logger.LogError((object)$"Failed to delete save file '{fullPath}': {arg}");
				SetStatus("Delete failed.", Color.red, 3f);
			}
		}

		private static string ResolveTargetScene(SaveMetadata metadata)
		{
			//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 (metadata == null)
			{
				return string.Empty;
			}
			Scene activeScene = SceneManager.GetActiveScene();
			string name = ((Scene)(ref activeScene)).name;
			HashSet<string> hashSet = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
			AddSceneCandidate(hashSet, metadata.levelName);
			if (metadata.levelNumber.HasValue)
			{
				AddSceneCandidate(hashSet, $"Level_{metadata.levelNumber.Value}");
			}
			if (metadata.dailyLevelIndex.HasValue)
			{
				try
				{
					string level = SingletonAsset<MapBaker>.Instance.GetLevel(metadata.dailyLevelIndex.Value + NextLevelService.debugLevelIndexOffset);
					AddSceneCandidate(hashSet, level);
				}
				catch
				{
				}
			}
			AddSceneCandidate(hashSet, metadata.sceneName);
			foreach (string item in hashSet)
			{
				if (CanUseSceneCandidate(item, name))
				{
					return item;
				}
			}
			return string.Empty;
		}

		private static bool SaveNeedsNonAirportScene(SaveMetadata metadata)
		{
			if (metadata == null)
			{
				return false;
			}
			if (metadata.levelNumber.HasValue && metadata.levelNumber.Value > 0)
			{
				return true;
			}
			if (!string.IsNullOrWhiteSpace(metadata.levelName) && !metadata.levelName.Equals("Airport", StringComparison.OrdinalIgnoreCase))
			{
				return true;
			}
			if (!string.IsNullOrWhiteSpace(metadata.sceneName) && !metadata.sceneName.Equals("Airport", StringComparison.OrdinalIgnoreCase))
			{
				return true;
			}
			return metadata.currentSegment > 0;
		}

		private static void AddSceneCandidate(HashSet<string> output, string sceneName)
		{
			if (!string.IsNullOrWhiteSpace(sceneName) && !sceneName.Equals("Airport", StringComparison.OrdinalIgnoreCase))
			{
				output.Add(sceneName);
			}
		}

		private static bool CanUseSceneCandidate(string sceneName, string activeScene)
		{
			if (string.IsNullOrWhiteSpace(sceneName))
			{
				return false;
			}
			if (string.Equals(sceneName, activeScene, StringComparison.OrdinalIgnoreCase))
			{
				return true;
			}
			return Application.CanStreamedLevelBeLoaded(sceneName);
		}

		private static bool IsInAirportScene()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			Scene activeScene = SceneManager.GetActiveScene();
			return string.Equals(((Scene)(ref activeScene)).name, "Airport", StringComparison.OrdinalIgnoreCase);
		}

		private static string ResolveLevelName(string sceneName, int? dailyLevelIndex)
		{
			if (!string.IsNullOrWhiteSpace(sceneName) && sceneName.StartsWith("Level_", StringComparison.OrdinalIgnoreCase))
			{
				return sceneName;
			}
			if (!dailyLevelIndex.HasValue)
			{
				return sceneName;
			}
			try
			{
				return SingletonAsset<MapBaker>.Instance.GetLevel(dailyLevelIndex.Value + NextLevelService.debugLevelIndexOffset);
			}
			catch
			{
				return sceneName;
			}
		}

		private static int? ParseLevelNumber(string sceneOrLevelName)
		{
			if (string.IsNullOrWhiteSpace(sceneOrLevelName))
			{
				return null;
			}
			if (!sceneOrLevelName.StartsWith("Level_", StringComparison.OrdinalIgnoreCase))
			{
				return null;
			}
			if (int.TryParse(sceneOrLevelName.Substring("Level_".Length), NumberStyles.Integer, CultureInfo.InvariantCulture, out var result))
			{
				return result;
			}
			return null;
		}

		private static Segment ClampSegment(int raw)
		{
			if (raw >= 0)
			{
				if (raw <= 5)
				{
					return (Segment)(byte)raw;
				}
				return (Segment)5;
			}
			return (Segment)0;
		}

		private static Vector3 GetCharacterPosition(Character character)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)character == (Object)null)
			{
				return Vector3.zero;
			}
			if (character.Center != Vector3.zero)
			{
				return character.Center;
			}
			if (character.refs != null && (Object)(object)character.refs.hip != (Object)null && (Object)(object)character.refs.hip.Rig != (Object)null)
			{
				return character.refs.hip.Rig.position;
			}
			return ((Component)character).transform.position;
		}

		private static string SanitizeFileName(string value)
		{
			string text = (string.IsNullOrWhiteSpace(value) ? "save" : value.Trim());
			char[] invalidFileNameChars = Path.GetInvalidFileNameChars();
			foreach (char oldChar in invalidFileNameChars)
			{
				text = text.Replace(oldChar, '_');
			}
			return text;
		}

		private static string BuildTransformPath(Transform transform)
		{
			if ((Object)(object)transform == (Object)null)
			{
				return string.Empty;
			}
			StringBuilder stringBuilder = new StringBuilder(128);
			while ((Object)(object)transform != (Object)null)
			{
				if (stringBuilder.Length == 0)
				{
					stringBuilder.Insert(0, ((Object)transform).name);
				}
				else
				{
					stringBuilder.Insert(0, '/');
					stringBuilder.Insert(0, ((Object)transform).name);
				}
				transform = transform.parent;
			}
			return stringBuilder.ToString();
		}

		internal static string ToDisplaySegmentName(string segmentName)
		{
			return ToDisplaySegmentName(segmentName, string.Empty);
		}

		internal static string ToDisplaySegmentName(string segmentName, string biomeId)
		{
			string text = NormalizeSegmentName(segmentName);
			string text2 = NormalizeBiomeDisplayName(biomeId, text);
			if (!string.IsNullOrWhiteSpace(text2))
			{
				return text2;
			}
			if (string.IsNullOrWhiteSpace(text))
			{
				return "-";
			}
			if (text.Equals("Beach", StringComparison.OrdinalIgnoreCase) || text.Equals("Shore", StringComparison.OrdinalIgnoreCase))
			{
				return "Shore";
			}
			if (text.Equals("Tropics", StringComparison.OrdinalIgnoreCase))
			{
				return "Tropics/Roots";
			}
			if (text.Equals("Alpine", StringComparison.OrdinalIgnoreCase))
			{
				return "Alpine/Mesa";
			}
			return text;
		}

		private static string NormalizeSegmentName(string segmentName)
		{
			if (string.IsNullOrWhiteSpace(segmentName))
			{
				return string.Empty;
			}
			string text = segmentName.Trim();
			if (text.Equals("Tropics/Roots", StringComparison.OrdinalIgnoreCase))
			{
				return "Tropics";
			}
			if (text.Equals("Alpine/Mesa", StringComparison.OrdinalIgnoreCase))
			{
				return "Alpine";
			}
			return text;
		}

		private static string NormalizeBiomeDisplayName(string biomeId, string normalizedSegment)
		{
			if (string.IsNullOrWhiteSpace(biomeId))
			{
				return string.Empty;
			}
			string text = biomeId.Trim();
			if (text.StartsWith("Biome_", StringComparison.OrdinalIgnoreCase))
			{
				text = text.Substring("Biome_".Length);
			}
			if (text.IndexOf("Roots", StringComparison.OrdinalIgnoreCase) >= 0)
			{
				return "Roots";
			}
			if (text.IndexOf("Tropics", StringComparison.OrdinalIgnoreCase) >= 0)
			{
				return "Tropics";
			}
			if (text.IndexOf("Alpine", StringComparison.OrdinalIgnoreCase) >= 0)
			{
				return "Alpine";
			}
			if (text.IndexOf("Mesa", StringComparison.OrdinalIgnoreCase) >= 0)
			{
				return "Mesa";
			}
			string text2 = text.Replace("_", string.Empty).Replace("-", string.Empty).Trim();
			if (text2.Length >= 4)
			{
				int biomeCodeIndexForSegment = GetBiomeCodeIndexForSegment(normalizedSegment);
				if (biomeCodeIndexForSegment >= 0 && biomeCodeIndexForSegment < text2.Length && TryGetBiomeNameFromCode(text2[biomeCodeIndexForSegment], out var biomeName))
				{
					return biomeName;
				}
			}
			return string.Empty;
		}

		private static int GetBiomeCodeIndexForSegment(string normalizedSegment)
		{
			if (string.IsNullOrWhiteSpace(normalizedSegment))
			{
				return -1;
			}
			if (normalizedSegment.Equals("Beach", StringComparison.OrdinalIgnoreCase) || normalizedSegment.Equals("Shore", StringComparison.OrdinalIgnoreCase))
			{
				return 0;
			}
			if (normalizedSegment.Equals("Tropics", StringComparison.OrdinalIgnoreCase) || normalizedSegment.Equals("Roots", StringComparison.OrdinalIgnoreCase))
			{
				return 1;
			}
			if (normalizedSegment.Equals("Alpine", StringComparison.OrdinalIgnoreCase) || normalizedSegment.Equals("Mesa", StringComparison.OrdinalIgnoreCase))
			{
				return 2;
			}
			if (normalizedSegment.Equals("Volcano", StringComparison.OrdinalIgnoreCase))
			{
				return 3;
			}
			if (normalizedSegment.Equals("Peak", StringComparison.OrdinalIgnoreCase))
			{
				return 4;
			}
			return -1;
		}

		private static bool TryGetBiomeNameFromCode(char code, out string biomeName)
		{
			biomeName = string.Empty;
			switch (char.ToUpperInvariant(code))
			{
			case 'S':
				biomeName = "Shore";
				return true;
			case 'T':
				biomeName = "Tropics";
				return true;
			case 'R':
				biomeName = "Roots";
				return true;
			case 'A':
				biomeName = "Alpine";
				return true;
			case 'M':
				biomeName = "Mesa";
				return true;
			case 'V':
				biomeName = "Volcano";
				return true;
			case 'P':
				biomeName = "Peak";
				return true;
			default:
				return false;
			}
		}

		private static string NormalizeObjectName(string objectName)
		{
			if (string.IsNullOrWhiteSpace(objectName))
			{
				return string.Empty;
			}
			string text = objectName.Trim();
			if (text.EndsWith("(Clone)", StringComparison.OrdinalIgnoreCase))
			{
				text = text.Substring(0, text.Length - "(Clone)".Length).TrimEnd(Array.Empty<char>());
			}
			return text;
		}

		private static bool IsGroundItemCandidate(Item item)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Invalid comparison between Unknown and I4
			if ((Object)(object)item == (Object)null || !((Component)item).gameObject.activeInHierarchy)
			{
				return false;
			}
			if ((int)item.itemState == 2)
			{
				return false;
			}
			if ((Object)(object)item.holderCharacter != (Object)null || (Object)(object)item.trueHolderCharacter != (Object)null)
			{
				return false;
			}
			Transform transform = ((Component)item).transform;
			if ((Object)(object)transform == (Object)null)
			{
				return false;
			}
			if ((Object)(object)((Component)transform).GetComponentInParent<Player>() != (Object)null || (Object)(object)((Component)transform).GetComponentInParent<Character>() != (Object)null)
			{
				return false;
			}
			return true;
		}

		private static float GetMagicBeanVineCurrentLength(MagicBeanVine vine)
		{
			return GetFloatFieldValue(vine, MagicBeanVineCurrentLengthField, 0f);
		}

		private static float GetMagicBeanVineInitialLength(MagicBeanVine vine)
		{
			return GetFloatFieldValue(vine, MagicBeanVineInitialLengthField, 0f);
		}

		private static float GetMagicBeanVineMaxLength(MagicBeanVine vine)
		{
			return GetFloatFieldValue(vine, MagicBeanVineMaxLengthField, 0f);
		}

		private static void SetMagicBeanVineCurrentLength(MagicBeanVine vine, float value)
		{
			SetFloatFieldValue(vine, MagicBeanVineCurrentLengthField, Mathf.Max(0f, value));
		}

		private static bool GetCloudFungusAlreadyBroke(CloudFungus fungus)
		{
			return GetBoolFieldValue(fungus, CloudFungusAlreadyBrokeField, fallback: false);
		}

		private static float GetCloudFungusTimeAlive(CloudFungus fungus)
		{
			return GetFloatFieldValue(fungus, CloudFungusTimeAliveField, 0f);
		}

		private static void SetCloudFungusAlreadyBroke(CloudFungus fungus, bool value)
		{
			SetBoolFieldValue(fungus, CloudFungusAlreadyBrokeField, value);
		}

		private static void SetCloudFungusTimeAlive(CloudFungus fungus, float value)
		{
			SetFloatFieldValue(fungus, CloudFungusTimeAliveField, Mathf.Max(0f, value));
		}

		private static float[] GetCheckpointStatuses(CheckpointFlag flag)
		{
			if ((Object)(object)flag == (Object)null)
			{
				return Array.Empty<float>();
			}
			if (CheckpointFlagStatusesField != null)
			{
				try
				{
					if (CheckpointFlagStatusesField.GetValue(flag) is float[] array && array != null)
					{
						return array;
					}
				}
				catch
				{
				}
			}
			return Array.Empty<float>();
		}

		private static void SetCheckpointStatuses(CheckpointFlag flag, float[] statuses)
		{
			if ((Object)(object)flag == (Object)null || CheckpointFlagStatusesField == null || statuses == null)
			{
				return;
			}
			try
			{
				CheckpointFlagStatusesField.SetValue(flag, statuses);
			}
			catch
			{
			}
		}

		private static Character GetCheckpointPlanter(CheckpointFlag flag)
		{
			if ((Object)(object)flag == (Object)null)
			{
				return null;
			}
			if (CheckpointFlagPlanterField != null)
			{
				try
				{
					object? value = CheckpointFlagPlanterField.GetValue(flag);
					return (Character)((value is Character) ? value : null);
				}
				catch
				{
				}
			}
			return null;
		}

		private static void SetCheckpointPlanter(CheckpointFlag flag, Character planter)
		{
			if ((Object)(object)flag == (Object)null || CheckpointFlagPlanterField == null)
			{
				return;
			}
			try
			{
				CheckpointFlagPlanterField.SetValue(flag, planter);
			}
			catch
			{
			}
		}

		private static int GetMirageLuggageVisualState(MirageLuggage mirage)
		{
			if ((Object)(object)mirage == (Object)null)
			{
				return 0;
			}
			Renderer[] array = null;
			if (MirageLuggageRenderersField != null)
			{
				try
				{
					array = MirageLuggageRenderersField.GetValue(mirage) as Renderer[];
				}
				catch
				{
				}
			}
			if (array == null || array.Length == 0)
			{
				return ((Component)mirage).gameObject.activeSelf ? 1 : 0;
			}
			foreach (Renderer val in array)
			{
				if ((Object)(object)val != (Object)null && val.enabled)
				{
					return 1;
				}
			}
			return 0;
		}

		private static float GetFloatFieldValue(object target, FieldInfo field, float fallback)
		{
			if (target == null || field == null)
			{
				return fallback;
			}
			try
			{
				object value = field.GetValue(target);
				if (value is float result)
				{
					return result;
				}
				if (value is int)
				{
					int num = (int)value;
					return num;
				}
			}
			catch
			{
			}
			return fallback;
		}

		private static bool GetBoolFieldValue(object target, FieldInfo field, bool fallback)
		{
			if (target == null || field == null)
			{
				return fallback;
			}
			try
			{
				object value = field.GetValue(target);
				if (value is bool)
				{
					return (bool)value;
				}
			}
			catch
			{
			}
			return fallback;
		}

		private static void SetFloatFieldValue(object target, FieldInfo field, float value)
		{
			if (target == null || field == null)
			{
				return;
			}
			try
			{
				field.SetValue(target, value);
			}
			catch
			{
			}
		}

		private static void SetBoolFieldValue(object target, FieldInfo field, bool value)
		{
			if (target == null || field == null)
			{
				return;
			}
			try
			{
				field.SetValue(target, value);
			}
			catch
			{
			}
		}

		private static bool IsGroundRopeShooterCandidate(RopeShooter ropeShooter)
		{
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)ropeShooter == (Object)null)
			{
				return false;
			}
			if (!((Component)ropeShooter).gameObject.activeInHierarchy)
			{
				return false;
			}
			if ((Object)(object)((ItemComponent)ropeShooter).item != (Object)null)
			{
				return IsGroundItemCandidate(((ItemComponent)ropeShooter).item);
			}
			Transform transform = ((Component)ropeShooter).transform;
			if ((Object)(object)transform == (Object)null)
			{
				return false;
			}
			if ((Object)(object)((Component)transform).GetComponentInParent<Player>() != (Object)null || (Object)(object)((Component)transform).GetComponentInParent<Character>() != (Object)null)
			{
				return false;
			}
			Scene scene = ((Component)transform).gameObject.scene;
			return ((Scene)(ref scene)).IsValid();
		}

		private static Campfire[] FindNonSegmentCampfires()
		{
			Campfire[] array = Object.FindObjectsByType<Campfire>((FindObjectsSortMode)0);
			if (array == null || array.Length == 0)
			{
				return Array.Empty<Campfire>();
			}
			HashSet<Campfire> segmentCampfires = GetSegmentCampfires();
			return array.Where((Campfire campfire) => (Object)(object)campfire != (Object)null && !segmentCampfires.Contains(campfire)).ToArray();
		}

		private static HashSet<Campfire> GetSegmentCampfires()
		{
			HashSet<Campfire> hashSet = new HashSet<Campfire>();
			MapHandler val = Object.FindFirstObjectByType<MapHandler>();
			if ((Object)(object)val == (Object)null || val.segments == null)
			{
				return hashSet;
			}
			for (int i = 0; i < val.segments.Length; i++)
			{
				MapSegment val2 = val.segments[i];
				if (val2 != null && !((Object)(object)val2.segmentCampfire == (Object)null))
				{
					Campfire componentInChildren = val2.segmentCampfire.GetComponentInChildren<Campfire>(true);
					if ((Object)(object)componentInChildren != (Object)null)
					{
						hashSet.Add(componentInChildren);
					}
				}
			}
			return hashSet;
		}

		private static WobbleSpinBounce[] FindBounceFungusObjects()
		{
			WobbleSpinBounce[] array = Object.FindObjectsByType<WobbleSpinBounce>((FindObjectsSortMode)0);
			if (array == null || array.Length == 0)
			{
				return Array.Empty<WobbleSpinBounce>();
			}
			return array.Where(IsBounceFungusCandidate).ToArray();
		}

		private static bool IsBounceFungusCandidate(WobbleSpinBounce component)
		{
			//IL_002e: 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)
			if ((Object)(object)component == (Object)null || !((Component)component).gameObject.activeInHierarchy)
			{
				return false;
			}
			Transform transform = ((Component)component).transform;
			if (!((Object)(object)transform == (Object)null))
			{
				Scene scene = ((Component)transform).gameObject.scene;
				if (((Scene)(ref scene)).IsValid())
				{
					if ((Object)(object)((Component)transform).GetComponentInParent<Player>() != (Object)null || (Object)(object)((Component)transform).GetComponentInParent<Character>() != (Object)null)
					{
						return false;
					}
					string text = NormalizeObjectName(((Object)component).name);
					if (!string.IsNullOrWhiteSpace(text) && (text.IndexOf("fung", StringComparison.OrdinalIgnoreCase) >= 0 || text.IndexOf("bounce", StringComparison.OrdinalIgnoreCase) >= 0 || text.IndexOf("mushroom", StringComparison.OrdinalIgnoreCase) >= 0))
					{
						return true;
					}
					return (Object)(object)((Component)component).GetComponent<PhotonView>() != (Object)null;
				}
			}
			return false;
		}

		private static int GetChainLauncherAmmo(RopeShooter ropeShooter)
		{
			if ((Object)(object)ropeShooter == (Object)null)
			{
				return 0;
			}
			try
			{
				if (RopeShooterAmmoProperty != null)
				{
					object value = RopeShooterAmmoProperty.GetValue(ropeShooter, null);
					if (value is int)
					{
						int num = (int)value;
						return Mathf.Max(0, num);
					}
				}
			}
			catch
			{
			}
			if ((Object)(object)((ItemComponent)ropeShooter).item != (Object)null && ItemTotalUsesField != null)
			{
				try
				{
					object value2 = ItemTotalUsesField.GetValue(((ItemComponent)ropeShooter).item);
					if (value2 is int)
					{
						int num2 = (int)value2;
						return Mathf.Max(0, num2);
					}
				}
				catch
				{
				}
			}
			return 0;
		}

		private static void SetChainLauncherAmmo(RopeShooter ropeShooter, int ammo)
		{
			if ((Object)(object)ropeShooter == (Object)null)
			{
				return;
			}
			int num = Mathf.Max(0, ammo);
			bool flag = false;
			try
			{
				if (RopeShooterAmmoProperty != null && RopeShooterAmmoProperty.CanWrite)
				{
					RopeShooterAmmoProperty.SetValue(ropeShooter, num, null);
					flag = true;
				}
			}
			catch
			{
			}
			if (!flag && (Object)(object)((ItemComponent)ropeShooter).item != (Object)null && ItemTotalUsesField != null)
			{
				try
				{
					ItemTotalUsesField.SetValue(((ItemComponent)ropeShooter).item, num);
				}
				catch
				{
				}
			}
			if (!(RopeShooterSyncRpcMethod != null))
			{
				return;
			}
			try
			{
				RopeShooterSyncRpcMethod.Invoke(ropeShooter, new object[1] { num > 0 });
			}
			catch
			{
			}
		}

		private static string NormalizeSaveDisplayName(string value)
		{
			string text = (string.IsNullOrWhiteSpace(value) ? "Save" : value.Trim());
			if (text.Length > 64)
			{
				text = text.Substring(0, 64).Trim();
			}
			if (!string.IsNullOrWhiteSpace(text))
			{
				return text;
			}
			return "Save";
		}

		private string BuildUniqueSavePath(string saveName)
		{
			string text = SanitizeFileName(saveName);
			if (string.IsNullOrWhiteSpace(text))
			{
				text = "save";
			}
			string text2 = Path.Combine(saveDirectory, text + ".peaksave.json");
			int num = 2;
			while (File.Exists(text2) && num < 10000)
			{
				text2 = Path.Combine(saveDirectory, $"{text}_{num}.peaksave.json");
				num++;
			}
			return text2;
		}

		private string ResolveSavePathForName(string saveName)
		{
			string text = NormalizeSaveDisplayName(saveName);
			if (text.Equals("Autosave", StringComparison.OrdinalIgnoreCase))
			{
				return Path.Combine(saveDirectory, "Autosave.peaksave.json");
			}
			return BuildUniqueSavePath(text);
		}

		private void CleanupLegacyAutosaves(string activeAutosavePath)
		{
			try
			{
				if (!EnsureSaveDirectoryReady(showStatus: false))
				{
					return;
				}
				string text = (string.IsNullOrWhiteSpace(activeAutosavePath) ? string.Empty : Path.GetFullPath(activeAutosavePath));
				FileInfo[] files = new DirectoryInfo(saveDirectory).GetFiles("Autosave_*.peaksave.json", SearchOption.TopDirectoryOnly);
				foreach (FileInfo fileInfo in files)
				{
					if (fileInfo == null)
					{
						continue;
					}
					string fullPath = Path.GetFullPath(fileInfo.FullName);
					if (string.IsNullOrWhiteSpace(text) || !string.Equals(fullPath, text, StringComparison.OrdinalIgnoreCase))
					{
						try
						{
							fileInfo.Delete();
						}
						catch
						{
						}
					}
				}
			}
			catch (Exception ex)
			{
				((BaseUnityPlugin)this).Logger.LogWarning((object)("Failed to clean legacy autosaves: " + ex.Message));
			}
		}

		private bool EnsureSaveDirectoryReady(bool showStatus)
		{
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			string[] source = new string[3] { saveDirectory, preferredSaveDirectory, fallbackSaveDirectory };
			string text = string.Empty;
			foreach (string item in source.Where((string path) => !string.IsNullOrWhiteSpace(path)).Distinct<string>(StringComparer.OrdinalIgnoreCase))
			{
				if (TryActivateSaveDirectory(item, out var failureReason))
				{
					return true;
				}
				text = failureReason;
				((BaseUnityPlugin)this).Logger.LogWarning((object)("Save directory '" + item + "' is unavailable: " + failureReason));
			}
			if (showStatus)
			{
				SetStatus(string.IsNullOrWhiteSpace(text) ? "Save failed: no writable save folder." : ("Save failed: " + text), Color.red, 6f);
			}
			return false;
		}

		private bool TryActivateSaveDirectory(string candidate, out string failureReason)
		{
			failureReason = string.Empty;
			if (string.IsNullOrWhiteSpace(candidate))
			{
				failureReason = "invalid save folder path";
				return false;
			}
			try
			{
				Directory.CreateDirectory(candidate);
				string path = Path.Combine(candidate, ".taynsm_write_test.tmp");
				File.WriteAllText(path, "ok");
				File.Delete(path);
				if (!string.Equals(saveDirectory, candidate, StringComparison.OrdinalIgnoreCase))
				{
					((BaseUnityPlugin)this).Logger.LogWarning((object)("Switching save directory to '" + candidate + "'."));
				}
				saveDirectory = candidate;
				return true;
			}
			catch (UnauthorizedAccessException)
			{
				failureReason = "save folder is not writable";
				return false;
			}
			catch (Exception ex2)
			{
				failureReason = (string.IsNullOrWhiteSpace(ex2.Message) ? "save folder is unavailable" : ex2.Message);
				return false;
			}
		}

		private static string BuildSaveFailureStatus(Exception ex)
		{
			if (ex is UnauthorizedAccessException)
			{
				return "Save failed: save folder is not writable.";
			}
			string text = ex?.GetBaseException()?.Message;
			if (string.IsNullOrWhiteSpace(text))
			{
				return "Save failed. Check BepInEx log.";
			}
			text = text.Trim();
			int num = text.IndexOfAny(new char[2] { '\r', '\n' });
			if (num >= 0)
			{
				text = text.Substring(0, num).Trim();
			}
			if (text.Length > 90)
			{
				text = text.Substring(0, 90).TrimEnd(Array.Empty<char>()) + "...";
			}
			return "Save failed: " + text;
		}

		private static string Safe(string value)
		{
			if (!string.IsNullOrWhiteSpace(value))
			{
				return value;
			}
			return "-";
		}

		internal static string FormatRunSummary(SaveMetadata metadata)
		{
			if (metadata == null)
			{
				return "Run: Day -  Time: -  Duration: -  Difficulty: -";
			}
			string text = (metadata.runDay.HasValue ? ("Day " + metadata.runDay.Value.ToString(CultureInfo.InvariantCulture)) : "Day -");
			string text2 = ResolveInGameTimeText(metadata);
			string text3 = FormatRunDuration(metadata.runTimeSeconds);
			string text4 = FormatDifficultyLabel(metadata.ascent);
			return "Run: " + text + "  Time: " + text2 + "  Duration: " + text3 + "  Difficulty: " + text4;
		}

		internal static string FormatDifficultyLabel(int ascent)
		{
			if (ascent < 0)
			{
				return "Tenderfoot";
			}
			if (ascent == 0)
			{
				return "Peak";
			}
			return "Ascent " + ascent.ToString(CultureInfo.InvariantCulture);
		}

		private static string ResolveInGameTimeText(SaveMetadata metadata)
		{
			if (metadata == null)
			{
				return "-";
			}
			if (!string.IsNullOrWhiteSpace(metadata.inGameTime))
			{
				return metadata.inGameTime.Trim();
			}
			if (!metadata.timeOfDay.HasValue)
			{
				return "-";
			}
			float value = metadata.timeOfDay.Value;
			if (float.IsNaN(value) || float.IsInfinity(value))
			{
				return "-";
			}
			float num = value;
			if (num >= 0f && num <= 1.01f)
			{
				num *= 24f;
			}
			num = Mathf.Repeat(num, 24f);
			int num2 = Mathf.FloorToInt(num);
			int num3 = Mathf.RoundToInt((num - (float)num2) * 60f);
			if (num3 >= 60)
			{
				num3 -= 60;
				num2 = (num2 + 1) % 24;
			}
			int num4 = num2 % 12;
			if (num4 == 0)
			{
				num4 = 12;
			}
			string text = ((num2 >= 12) ? "PM" : "AM");
			return num4.ToString(CultureInfo.InvariantCulture) + ":" + num3.ToString("00", CultureInfo.InvariantCulture) + " " + text;
		}

		private static string FormatRunDuration(float? runTimeSeconds)
		{
			if (!runTimeSeconds.HasValue)
			{
				return "-";
			}
			float value = runTimeSeconds.Value;
			if (float.IsNaN(value) || float.IsInfinity(value))
			{
				return "-";
			}
			TimeSpan timeSpan = TimeSpan.FromSeconds(Math.Max(0.0, value));
			if (timeSpan.TotalHours >= 1.0)
			{
				return string.Format(CultureInfo.InvariantCulture, "{0:D2}:{1:D2}:{2:D2}", (int)timeSpan.TotalHours, timeSpan.Minutes, timeSpan.Seconds);
			}
			return string.Format(CultureInfo.InvariantCulture, "{0:D2}:{1:D2}", timeSpan.Minutes, timeSpan.Seconds);
		}

		private static string FormatBytes(long size)
		{
			if (size < 1024)
			{
				return $"{size} B";
			}
			if (size < 1048576)
			{
				return $"{(float)size / 1024f:F1} KB";
			}
			return $"{(float)size / 1048576f:F1} MB";
		}

		private void SetStatus(string message, Color color, float durationSeconds)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			statusMessage = message;
			statusColor = color;
			statusMessageUntil = Time.unscaledTime + Mathf.Max(0.5f, durationSeconds);
		}

		private static Texture2D MakeTexture(Color color)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Expected O, but got Unknown
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: 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_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			Texture2D val = new Texture2D(2, 2)
			{
				filterMode = (FilterMode)1,
				wrapMode = (TextureWrapMode)1
			};
			Color[] pixels = (Color[])(object)new Color[4] { color, color, color, color };
			val.SetPixels(pixels);
			val.Apply();
			return val;
		}

		private static Texture2D MakeRoundedTexture(Color color, int cornerRadius, int size = 48)
		{
			//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_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Expected O, but got Unknown
			//IL_015c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: Unknown result type (might be due to invalid IL or missing references)
			int num = Mathf.Max(8, size);
			int num2 = Mathf.Max(8, size);
			int num3 = Mathf.Clamp(cornerRadius, 0, Mathf.Min(num, num2) / 2);
			float num4 = num3 * num3;
			Texture2D val = new Texture2D(num, num2, (TextureFormat)5, false)
			{
				filterMode = (FilterMode)1,
				wrapMode = (TextureWrapMode)1
			};
			Color val2 = default(Color);
			((Color)(ref val2))..ctor(0f, 0f, 0f, 0f);
			for (int i = 0; i < num2; i++)
			{
				for (int j = 0; j < num; j++)
				{
					bool flag = true;
					if (j < num3 && i < num3)
					{
						float num5 = (float)(num3 - j) - 0.5f;
						float num6 = (float)(num3 - i) - 0.5f;
						flag = num5 * num5 + num6 * num6 <= num4;
					}
					else if (j >= num - num3 && i < num3)
					{
						float num7 = (float)(j - (num - num3)) + 0.5f;
						float num8 = (float)(num3 - i) - 0.5f;
						flag = num7 * num7 + num8 * num8 <= num4;
					}
					else if (j < num3 && i >= num2 - num3)
					{
						float num9 = (float)(num3 - j) - 0.5f;
						float num10 = (float)(i - (num2 - num3)) + 0.5f;
						flag = num9 * num9 + num10 * num10 <= num4;
					}
					else if (j >= num - num3 && i >= num2 - num3)
					{
						float num11 = (float)(j - (num - num3)) + 0.5f;
						float num12 = (float)(i - (num2 - num3)) + 0.5f;
						flag = num11 * num11 + num12 * num12 <= num4;
					}
					val.SetPixel(j, i, flag ? color : val2);
				}
			}
			val.Apply();
			return val;
		}

		private void EnsureStyles()
		{
			//IL_001e: 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_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: 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_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_014a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0167: Unknown result type (might be due to invalid IL or missing references)
			//IL_016c: Unknown result type (might be due to invalid IL or missing references)
			//IL_017d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0183: 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_0194: Unknown result type (might be due to invalid IL or missing references)
			//IL_019c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01af: Expected O, but got Unknown
			//IL_01b4: Expected O, but got Unknown
			//IL_01bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01db: 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)
			//IL_01ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f4: Expected O, but got Unknown
			//IL_01f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0207: Expected O, but got Unknown
			//IL_0207: Unknown result type (might be due to invalid IL or missing references)
			//IL_020c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0216: Expected O, but got Unknown
			//IL_021b: Expected O, but got Unknown
			//IL_0226: Unknown result type (might be due to invalid IL or missing references)
			//IL_022b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0233: Unknown result type (might be due to invalid IL or missing references)
			//IL_023a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0240: Unknown result type (might be due to invalid IL or missing references)
			//IL_024f: Expected O, but got Unknown
			//IL_025a: 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)
			//IL_0267: Unknown result type (might be due to invalid IL or missing references)
			//IL_026e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0288: Unknown result type (might be due to invalid IL or missing references)
			//IL_0297: Expected O, but got Unknown
			//IL_02a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02af: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02df: Expected O, but got Unknown
			//IL_02ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0318: Unknown result type (might be due to invalid IL or missing references)
			//IL_0327: Expected O, but got Unknown
			//IL_0332: Unknown result type (might be due to invalid IL or missing references)
			//IL_0337: Unknown result type (might be due to invalid IL or missing references)
			//IL_033f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0346: Unknown result type (might be due to invalid IL or missing references)
			//IL_034d: Unknown result type (might be due to invalid IL or missing references)
			//IL_035e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0364: Unknown result type (might be due to invalid IL or missing references)
			//IL_036e: Unknown result type (might be due to invalid IL or missing references)
			//IL_037f: 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_038f: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c3: Expected O, but got Unknown
			//IL_03c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d2: Expected O, but got Unknown
			//IL_03d7: Expected O, but got Unknown
			//IL_03de: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_03fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0404: Unknown result type (might be due to invalid IL or missing references)
			//IL_0415: Unknown result type (might be due to invalid IL or missing references)
			//IL_041b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0425: Unknown result type (might be due to invalid IL or missing references)
			//IL_0436: Unknown result type (might be due to invalid IL or missing references)
			//IL_043c: Unknown result type (might be due to invalid IL or missing references)
			//IL_044b: Expected O, but got Unknown
			//IL_0456: Unknown result type (might be due to invalid IL or missing references)
			//IL_045b: Unknown result type (might be due to invalid IL or missing references)
			//IL_046c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0472: Unknown result type (might be due to invalid IL or missing references)
			//IL_047c: Unknown result type (might be due to invalid IL or missing references)
			//IL_048d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0493: Unknown result type (might be due to invalid IL or missing references)
			//IL_049d: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ac: Expected O, but got Unknown
			//IL_04ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_04b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_04bb: Expected O, but got Unknown
			//IL_04c0: Expected O, but got Unknown
			//IL_04cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_04d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_04e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_04e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_04f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_04f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0500: Expected O, but got Unknown
			//IL_0500: Unknown result type (might be due to invalid IL or missing references)
			//IL_0505: Unknown result type (might be due to invalid IL or missing references)
			//IL_050f: Expected O, but got Unknown
			//IL_050f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0514: Unknown result type (might be due to invalid IL or missing references)
			//IL_051e: Expected O, but got Unknown
			//IL_0523: Expected O, but got Unknown
			//IL_052a: Unknown result type (might be due to invalid IL or missing references)
			//IL_052f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0540: Unknown result type (might be due to invalid IL or missing references)
			//IL_0546: Unknown result type (might be due to invalid IL or missing references)
			//IL_0555: Expected O, but got Unknown
			if (!stylesBuilt)
			{
				overlayTexture = MakeTexture(new Color(0.01f, 0.04f, 0.08f, 0.26f));
				windowTexture = MakeTexture(new Color(0.08f, 0.13f, 0.18f, 0.98f));
				sectionTexture = MakeTexture(new Color(0.12f, 0.18f, 0.24f, 0.98f));
				cardTexture = MakeTexture(new Color(0.1f, 0.16f, 0.22f, 0.96f));
				warningCardTexture = MakeTexture(new Color(0.28f, 0.21f, 0.07f, 0.96f));
				buttonTexture = MakeRoundedTexture(new Color(0.16f, 0.43f, 0.35f, 0.98f), 10);
				buttonHoverTexture = MakeRoundedTexture(new Color(0.19f, 0.54f, 0.43f, 0.98f), 10);
				dangerButtonTexture = MakeRoundedTexture(new Color(0.58f, 0.18f, 0.18f, 0.98f), 10);
				textFieldTexture = MakeRoundedTexture(new Color(0.08f, 0.11f, 0.14f, 1f), 8);
				GUIStyle val = new GUIStyle(GUI.skin.window);
				val.normal.background = windowTexture;
				val.normal.textColor = Color.white;
				val.fontStyle = (FontStyle)1;
				val.fontSize = 14;
				val.padding = new RectOffset(12, 12, 24, 12);
				windowStyle = val;
				GUIStyle val2 = new GUIStyle(GUI.skin.box);
				val2.normal.background = sectionTexture;
				val2.normal.textColor = Color.white;
				val2.border = new RectOffset(6, 6, 6, 6);
				val2.padding = new RectOffset(10, 10, 10, 10);
				val2.margin = new RectOffset(3, 3, 3, 3);
				sectionStyle = val2;
				GUIStyle val3 = new GUIStyle(GUI.skin.label)
				{
					fontSize = 14,
					fontStyle = (FontStyle)1
				};
				val3.normal.textColor = Color.white;
				titleStyle = val3;
				GUIStyle val4 = new GUIStyle(GUI.skin.label)
				{
					fontSize = 12,
					fontStyle = (FontStyle)1
				};
				val4.normal.textColor = new Color(0.78f, 0.92f, 1f, 1f);
				subtitleStyle = val4;
				GUIStyle val5 = new GUIStyle(GUI.skin.label)
				{
					fontSize = 11,
					wordWrap = true
				};
				val5.normal.textColor = new Color(0.88f, 0.92f, 0.95f, 1f);
				normalLabelStyle = val5;
				GUIStyle val6 = new GUIStyle(GUI.skin.label)
				{
					fontSize = 11,
					wordWrap = true
				};
				val6.normal.textColor = new Color(1f, 0.88f, 0.35f, 1f);
				errorLabelStyle = val6;
				GUIStyle val7 = new GUIStyle(GUI.skin.button)
				{
					fontSize = 11,
					fontStyle = (FontStyle)1,
					alignment = (TextAnchor)4
				};
				val7.normal.background = buttonTexture;
				val7.normal.textColor = Color.white;
				val7.hover.background = buttonHoverTexture;
				val7.hover.textColor = Color.white;
				val7.active.background = buttonHoverTexture;
				val7.active.textColor = Color.white;
				val7.border = new RectOffset(10, 10, 10, 10);
				val7.padding = new RectOffset(8, 8, 5, 5);
				softButtonStyle = val7;
				GUIStyle val8 = new GUIStyle(softButtonStyle);
				val8.normal.background = dangerButtonTexture;
				val8.normal.textColor = Color.white;
				val8.hover.background = dangerButtonTexture;
				val8.hover.textColor = Color.white;
				val8.active.background = dangerButtonTexture;
				val8.active.textColor = Color.white;
				dangerButtonStyle = val8;
				GUIStyle val9 = new GUIStyle(GUI.skin.textField);
				val9.normal.background = textFieldTexture;
				val9.normal.textColor = Color.white;
				val9.focused.background = textFieldTexture;
				val9.focused.textColor = Color.white;
				val9.border = new RectOffset(8, 8, 8, 8);
				val9.padding = new RectOffset(8, 8, 5, 5);
				textFieldStyle = val9;
				GUIStyle val10 = new GUIStyle(GUI.skin.box);
				val10.normal.background = cardTexture;
				val10.normal.textColor = Color.white;
				val10.border = new RectOffset(4, 4, 4, 4);
				val10.padding = new RectOffset(8, 8, 8, 8);
				val10.margin = new RectOffset(1, 1, 1, 1);
				cardStyle = val10;
				GUIStyle val11 = new GUIStyle(cardStyle);
				val11.normal.background = warningCardTexture;
				val11.normal.textColor = Color.white;
				cardWarningStyle = val11;
				stylesBuilt = true;
			}
		}

		private void DrawOverlay()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: 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)
			Color color = GUI.color;
			GUI.color = Color.white;
			GUI.DrawTexture(new Rect(0f, 0f, (float)Screen.width, (float)Screen.height), (Texture)(object)overlayTexture, (ScaleMode)0);
			GUI.color = color;
		}

		private static void SetPendingSeedForLoad(int seed)
		{
			PendingSeedForLoad = seed;
			PendingSeedSetRealtime = Time.realtimeSinceStartup;
		}

		private static void ClearPendingSeedForLoad()
		{
			PendingSeedForLoad = null;
			PendingSeedSetRealtime = 0f;
		}

		private void DestroyUiResources()
		{
			if ((Object)(object)overlayTexture != (Object)null)
			{
				Object.Destroy((Object)(object)overlayTexture);
			}
			if ((Object)(object)windowTexture != (Object)null)
			{
				Object.Destroy((Object)(object)windowTexture);
			}
			if ((Object)(object)sectionTexture != (Object)null)
			{
				Object.Destroy((Object)(object)sectionTexture);
			}
			if ((Object)(object)cardTexture != (Object)null)
			{
				Object.Destroy((Object)(object)cardTexture);
			}
			if ((Object)(object)warningCardTexture != (Object)null)
			{
				Object.Destroy((Object)(object)warningCardTexture);
			}
			if ((Object)(object)buttonTexture != (Object)null)
			{
				Object.Destroy((Object)(object)buttonTexture);
			}
			if ((Object)(object)buttonHoverTexture != (Object)null)
			{
				Object.Destroy((Object)(object)buttonHoverTexture);
			}
			if ((Object)(object)dangerButtonTexture != (Object)null)
			{
				Object.Destroy((Object)(object)dangerButtonTexture);
			}
			if ((Object)(object)textFieldTexture != (Object)null)
			{
				Object.Destroy((Object)(object)textFieldTexture);
			}
		}

		internal static bool TryGetPendingSeed(out int seed)
		{
			if (!PendingSeedForLoad.HasValue)
			{
				seed = 0;
				return false;
			}
			if ((Object)(object)Instance == (Object)null || !Instance.isLoading)
			{
				ClearPendingSeedForLoad();
				seed = 0;
				return false;
			}
			if (PendingSeedSetRealtime > 0f && Time.realtimeSinceStartup - PendingSeedSetRealtime > 90f)
			{
				((BaseUnityPlugin)Instance).Logger.LogWarning((object)"Discarded stale pending seed override.");
				ClearPendingSeedForLoad();
				seed = 0;
				return false;
			}
			seed = PendingSeedForLoad.Value;
			return true;
		}
	}
	internal sealed class SaveManagerPausePage : UIPage
	{
		private enum ButtonVisualStyle
		{
			Primary,
			Secondary,
			Neutral,
			Danger
		}

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

			private object <>2__current;

			public RectTransform rectTransform;

			public SaveManagerPausePage <>4__this;

			private Vector3 <originalScale>5__2;

			private Vector3 <pressedScale>5__3;

			private float <elapsed>5__4;

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

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

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

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

			private bool MoveNext()
			{
				//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_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_00ba: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
				//IL_0197: 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_0140: 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)
				int num = <>1__state;
				SaveManagerPausePage saveManagerPausePage = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if ((Object)(object)rectTransform == (Object)null)
					{
						return false;
					}
					<originalScale>5__2 = ((Transform)rectTransform).localScale;
					<pressedScale>5__3 = new Vector3(<originalScale>5__2.x * 0.965f, <originalScale>5__2.y * 0.965f, <originalScale>5__2.z);
					<elapsed>5__4 = 0f;
					goto IL_00e7;
				case 1:
					<>1__state = -1;
					goto IL_00e7;
				case 2:
					{
						<>1__state = -1;
						break;
					}
					IL_00e7:
					if (<elapsed>5__4 < 0.045f && (Object)(object)rectTransform != (Object)null)
					{
						<elapsed>5__4 += Time.unscaledDeltaTime;
						float num2 = Mathf.Clamp01(<elapsed>5__4 / 0.045f);
						((Transform)rectTransform).localScale = Vector3.LerpUnclamped(<originalScale>5__2, <pressedScale>5__3, num2);
						<>2__current = null;
						<>1__state = 1;
						return true;
					}
					<elapsed>5__4 = 0f;
					break;
				}
				if (<elapsed>5__4 < 0.08f && (Object)(object)rectTransform != (Object)null)
				{
					<elapsed>5__4 += Time.unscaledDeltaTime;
					float num3 = Mathf.Clamp01(<elapsed>5__4 / 0.08f);
					((Transform)rectTransform).localScale = Vector3.LerpUnclamped(<pressedScale>5__3, <originalScale>5__2, num3);
					<>2__current = null;
					<>1__state = 2;
					return true;
				}
				if ((Object)(object)rectTransform != (Object)null)
				{
					((Transform)rectTransform).localScale = <originalScale>5__2;
					saveManagerPausePage.activePressAnimations.Remove(rectTransform);
				}
				return false;
			}

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

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

		private SaveManagerPlugin plugin;

		private UIPageHandler handler;

		private UIPage returnPage;

		private Button templateButton;

		private TMP_Text templateButtonText;

		private bool uiBuilt;

		private RectTransform rootContainer;

		private TextMeshProUGUI statusLabel;

		private RectTransform quitDecisionRow;

		private RectTransform standardSaveRow;

		private RectTransform saveListContent;

		private GameObject slotActionPanel;

		private TextMeshProUGUI slotActionLabel;

		private Button loadSelectedButton;

		private Button overwriteSelectedButton;

		private Button deleteSelectedButton;

		private GameObject confirmPanel;

		private TextMeshProUGUI confirmLabel;

		private Action confirmAction;

		private GameObject nameEntryPanel;

		private TMP_InputField nameEntryInput;

		private TextMeshProUGUI nameEntryTitle;

		private Action<string> nameEntryConfirmAction;

		private float nextStatusRefresh;

		private MonoBehaviour templateClickSfxComponent;

		private MethodInfo templateClickSfxPlayMethod;

		private MonoBehaviour templateHoverFeedbackComponent;

		private MethodInfo templateHoverOnClickMethod;

		private readonly Dictionary<RectTransform, Coroutine> activePressAnimations = new Dictionary<RectTransform, Coroutine>();

		private readonly List<SaveListEntry> displayedEntries = new List<SaveListEntry>();

		private readonly List<Image> displayedSlotBackgrounds = new List<Image>();

		private readonly List<Outline> displayedSlotOutlines = new List<Outline>();

		private readonly List<TextMeshProUGUI> displayedSlotTitles = new List<TextMeshProUGUI>();

		private int selectedSaveIndex = -1;

		public void Initialize(SaveManagerPlugin plugin, UIPageHandler handler, UIPage returnPage, Button templateButton)
		{
			this.plugin = plugin;
			this.handler = handler;
			this.returnPage = returnPage;
			this.templateButton = templateButton;
			templateButtonText = (((Object)(object)templateButton != (Object)null) ? ((Component)templateButton).GetComponentInChildren<TMP_Text>(true) : null);
			CacheTemplateFeedbackComponents();
			if (!uiBuilt)
			{
				BuildUi();
			}
		}

		public override void OnPageEnter()
		{
			((UIPage)this).OnPageEnter();
			if ((Object)(object)EventSystem.current != (Object)null)
			{
				EventSystem.current.SetSelectedGameObject((GameObject)null);
			}
			RefreshFromSource();
		}

		public override void OnPageExit()
		{
			((PageBase)this).OnPageExit();
			StopAllPressAnimations();
			HideSlotActionPanel();
			HideConfirmation();
			HideNameEntryPanel();
		}

		public void PrepareForLoad()
		{
			StopAllPressAnimations();
			HideSlotActionPanel();
			HideConfirmation();
			HideNameEntryPanel();
			if (((Component)this).gameObject.activeSelf)
			{
				((Component)this).gameObject.SetActive(false);
			}
		}

		private void Update()
		{
			if (!((Component)this).gameObject.activeInHierarchy)
			{
				return;
			}
			if (Input.GetKeyDown((KeyCode)27))
			{
				if ((Object)(object)nameEntryPanel != (Object)null && nameEntryPanel.activeSelf)
				{
					HideNameEntryPanel();
				}
				else if ((Object)(object)confirmPanel != (Object)null && confirmPanel.activeSelf)
				{
					HideConfirmation();
				}
				else if ((Object)(object)slotActionPanel != (Object)null && slotActionPanel.activeSelf)
				{
					HideSlotActionPanel();
				}
				else
				{
					GoBack();
				}
			}
			else if (!(Time.unscaledTime < nextStatusRefresh))
			{
				UpdateStatusLabel();
				UpdateSlotActionPanelState();
				nextStatusRefresh = Time.unscaledTime + 0.25f;
			}
		}

		public void RefreshFromSource()
		{
			if (!((Object)(object)plugin == (Object)null))
			{
				string preferredPath = GetSelectedEntry()?.fullPath;
				plugin.UiRefreshSaveList();
				RebuildSaveRows(preferredPath);
				UpdateStatusLabel();
				UpdateQuitDecisionRow();
				HideSlotActionPanel();
				HideConfirmation();
				HideNameEntryPanel();
			}
		}

		private void BuildUi()
		{
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Expected O, but got Unknown
			//IL_027d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0270: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0300: Expected O, but got Unknown
			//IL_03ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_0400: Unknown result type (might be due to invalid IL or missing references)
			//IL_0493: Unknown result type (might be due to invalid IL or missing references)
			//IL_04aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_04b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_04cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_04e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0507: Unknown result type (might be due to invalid IL or missing references)
			//IL_0551: Unknown result type (might be due to invalid IL or missing references)
			//IL_057e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0598: Unknown result type (might be due to invalid IL or missing references)
			//IL_05b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_05cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_05e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_060b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0615: Expected O, but got Unknown
			uiBuilt = true;
			Transform transform = ((Component)this).transform;
			RectTransform val = (RectTransform)(object)((transform is RectTransform) ? transform : null);
			if (!((Object)(object)val == (Object)null))
			{
				rootContainer = new GameObject("SaveManagerRoot", new Type[4]
				{
					typeof(RectTransform),
					typeof(Image),
					typeof(VerticalLayoutGroup),
					typeof(ContentSizeFitter)
				}).GetComponent<RectTransform>();
				((Transform)rootContainer).SetParent((Transform)(object)val, false);
				rootContainer.anchorMin = new Vector2(0.09f, 0.07f);
				rootContainer.anchorMax = new Vector2(0.91f, 0.93f);
				rootContainer.offsetMin = Vector2.zero;
				rootContainer.offsetMax = Vector2.zero;
				((Graphic)((Component)rootContainer).GetComponent<Image>()).color = new Color(0f, 0f, 0f, 0.22f);
				VerticalLayoutGroup component = ((Component)rootContainer).GetComponent<VerticalLayoutGroup>();
				((HorizontalOrVerticalLayoutGroup)component).spacing = 8f;
				((LayoutGroup)component).padding = new RectOffset(16, 16, 14, 14);
				((HorizontalOrVerticalLayoutGroup)component).childControlHeight = true;
				((HorizontalOrVerticalLayoutGroup)component).childControlWidth = true;
				((HorizontalOrVerticalLayoutGroup)component).childForceExpandHeight = false;
				((HorizontalOrVerticalLayoutGroup)component).childForceExpandWidth = true;
				ContentSizeFitter component2 = ((Component)rootContainer).GetComponent<ContentSizeFitter>();
				component2.verticalFit = (FitMode)0;
				component2.horizontalFit = (FitMode)0;
				RectTransform parent = CreateRow((Transform)(object)rootContainer, 44f);
				CreateButton((Transform)(object)parent, "BACK", GoBack, 108f, ButtonVisualStyle.Danger);
				((TMP_Text)CreateLabel((Transform)(object)parent, "SAVE MANAGER", 36f, (TextAlignmentOptions)513, 28)).fontStyle = (FontStyles)16;
				standardSaveRow = CreateRow((Transform)(object)rootContainer, 40f);
				CreateButton((Transform)(object)standardSaveRow, "QUICK SAVE", QuickSaveClicked, 150f, ButtonVisualStyle.Secondary);
				CreateButton((Transform)(object)standardSaveRow, "SAVE", SaveClicked, 120f, ButtonVisualStyle.Primary);
				CreateButton((Transform)(object)standardSaveRow, "REFRESH", RefreshFromSource, 114f, ButtonVisualStyle.Neutral);
				statusLabel = CreateLabel((Transform)(object)rootContainer, string.Empty, 26f, (TextAlignmentOptions)513, 16);
				((Graphic)statusLabel).color = (Color)(((Object)(object)templateButtonText != (Object)null) ? ((Graphic)templateButtonText).color : new Color(0.9f, 0.9f, 0.9f, 0.95f));
				quitDecisionRow = new GameObject("QuitDecisionRow", new Type[3]
				{
					typeof(RectTransform),
					typeof(VerticalLayoutGroup),
					typeof(LayoutElement)
				}).GetComponent<RectTransform>();
				((Transform)quitDecisionRow).SetParent((Transform)(object)rootContainer, false);
				VerticalLayoutGroup component3 = ((Component)quitDecisionRow).GetComponent<VerticalLayoutGroup>();
				((HorizontalOrVerticalLayoutGroup)component3).spacing = 6f;
				((LayoutGroup)component3).padding = new RectOffset(0, 0, 0, 0);
				((HorizontalOrVerticalLayoutGroup)component3).childControlHeight = true;
				((HorizontalOrVerticalLayoutGroup)component3).childControlWidth = true;
				((HorizontalOrVerticalLayoutGroup)component3).childForceExpandHeight = false;
				((HorizontalOrVerticalLayoutGroup)component3).childForceExpandWidth = true;
				LayoutElement component4 = ((Component)quitDecisionRow).GetComponent<LayoutElement>();
				component4.minHeight = 44f;
				component4.preferredHeight = 44f;
				RectTransform parent2 = CreateRow((Transform)(object)quitDecisionRow, 42f);
				CreateButton((Transform)(object)parent2, "SAVE & QUIT", SaveAndQuitClicked, 176f, ButtonVisualStyle.Secondary);
				CreateButton((Transform)(object)parent2, "CANCEL QUIT", CancelQuitClicked, 156f, ButtonVisualStyle.Neutral);
				((Component)quitDecisionRow).gameObject.SetActive(false);
				RectTransform component5 = new GameObject("SaveListContainer", new Type[3]
				{
					typeof(RectTransform),
					typeof(Image),
					typeof(LayoutElement)
				}).GetComponent<RectTransform>();
				((Transform)component5).SetParent((Transform)(object)rootContainer, false);
				((Graphic)((Component)component5).GetComponent<Image>()).color = new Color(0f, 0f, 0f, 0.35f);
				LayoutElement component6 = ((Component)component5).GetComponent<LayoutElement>();
				component6.preferredHeight = 488f;
				component6.minHeight = 360f;
				component6.flexibleHeight = 1f;
				ScrollRect val2 = ((Component)component5).gameObject.AddComponent<ScrollRect>();
				val2.horizontal = false;
				val2.vertical = true;
				val2.movementType = (MovementType)2;
				val2.scrollSensitivity = 32f;
				RectTransform component7 = new GameObject("Viewport", new Type[3]
				{
					typeof(RectTransform),
					typeof(Image),
					typeof(Mask)
				}).GetComponent<RectTransform>();
				((Transform)component7).SetParent((Transform)(object)component5, false);
				component7.anchorMin = Vector2.zero;
				component7.anchorMax = Vector2.one;
				component7.offsetMin = new Vector2(10f, 10f);
				component7.offsetMax = new Vector2(-28f, -10f);
				((Graphic)((Component)component7).GetComponent<Image>()).color = new Color(0f, 0f, 0f, 0.12f);
				((Component)component7).GetComponent<Mask>().showMaskGraphic = false;
				saveListContent = new GameObject("Content", new Type[3]
				{
					typeof(RectTransform),
					typeof(VerticalLayoutGroup),
					typeof(ContentSizeFitter)
				}).GetComponent<RectTransform>();
				((Transform)saveListContent).SetParent((Transform)(object)component7, false);
				saveListContent.anchorMin = new Vector2(0f, 1f);
				saveListContent.anchorMax = new Vector2(1f, 1f);
				saveListContent.pivot = new Vector2(0.5f, 1f);
				saveListContent.offsetMin = new Vector2(2f, 0f);
				saveListContent.offsetMax = new Vector2(-2f, 0f);
				VerticalLayoutGroup component8 = ((Component)saveListContent).GetComponent<VerticalLayoutGroup>();
				((HorizontalOrVerticalLayoutGroup)component8).spacing = 8f;
				((LayoutGroup)component8).padding = new RectOffset(2, 2, 2, 2);
				((HorizontalOrVerticalLayoutGroup)component8).childControlHeight = true;
				((HorizontalOrVerticalLayoutGroup)component8).childControlWidth = true;
				((HorizontalOrVerticalLayoutGroup)component8).childForceExpandHeight = false;
				((HorizontalOrVerticalLayoutGroup)component8).childForceExpandWidth = true;
				ContentSizeFitter component9 = ((Component)saveListContent).GetComponent<ContentSizeFitter>();
				component9.verticalFit = (FitMode)2;
				component9.horizontalFit = (FitMode)0;
				Scrollbar verticalScrollbar = CreateVerticalScrollbar((Transform)(object)component5);
				val2.viewport = component7;
				val2.content = saveListContent;
				val2.verticalScrollbar = verticalScrollbar;
				val2.verticalScrollbarVisibility = (ScrollbarVisibility)0;
				BuildSlotActionPanel();
				BuildNameEntryPanel();
				BuildConfirmationPanel();
			}
		}

		private void BuildSlotActionPanel()
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: 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_00b8: 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_0118: Unknown result type (might be due to invalid IL or missing references)
			//IL_012d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0142: Unknown result type (might be due to invalid IL or missing references)
			//IL_0157: Unknown result type (might be due to invalid IL or missing references)
			//IL_017b: Unknown result type (might be due to invalid IL or missing references)
			//IL_019f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a9: Expected O, but got Unknown
			slotActionPanel = new GameObject("SlotActionOverlay", new Type[3]
			{
				typeof(RectTransform),
				typeof(Image),
				typeof(LayoutElement)
			}).gameObject;
			RectTransform component = slotActionPanel.GetComponent<RectTransform>();
			((Transform)component).SetParent((Transform)(object)rootContainer, false);
			component.anchorMin = Vector2.zero;
			component.anchorMax = Vector2.one;
			component.offsetMin = Vector2.zero;
			component.offsetMax = Vector2.zero;
			slotActionPanel.GetComponent<LayoutElement>().ignoreLayout = true;
			Image component2 = slotActionPanel.GetComponent<Image>();
			((Graphic)component2).color = new Color(0f, 0f, 0f, 0.62f);
			((Graphic)component2).raycastTarget = true;
			RectTransform component3 = new GameObject("SlotActionPanel", new Type[3]
			{
				typeof(RectTransform),
				typeof(Image),
				typeof(VerticalLayoutGroup)
			}).GetComponent<RectTransform>();
			((Transform)component3).SetParent((Transform)(object)component, false);
			component3.anchorMin = new Vector2(0.5f, 0.5f);
			component3.anchorMax = new Vector2(0.5f, 0.5f);
			component3.pivot = new Vector2(0.5f, 0.5f);
			component3.sizeDelta = new Vector2(700f, 250f);
			((Graphic)((Component)component3).GetComponent<Image>()).color = new Color(0f, 0f, 0f, 0.88f);
			VerticalLayoutGroup component4 = ((Component)component3).GetComponent<VerticalLayoutGroup>();
			((HorizontalOrVerticalLayoutGroup)component4).spacing = 10f;
			((LayoutGroup)component4).padding = new RectOffset(18, 18, 16, 16);
			((HorizontalOrVerticalLayoutGroup)component4).childControlHeight = true;
			((HorizontalOrVerticalLayoutGroup)component4).childControlWidth = true;
			((HorizontalOrVerticalLayoutGroup)component4).childForceExpandHeight = false;
			((HorizontalOrVerticalLayoutGroup)component4).childForceExpandWidth = true;
			CreateLabel((Transform)(object)component3, "SAVE ACTIONS", 30f, (TextAlignmentOptions)514, 24);
			slotActionLabel = CreateLabel((Transform)(object)component3, "Select an action.", 84f, (TextAlignmentOptions)514, 18);
			((TMP_Text)slotActionLabel).textWrappingMode = (TextWrappingModes)1;
			((TMP_Text)slotActionLabel).overflowMode = (TextOverflowModes)0;
			RectTransform val = CreateRow((Transform)(object)component3, 44f);
			HorizontalLayoutGroup component5 = ((Component)val).GetComponent<HorizontalLayoutGroup>();
			if ((Object)(object)component5 != (Object)null)
			{
				((LayoutGroup)component5).childAlignment = (TextAnchor)4;
				((HorizontalOrVerticalLayoutGroup)component5).spacing = 12f;
			}
			loadSelectedButton = CreateButton((Transform)(object)val, "LOAD", LoadSelectedClicked, 168f, ButtonVisualStyle.Primary);
			overwriteSelectedButton = CreateButton((Transform)(object)val, "OVERWRITE", OverwriteSelectedClicked, 180f, ButtonVisualStyle.Secondary);
			deleteSelectedButton = CreateButton((Transform)(object)val, "DELETE", DeleteSelectedClicked, 138f, ButtonVisualStyle.Danger);
			RectTransform val2 = CreateRow((Transform)(object)component3, 40f);
			HorizontalLayoutGroup component6 = ((Component)val2).GetComponent<HorizontalLayoutGroup>();
			if ((Object)(object)component6 != (Object)null)
			{
				((LayoutGroup)component6).childAlignment = (TextAnchor)4;
				((HorizontalOrVerticalLayoutGroup)component6).spacing = 0f;
			}
			CreateButton((Transform)(object)val2, "CANCEL", HideSlotActionPanel, 160f, ButtonVisualStyle.Neutral);
			slotActionPanel.SetActive(false);
		}

		private void BuildConfirmationPanel()
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: 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_00b8: 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_0118: Unknown result type (might be due to invalid IL or missing references)
			//IL_012d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0142: Unknown result type (might be due to invalid IL or missing references)
			//IL_0157: Unknown result type (might be due to invalid IL or missing references)
			//IL_017b: Unknown result type (might be due to invalid IL or missing references)
			//IL_019f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a9: Expected O, but got Unknown
			confirmPanel = new GameObject("ConfirmOverlay", new Type[3]
			{
				typeof(RectTransform),
				typeof(Image),
				typeof(LayoutElement)
			}).gameObject;
			RectTransform component = confirmPanel.GetComponent<RectTransform>();
			((Transform)component).SetParent((Transform)(object)rootContainer, false);
			component.anchorMin = Vector2.zero;
			component.anchorMax = Vector2.one;
			component.offsetMin = Vector2.zero;
			component.offsetMax = Vector2.zero;
			confirmPanel.GetComponent<LayoutElement>().ignoreLayout = true;
			Image component2 = confirmPanel.GetComponent<Image>();
			((Graphic)component2).color = new Color(0f, 0f, 0f, 0.62f);
			((Graphic)component2).raycastTarget = true;
			RectTransform component3 = new GameObject("ConfirmPanel", new Type[3]
			{
				typeof(RectTransform),
				typeof(Image),
				typeof(VerticalLayoutGroup)
			}).GetComponent<RectTransform>();
			((Transform)component3).SetParent((Transform)(object)component, false);
			component3.anchorMin = new Vector2(0.5f, 0.5f);
			component3.anchorMax = new Vector2(0.5f, 0.5f);
			component3.pivot = new Vector2(0.5f, 0.5f);
			component3.sizeDelta = new Vector2(620f, 250f);
			((Graphic)((Component)component3).GetComponent<Image>()).color = new Color(0f, 0f, 0f, 0.88f);
			VerticalLayoutGroup component4 = ((Component)component3).GetComponent<VerticalLayoutGroup>();
			((HorizontalOrVerticalLayoutGroup)component4).spacing = 10f;
			((LayoutGroup)component4).padding = new RectOffset(18, 18, 16, 16);
			((HorizontalOrVerticalLayoutGroup)component4).childControlHeight = true;
			((HorizontalOrVerticalLayoutGroup)component4).childControlWidth = true;
			((HorizontalOrVerticalLayoutGroup)component4).childForceExpandHeight = false;
			((HorizontalOrVerticalLayoutGroup)component4).childForceExpandWidth = true;
			CreateLabel((Transform)(object)component3, "ARE YOU SURE?", 28f, (TextAlignmentOptions)514, 24);
			confirmLabel = CreateLabel((Transform)(object)component3, string.Empty, 92f, (TextAlignmentOptions)514, 18);
			((TMP_Text)confirmLabel).textWrappingMode = (TextWrappingModes)1;
			((TMP_Text)confirmLabel).overflowMode = (TextOverflowModes)0;
			RectTransform val = CreateRow((Transform)(object)component3, 42f);
			HorizontalLayoutGroup component5 = ((Component)val).GetComponent<HorizontalLayoutGroup>();
			if ((Object)(object)component5 != (Object)null)
			{
				((LayoutGroup)component5).childAlignment = (TextAnchor)4;
				((HorizontalOrVerticalLayoutGroup)component5).spacing = 12f;
			}
			CreateButton((Transform)(object)val, "CANCEL", HideConfirmation, 144f, ButtonVisualStyle.Neutral);
			CreateButton((Transform)(object)val, "CONFIRM", ConfirmActionClicked, 148f, ButtonVisualStyle.Primary);
			confirmPanel.SetActive(false);
		}

		private void BuildNameEntryPanel()
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: 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_00b8: 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_0118: Unknown result type (might be due to invalid IL or missing references)
			//IL_012d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0142: Unknown result type (might be due to invalid IL or missing references)
			//IL_0157: Unknown result type (might be due to invalid IL or missing references)
			//IL_017b: Unknown result type (might be due to invalid IL or missing references)
			//IL_019f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a9: Expected O, but got Unknown
			nameEntryPanel = new GameObject("SaveNameOverlay", new Type[3]
			{
				typeof(RectTransform),
				typeof(Image),
				typeof(LayoutElement)
			}).gameObject;
			RectTransform component = nameEntryPanel.GetComponent<RectTransform>();
			((Transform)component).SetParent((Transform)(object)rootContainer, false);
			component.anchorMin = Vector2.zero;
			component.anchorMax = Vector2.one;
			component.offsetMin = Vector2.zero;
			component.offsetMax = Vector2.zero;
			nameEntryPanel.GetComponent<LayoutElement>().ignoreLayout = true;
			Image component2 = nameEntryPanel.GetComponent<Image>();
			((Graphic)component2).color = new Color(0f, 0f, 0f, 0.62f);
			((Graphic)component2).raycastTarget = true;
			RectTransform component3 = new GameObject("SaveNamePanel", new Type[3]
			{
				typeof(RectTransform),
				typeof(Image),
				typeof(VerticalLayoutGroup)
			}).GetComponent<RectTransform>();
			((Transform)component3).SetParent((Transform)(object)component, false);
			component3.anchorMin = new Vector2(0.5f, 0.5f);
			component3.anchorMax = new Vector2(0.5f, 0.5f);
			component3.pivot = new Vector2(0.5f, 0.5f);
			component3.sizeDelta = new Vector2(620f, 250f);
			((Graphic)((Component)component3).GetComponent<Image>()).color = new Color(0f, 0f, 0f, 0.88f);
			VerticalLayoutGroup component4 = ((Component)component3).GetComponent<VerticalLayoutGroup>();
			((HorizontalOrVerticalLayoutGroup)component4).spacing = 10f;
			((LayoutGroup)component4).padding = new RectOffset(18, 18, 16, 16);
			((HorizontalOrVerticalLayoutGroup)component4).childControlHeight = true;
			((HorizontalOrVerticalLayoutGroup)component4).childControlWidth = true;
			((HorizontalOrVerticalLayoutGroup)component4).childForceExpandHeight = false;
			((HorizontalOrVerticalLayoutGroup)component4).childForceExpandWidth = true;
			nameEntryTitle = CreateLabel((Transform)(object)component3, "NAME SAVE", 32f, (TextAlignmentOptions)514, 24);
			nameEntryInput = CreateInput((Transform)(object)component3);
			RectTransform val = CreateRow((Transform)(object)component3, 42f);
			HorizontalLayoutGroup component5 = ((Component)val).GetComponent<HorizontalLayoutGroup>();
			if ((Object)(object)component5 != (Object)null)
			{
				((LayoutGroup)component5).childAlignment = (TextAnchor)4;
				((HorizontalOrVerticalLayoutGroup)component5).spacing = 12f;
			}
			CreateButton((Transform)(object)val, "CANCEL", HideNameEntryPanel, 146f, ButtonVisualStyle.Neutral);
			CreateButton((Transform)(object)val, "CONFIRM", ConfirmNameEntry, 146f, ButtonVisualStyle.Primary);
			nameEntryPanel.SetActive(false);
		}

		private void CacheTemplateFeedbackComponents()
		{
			templateClickSfxComponent = null;
			templateClickSfxPlayMethod = null;
			templateHoverFeedbackComponent = null;
			templateHoverOnClickMethod = null;
			if ((Object)(object)templateButton == (Object)null)
			{
				return;
			}
			MonoBehaviour[] componentsInChildren = ((Component)templateButton).GetComponentsInChildren<MonoBehaviour>(true);
			foreach (MonoBehaviour val in componentsInChildren)
			{
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				Type type = ((object)val).GetType();
				if ((Object)(object)templateClickSfxComponent == (Object)null && string.Equals(type.Name, "SFX_PlayOneShot", StringComparison.Ordinal))
				{
					MethodInfo method = type.GetMethod("Play", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, Type.EmptyTypes, null);
					if (method != null)
					{
						templateClickSfxComponent = val;
						templateClickSfxPlayMethod = method;
					}
				}
				if ((Object)(object)templateHoverFeedbackComponent == (Object)null && string.Equals(type.Name, "ButtonHoverFeedback", StringComparison.Ordinal))
				{
					MethodInfo method2 = type.GetMethod("OnClick", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, Type.EmptyTypes, null);
					if (method2 != null)
					{
						templateHoverFeedbackComponent = val;
						templateHoverOnClickMethod = method2;
					}
				}
			}
		}

		private void PlayButtonFeedback(RectTransform rectTransform)
		{
			if (!((Object)(object)rectTransform != (Object)null) || !TriggerObjectClickHooks(((Component)rectTransform).gameObject))
			{
				TriggerTemplateClickHooks();
			}
			if (!((Object)(object)rectTransform == (Object)null))
			{
				if (activePressAnimations.TryGetValue(rectTransform, out var value) && value != null)
				{
					((MonoBehaviour)this).StopCoroutine(value);
					activePressAnimations.Remove(rectTransform);
				}
				Coroutine value2 = ((MonoBehaviour)this).StartCoroutine(AnimateButtonPress(rectTransform));
				activePressAnimations[rectTransform] = value2;
			}
		}

		private bool TriggerObjectClickHooks(GameObject gameObject)
		{
			if ((Object)(object)gameObject == (Object)null)
			{
				return false;
			}
			bool result = false;
			MonoBehaviour[] componentsInChildren = gameObject.GetComponentsInChildren<MonoBehaviour>(true);
			foreach (MonoBehaviour val in componentsInChildren)
			{
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				Type type = ((object)val).GetType();
				if (string.Equals(type.Name, "ButtonHoverFeedback", StringComparison.Ordinal))
				{
					MethodInfo method = type.GetMethod("OnClick", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, Type.EmptyTypes, null);
					if (TryInvokeClickMethod(val, method))
					{
						result = true;
					}
				}
				else if (string.Equals(type.Name, "SFX_PlayOneShot", StringComparison.Ordinal))
				{
					MethodInfo method2 = type.GetMethod("Play", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, Type.EmptyTypes, null);
					if (TryInvokeClickMethod(val, method2))
					{
						result = true;
					}
				}
			}
			return result;
		}

		private bool TriggerTemplateClickHooks()
		{
			bool result = false;
			if (TryInvokeClickMethod(templateHoverFeedbackComponent, templateHoverOnClickMethod))
			{
				result = true;
			}
			if (TryInvokeClickMethod(templateClickSfxComponent, templateClickSfxPlayMethod))
			{
				result = true;
			}
			return result;
		}

		private static bool TryInvokeClickMethod(MonoBehaviour behaviour, MethodInfo method)
		{
			if ((Object)(object)behaviour == (Object)null || method == null)
			{
				return false;
			}
			try
			{
				method.Invoke(behaviour, null);
				return true;
			}
			catch
			{
				return false;
			}
		}

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

		private void StopAllPressAnimations()
		{
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			foreach (KeyValuePair<RectTransform, Coroutine> activePressAnimation in activePressAnimations)
			{
				if (activePressAnimation.Value != null)
				{
					((MonoBehaviour)this).StopCoroutine(activePressAnimation.Value);
				}
				if ((Object)(object)activePressAnimation.Key != (Object)null)
				{
					((Transform)activePressAnimation.Key).localScale = Vector3.one;
				}
			}
			activePressAnimations.Clear();
		}

		private Scrollbar CreateVerticalScrollbar(Transform parent)
		{
			//IL_0032: 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_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_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: 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_014e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0162: 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_0182: Unknown result type (might be due to invalid IL or missing references)
			//IL_0197: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bd: Unknown result type (might be due to invalid IL or missing references)
			RectTransform component = new GameObject("Scrollbar", new Type[3]
			{
				typeof(RectTransform),
				typeof(Image),
				typeof(Scrollbar)
			}).GetComponent<RectTransform>();
			((Transform)component).SetParent(parent, false);
			component.anchorMin = new Vector2(1f, 0f);
			component.anchorMax = new Vector2(1f, 1f);
			component.pivot = new Vector2(1f, 0.5f);
			component.offsetMin = new Vector2(-18f, 10f);
			component.offsetMax = new Vector2(-6f, -10f);
			((Graphic)((Component)component).GetComponent<Image>()).color = new Color(0f, 0f, 0f, 0.32f);
			RectTransform component2 = new GameObject("Sliding Area", new Type[1] { typeof(RectTransform) }).GetComponent<RectTransform>();
			((Transform)component2).SetParent((Transform)(object)component, false);
			component2.anchorMin = Vector2.zero;
			component2.anchorMax = Vector2.one;
			component2.offsetMin = Vector2.zero;
			component2.offsetMax = Vector2.zero;
			RectTransform component3 = new GameObject("Handle", new Type[2]
			{
				typeof(RectTransform),
				typeof(Image)
			}).GetComponent<RectTransform>();
			((Transform)component3).SetParent((Transform)(object)component2, false);
			component3.anchorMin = Vector2.zero;
			component3.anchorMax = Vector2.one;
			component3.offsetMin = new Vector2(1f, 1f);
			component3.offsetMax = new Vector2(-1f, -1f);
			Image component4 = ((Component)component3).GetComponent<Image>();
			((Graphic)component4).color = new Color(0.92f, 0.92f, 0.92f, 0.95f);
			Scrollbar component5 = ((Component)component).GetComponent<Scrollbar>();
			((Selectable)component5).targetGraphic = (Graphic)(object)component4;
			component5.handleRect = component3;
			component5.direction = (Direction)2;
			component5.size = 0.28f;
			return component5;
		}

		private RectTransform CreateRow(Transform parent, float minHeight)
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Expected O, but got Unknown
			RectTransform component = new GameObject("Row", new Type[3]
			{
				typeof(RectTransform),
				typeof(HorizontalLayoutGroup),
				typeof(LayoutElement)
			}).GetComponent<RectTransform>();
			((Transform)component).SetParent(parent, false);
			HorizontalLayoutGroup component2 = ((Component)component).GetComponent<HorizontalLayoutGroup>();
			((HorizontalOrVerticalLayoutGroup)component2).spacing = 8f;
			((LayoutGroup)component2).padding = new RectOffset(0, 0, 0, 0);
			((HorizontalOrVerticalLayoutGroup)component2).childControlHeight = true;
			((HorizontalOrVerticalLayoutGroup)component2).childControlWidth = true;
			((HorizontalOrVerticalLayoutGroup)component2).childForceExpandHeight = false;
			((HorizontalOrVerticalLayoutGroup)component2).childForceExpandWidth = false;
			LayoutElement component3 = ((Component)component).GetComponent<LayoutElement>();
			component3.minHeight = minHeight;
			component3.preferredHeight = minHeight;
			return component;
		}

		private TextMeshProUGUI CreateLabel(Transform parent, string text, float minHeight, TextAlignmentOptions alignment, int fontSize)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			RectTransform component = new GameObject("Label", new Type[2]
			{
				typeof(RectTransform),
				typeof(LayoutElement)
			}).GetComponent<RectTransform>();
			((Transform)component).SetParent(parent, false);
			LayoutElement component2 = ((Component)component).GetComponent<LayoutElement>();
			component2.minHeight = minHeight;
			component2.preferredHeight = minHeight;
			component2.flexibleWidth = 1f;
			TextMeshProUGUI val = ((Component)component).gameObject.AddComponent<TextMeshProUGUI>();
			if ((Object)(object)templateButtonText != (Object)null)
			{
				((TMP_Text)val).font = templateButtonText.font;
				((TMP_Text)val).fontSharedMaterial = templateButtonText.fontSharedMaterial;
				((Graphic)val).color = ((Graphic)templateButtonText).color;
			}
			else
			{
				((Graphic)val).color = Color.white;
			}
			((TMP_Text)val).enableAutoSizing = false;
			((TMP_Text)val).fontSize = fontSize;
			((TMP_Text)val).alignment = alignment;
			((TMP_Text)val).textWrappingMode = (TextWrappingModes)0;
			((TMP_Text)val).overflowMode = (TextOverflowModes)1;
			((TMP_Text)val).text = text;
			return val;
		}

		private TMP_InputField CreateInput(Transform parent)
		{
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_012e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bd: Unknown result type (might be due to invalid IL or missing references)
			RectTransform component = new GameObject("SaveNameInput", new Type[4]
			{
				typeof(RectTransform),
				typeof(Image),
				typeof(LayoutElement),
				typeof(TMP_InputField)
			}).GetComponent<RectTransform>();
			((Transform)component).SetParent(parent, false);
			LayoutElement component2 = ((Component)component).GetComponent<LayoutElement>();
			component2.minWidth = 260f;
			component2.preferredWidth = 420f;
			component2.flexibleWidth = 1f;
			component2.minHeight = 42f;
			component2.preferredHeight = 42f;
			((Graphic)((Component)component).GetComponent<Image>()).color = new Color(0.06f, 0.1f, 0.13f, 1f);
			Outline obj = ((Component)component).gameObject.AddComponent<Outline>();
			((Shadow)obj).effectColor = new Color(0.25f, 0.33f, 0.38f, 0.46f);
			((Shadow)obj).effectDistance = new Vector2(1f, -1f);
			((Shadow)obj).useGraphicAlpha = true;
			RectTransform component3 = new GameObject("TextArea", new Type[1] { typeof(RectTransform) }).GetComponent<RectTransform>();
			((Transform)component3).SetParent((Transform)(object)component, false);
			component3.anchorMin = Vector2.zero;
			component3.anchorMax = Vector2.one;
			component3.offsetMin = new Vector2(10f, 6f);
			component3.offsetMax = new Vector2(-10f, -6f);
			TextMeshProUGUI val = CreateTextElement((Transform)(object)component3, "InputText");
			((TMP_Text)val).alignment = (TextAlignmentOptions)513;
			((TMP_Text)val).text = string.Empty;
			TextMeshProUGUI val2 = CreateTextElement((Transform)(object)component3, "Placeholder");
			((TMP_Text)val2).alignment = (TextAlignmentOptions)513;
			((TMP_Text)val2).text = "Save name";
			((Graphic)val2).color = new Color(0.7f, 0.8f, 0.9f, 0.55f);
			TMP_InputField component4 = ((Component)component).GetComponent<TMP_InputField>();
			component4.textComponent = (TMP_Text)(object)val;
			component4.placeholder = (Graphic)(object)val2;
			component4.lineType = (LineType)0;
			component4.characterLimit = 64;
			return component4;
		}

		private TextMeshProUGUI CreateTextElement(Transform parent, string name)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//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_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			RectTransform component = new GameObject(name, new Type[1] { typeof(RectTransform) }).GetComponent<RectTransform>();
			((Transform)component).SetParent(parent, false);
			component.anchorMin = Vector2.zero;
			component.anchorMax = Vector2.one;
			component.offsetMin = Vector2.zero;
			component.offsetMax = Vector2.zero;
			TextMeshProUGUI val = ((Component)component).gameObject.AddComponent<TextMeshProUGUI>();
			if ((Object)(object)templateButtonText != (Object)null)
			{
				((TMP_Text)val).font = templateButtonText.font;
				((TMP_Text)val).fontSharedMaterial = templateButtonText.fontSharedMaterial;
				((Graphic)val).color = ((Graphic)templateButtonText).color;
			}
			else
			{
				((Graphic)val).color = Color.white;
			}
			((TMP_Text)val).enableAutoSizing = false;
			((TMP_Text)val).fontSize = 20f;
			((TMP_Text)val).richText = false;
			return val;
		}

		private Button CreateButton(Transform parent, string label, Action action, float minWidth)
		{
			return CreateButton(parent, label, action, minWidth, ButtonVisualStyle.Secondary);
		}

		private Button CreateButton(Transform parent, string label, Action action, float minWidth, ButtonVisualStyle style)
		{
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Expected O, but got Unknown
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: 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_0192: Unknown result type (might be due to invalid IL or missing references)
			//IL_019d: 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_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01df: Expected O, but got Unknown
			float num = 40f;
			GameObject val;
			Button component;
			if ((Object)(object)templateButton != (Object)null)
			{
				val = Object.Instantiate<GameObject>(((Component)templateButton).gameObject, parent, false);
				component = val.GetComponent<Button>();
				RemoveLocalizedTextComponents(val);
				Transform transform = ((Component)templateButton).transform;
				RectTransform val2 = (RectTransform)(object)((transform is RectTransform) ? transform : null);
				if ((Object)(object)val2 != (Object)null)
				{
					Rect rect = val2.rect;
					if (((Rect)(ref rect)).height > 0f)
					{
						rect = val2.rect;
						num = Mathf.Clamp(((Rect)(ref rect)).height, 34f, 54f);
					}
				}
			}
			else
			{
				val = new GameObject("Button", new Type[3]
				{
					typeof(RectTransform),
					typeof(Image),
					typeof(Button)
				});
				((Transform)val.GetComponent<RectTransform>()).SetParent(parent, false);
				Image component2 = val.GetComponent<Image>();
				((Graphic)component2).color = new Color(0.14f, 0.36f, 0.31f, 0.98f);
				component2.type = (Type)1;
				component = val.GetComponent<Button>();
			}
			ApplyButtonVisualStyle(component, style);
			LayoutElement val3 = val.GetComponent<LayoutElement>();
			if ((Object)(object)val3 == (Object)null)
			{
				val3 = val.AddComponent<LayoutElement>();
			}
			val3.minWidth = Mathf.Max(80f, minWidth * 0.7f);
			val3.preferredWidth = minWidth;
			val3.minHeight = num;
			val3.preferredHeight = num;
			val3.flexibleWidth = 0f;
			SetButtonText(val, label);
			ApplyButtonLabelStyle(val, style);
			Navigation navigation = ((Selectable)component).navigation;
			((Navigation)(ref navigation)).mode = (Mode)0;
			((Selectable)component).navigation = navigation;
			((UnityEventBase)component.onClick).RemoveAllListeners();
			if (action != null)
			{
				RectTransform buttonRect = default(RectTransform);
				ref RectTransform reference = ref buttonRect;
				Transform transform2 = val.transform;
				reference = (RectTransform)(object)((transform2 is RectTransform) ? transform2 : null);
				((UnityEvent)component.onClick).AddListener((UnityAction)delegate
				{
					if ((Object)(object)EventSystem.current != (Object)null)
					{
						EventSystem.current.SetSelectedGameObject((GameObject)null);
					}
					PlayButtonFeedback(buttonRect);
					action();
				});
			}
			AttachButtonTextColorState(val, component);
			return component;
		}

		private void ApplyButtonLabelStyle(GameObject buttonObject, ButtonVisualStyle style)
		{
			//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_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_012d: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)buttonObject == (Object)null)
			{
				return;
			}
			Color buttonLabelColor = GetButtonLabelColor(style);
			TMP_FontAsset val = (((Object)(object)templateButtonText != (Object)null) ? templateButtonText.font : null);
			Material val2 = (((Object)(object)templateButtonText != (Object)null) ? templateButtonText.fontSharedMaterial : null);
			FontStyles fontStyle = (FontStyles)(((Object)(object)templateButtonText != (Object)null) ? (templateButtonText.fontStyle & -2) : 0);
			TMP_Text[] componentsInChildren = buttonObject.GetComponentsInChildren<TMP_Text>(true);
			foreach (TMP_Text val3 in componentsInChildren)
			{
				if (!((Object)(object)val3 == (Object)null))
				{
					if ((Object)(object)val != (Object)null)
					{
						val3.font = val;
					}
					if ((Object)(object)val2 != (Object)null)
					{
						val3.fontSharedMaterial = val2;
					}
					((Graphic)val3).color = buttonLabelColor;
					val3.fontStyle = fontStyle;
					val3.enableAutoSizing = true;
					val3.fontSizeMin = 11f;
					val3.fontSizeMax = 18f;
					val3.textWrappingMode = (TextWrappingModes)0;
					val3.overflowMode = (TextOverflowModes)1;
					val3.alignment = (TextAlignmentOptions)514;
				}
			}
			Text[] componentsInChildren2 = buttonObject.GetComponentsInChildren<Text>(true);
			foreach (Text val4 in componentsInChildren2)
			{
				if (!((Object)(object)val4 == (Object)null))
				{
					((Graphic)val4).color = buttonLabelColor;
					val4.fontStyle = (FontStyle)0;
					val4.resizeTextForBestFit = true;
					val4.resizeTextMinSize = 11;
					val4.resizeTextMaxSize = 18;
					val4.horizontalOverflow = (HorizontalWrapMode)1;
					val4.verticalOverflow = (VerticalWrapMode)0;
					val4.alignment = (TextAnchor)4;
				}
			}
		}

		private static Color GetButtonLabelColor(ButtonVisualStyle style)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return Color.white;
		}

		private static void AttachButtonTextColorState(GameObject buttonObject, Button button)
		{
			if (!((Object)(object)buttonObject == (Object)null) && !((Object)(object)button == (Object)null))
			{
				ButtonTextColorState buttonTextColorState = buttonObject.GetComponent<ButtonTextColorState>();
				if ((Object)(object)buttonTextColorState == (Object)null)
				{
					buttonTextColorState = buttonObject.AddComponent<ButtonTextColorState>();
				}
				buttonTextColorState.Bind(button);
			}
		}

		private static void RemoveLocalizedTextComponents(GameObject buttonObject)
		{
			if ((Object)(object)buttonObject == (Object)null)
			{
				return;
			}
			MonoBehaviour[] componentsInChildren = buttonObject.GetComponentsInChildren<MonoBehaviour>(true);
			foreach (MonoBehaviour val in componentsInChildren)
			{
				if (!((Object)(object)val == (Object)null) && string.Equals(((object)val).GetType().Name, "LocalizedText", StringComparison.Ordinal))
				{
					Object.Destroy((Object)(object)val);
				}
			}
		}

		private void ApplyButtonVisualStyle(Button button, ButtonVisualStyle style)
		{
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: 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_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: 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)
			//IL_0060: 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)
			//IL_016e: Unknown result type (might be due to invalid IL or missing references)
			//IL_018e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0201: 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_0241: Unknown result type (might be due to invalid IL or missing references)
			//IL_024f: Unknown result type (might be due to invalid IL or missing references)
			//IL_026f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0294: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0302: Unknown result type (might be due to invalid IL or missing references)
			//IL_0327: Unknown result type (might be due to invalid IL or missing references)
			//IL_0347: Unknown result type (might be due to invalid IL or missing references)
			//IL_0367: Unknown result type (might be due to invalid IL or missing references)
			//IL_0375: Unknown result type (might be due to invalid IL or missing references)
			//IL_0395: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_03bc: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)button == (Object)null)
			{
				return;
			}
			((Selectable)button).transition = (Transition)1;
			if ((Object)(object)((Selectable)button).targetGraphic == (Object)null)
			{
				((Selectable)button).targetGraphic = (Graphic)(object)((Component)button).GetComponent<Image>();
			}
			if ((Object)(object)templateButton != (Object)null)
			{
				((Selectable)button).colors = ((Selectable)templateButton).colors;
			}
			else
			{
				Graphic targetGraphic = ((Selectable)button).targetGraphic;
				if ((Object)(object)targetGraphic != (Object)null)
				{
					targetGraphic.color = Color.white;
				}
				ColorBlock colors = ((Selectable)button).colors;
				((ColorBlock)(ref colors)).colorMultiplier = 1f;
				((ColorBlock)(ref colors)).fadeDuration = 0.08f;
				((ColorBlock)(ref colors)).normalColor = new Color(0.95f, 0.95f, 0.95f, 1f);
				((ColorBlock)(ref colors)).highlightedColor = new Color(1f, 1f, 1f, 1f);
				((ColorBlock)(ref colors)).pressedColor = new Color(0.82f, 0.82f, 0.82f, 1f);
				((ColorBlock)(ref colors)).selectedColor = ((ColorBlock)(ref colors)).highlightedColor;
				((ColorBlock)(ref colors)).disabledColor = new Color(0.62f, 0.62f, 0.62f, 0.84f);
				((Selectable)button).colors = colors;
			}
			ColorBlock colors2 = ((Selectable)button).colors;
			((ColorBlock)(ref colors2)).colorMultiplier = 1f;
			((ColorBlock)(ref colors2)).fadeDuration = 0.08f;
			switch (style)
			{
			case ButtonVisualStyle.Primary:
				((ColorBlock)(ref colors2)).normalColor = new Color(0.54f, 0.82f, 0.49f, 1f);
				((ColorBlock)(ref colors2)).highlightedColor = new Color(0.61f, 0.88f, 0.56f, 1f);
				((ColorBlock)(ref colors2)).pressedColor = new Color(0.44f, 0.67f, 0.4f, 1f);
				((ColorBlock)(ref colors2)).selectedColor = ((ColorBlock)(ref colors2)).highlightedColor;
				((ColorBlock)(ref colors2)).disabledColor = new Color(0.38f, 0.48f, 0.35f, 0.74f);
				break;
			case ButtonVisualStyle.Secondary:
				((ColorBlock)(ref colors2)).normalColor = new Color(0.44f, 0.66f, 0.88f, 1f);
				((ColorBlock)(ref colors2)).highlightedColor = new Color(0.52f, 0.74f, 0.95f, 1f);
				((ColorBlock)(ref colors2)).pressedColor = new Color(0.35f, 0.53f, 0.72f, 1f);
				((ColorBlock)(ref colors2)).selectedColor = ((ColorBlock)(ref colors2)).highlightedColor;
				((ColorBlock)(ref colors2)).disabledColor = new Color(0.33f, 0.4f, 0.49f, 0.74f);
				break;
			case ButtonVisualStyle.Neutral:
				((ColorBlock)(ref colors2)).normalColor = new Color(0.7f, 0.7f, 0.7f, 1f);
				((ColorBlock)(ref colors2)).highlightedColor = new Color(0.78f, 0.78f, 0.78f, 1f);
				((ColorBlock)(ref colors2)).pressedColor = new Color(0.58f, 0.58f, 0.58f, 1f);
				((ColorBlock)(ref colors2)).selectedColor = ((ColorBlock)(ref colors2)).highlightedColor;
				((ColorBlock)(ref colors2)).disabledColor = new Color(0.44f, 0.44f, 0.44f, 0.74f);
				break;
			case ButtonVisualStyle.Danger:
				((ColorBlock)(ref colors2)).normalColor = new Color(0.86f, 0.4f, 0.4f, 1f);
				((ColorBlock)(ref colors2)).highlightedColor = new Color(0.92f, 0.48f, 0.48f, 1f);
				((ColorBlock)(ref colors2)).pressedColor = new Color(0.7f, 0.3f, 0.3f, 1f);
				((ColorBlock)(ref colors2)).selectedColor = ((ColorBlock)(ref colors2)).highlightedColor;
				((ColorBlock)(ref colors2)).disabledColor = new Color(0.49f, 0.3f, 0.3f, 0.74f);
				break;
			}
			((Selectable)button).colors = colors2;
			if ((Object)(object)((Selectable)button).targetGraphic != (Object)null)
			{
				((Selectable)button).targetGraphic.color = ((ColorBlock)(ref colors2)).normalColor;
			}
		}

		private void SetButtonText(GameObject buttonObject, string text)
		{
			//IL_0054: 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)
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: 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_0194: 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)
			if ((Object)(object)buttonObject == (Object)null)
			{
				return;
			}
			TMP_Text[] componentsInChildren = buttonObject.GetComponentsInChildren<TMP_Text>(true);
			bool flag = false;
			foreach (TMP_Text val in componentsInChildren)
			{
				if (!((Object)(object)val == (Object)null))
				{
					val.text = text;
					val.enableAutoSizing = true;
					val.fontSizeMin = 11f;
					val.fontSizeMax = 18f;
					val.fontStyle = (FontStyles)(val.fontStyle & -2);
					val.overflowMode = (TextOverflowModes)1;
					val.textWrappingMode = (TextWrappingModes)0;
					flag = true;
				}
			}
			Text[] componentsInChildren2 = buttonObject.GetComponentsInChildren<Text>(true);
			foreach (Text val2 in componentsInChildren2)
			{
				if (!((Object)(object)val2 == (Object)null))
				{
					val2.text = text;
					val2.resizeTextForBestFit = true;
					val2.resizeTextMinSize = 11;
					val2.resizeTextMaxSize = 18;
					val2.fontStyle = (FontStyle)0;
					val2.horizontalOverflow = (HorizontalWrapMode)1;
					val2.verticalOverflow = (VerticalWrapMode)0;
					flag = true;
				}
			}
			if (!flag)
			{
				RectTransform component = new GameObject("Text", new Type[1] { typeof(RectTransform) }).GetComponent<RectTransform>();
				((Transform)component).SetParent(buttonObject.transform, false);
				component.anchorMin = Vector2.zero;
				component.anchorMax = Vector2.one;
				component.offsetMin = Vector2.zero;
				component.offsetMax = Vector2.zero;
				TextMeshProUGUI val3 = ((Component)component).gameObject.AddComponent<TextMeshProUGUI>();
				if ((Object)(object)templateButtonText != (Object)null)
				{
					((TMP_Text)val3).font = templateButtonText.font;
					((TMP_Text)val3).fontSharedMaterial = templateButtonText.fontSharedMaterial;
					((Graphic)val3).color = ((Graphic)templateButtonText).color;
				}
				else
				{
					((Graphic)val3).color = Color.white;
				}
				((TMP_Text)val3).alignment = (TextAlignmentOptions)514;
				((TMP_Text)val3).enableAutoSizing = true;
				((TMP_Text)val3).fontSizeMin = 11f;
				((TMP_Text)val3).fontSizeMax = 18f;
				((TMP_Text)val3).fontStyle = (FontStyles)0;
				((TMP_Text)val3).overflowMode = (TextOverflowModes)1;
				((TMP_Text)val3).textWrappingMode = (TextWrappingModes)0;
				((TMP_Text)val3).text = text;
				ApplyButtonLabelStyle(buttonObject, ButtonVisualStyle.Secondary);
			}
		}

		private static string GetDisplaySaveName(SaveListEntry entry)
		{
			if (entry != null && entry.metadata != null && !string.IsNullOrWhiteSpace(entry.metadata.saveName))
			{
				return PrettySaveName(entry.metadata.saveName.Trim());
			}
			if (entry == null || string.IsNullOrWhiteSpace(entry.fileName))
			{
				return "Unnamed Save";
			}
			string fileName = entry.fileName;
			fileName = ((!fileName.EndsWith(".peaksave.json", StringComparison.OrdinalIgnoreCase)) ? Path.GetFileNameWithoutExtension(fileName) : fileName.Substring(0, fileName.Length - ".peaksave.json".Length));
			if (!string.IsNullOrWhiteSpace(fileName))
			{
				return PrettySaveName(fileName);
			}
			return "Unnamed Save";
		}

		private static string PrettySaveName(string name)
		{
			if (string.IsNullOrWhiteSpace(name))
			{
				return "Unnamed Save";
			}
			string text = name.Trim();
			if (text.EndsWith(".peaksave.json", StringComparison.OrdinalIgnoreCase))
			{
				text = text.Substring(0, text.Length - ".peaksave.json".Length);
			}
			else if (text.EndsWith(".json", StringComparison.OrdinalIgnoreCase))
			{
				text = text.Substring(0, text.Length - ".json".Length);
			}
			else if (text.EndsWith(".peaksave", StringComparison.OrdinalIgnoreCase))
			{
				text = text.Substring(0, text.Length - ".peaksave".Length);
			}
			if (string.IsNullOrWhiteSpace(text))
			{
				text = "Unnamed Save";
			}
			if (text.StartsWith("quicksave_", StringComparison.OrdinalIgnoreCase) || text.StartsWith("quit_save_", StringComparison.OrdinalIgnoreCase))
			{
				return "Quick Save";
			}
			if (text.StartsWith("autosave", StringComparison.OrdinalIgnoreCase))
			{
				return "Autosave";
			}
			return text;
		}

		private static string FormatSavedTime(SaveListEntry entry)
		{
			if (entry == null)
			{
				return "Saved: -";
			}
			DateTime dateTime = entry.fileTime;
			if (entry.metadata != null && entry.metadata.savedAtUtc != default(DateTime))
			{
				dateTime = entry.metadata.savedAtUtc.ToLocalTime();
			}
			return "Saved: " + dateTime.ToString("M/d/yyyy h:mm:ss tt", CultureInfo.InvariantCulture);
		}

		private static string FormatLevelDisplayName(SaveMetadata metadata)
		{
			if (metadata == null)
			{
				return "-";
			}
			if (metadata.levelNumber.HasValue)
			{
				return "Level " + metadata.levelNumber.Value.ToString(CultureInfo.InvariantCulture);
			}
			string levelName = metadata.levelName;
			if (string.IsNullOrWhiteSpace(levelName))
			{
				return "-";
			}
			if (levelName.StartsWith("Level_", StringComparison.OrdinalIgnoreCase) && int.TryParse(levelName.Substring("Level_".Length), NumberStyles.Integer, CultureInfo.InvariantCulture, out var result))
			{
				return "Level " + result.ToString(CultureInfo.InvariantCulture);
			}
			return levelName.Replace('_', ' ');
		}

		private void RebuildSaveRows(string preferredPath = null)
		{
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)saveListContent == (Object)null || (Object)(object)plugin == (Object)null)
			{
				return;
			}
			for (int num = ((Transform)saveListContent).childCount - 1; num >= 0; num--)
			{
				Object.Destroy((Object)(object)((Component)((Transform)saveListContent).GetChild(num)).gameObject);
			}
			displayedEntries.Clear();
			displayedSlotBackgrounds.Clear();
			displayedSlotOutlines.Clear();
			displayedSlotTitles.Clear();
			displayedEntries.AddRange(plugin.UiGetSaveEntries());
			if (displayedEntries.Count == 0)
			{
				selectedSaveIndex = -1;
				((Graphic)CreateLabel((Transform)(object)saveListContent, "No save files found.", 42f, (TextAlignmentOptions)513, 17)).color = (((Object)(object)templateButtonText != (Object)null) ? ((Graphic)templateButtonText).color : Color.white);
				HideSlotActionPanel();
				return;
			}
			int num2 = -1;
			if (!string.IsNullOrWhiteSpace(preferredPath))
			{
				num2 = displayedEntries.FindIndex((SaveListEntry entry) => string.Equals(entry.fullPath, preferredPath, StringComparison.OrdinalIgnoreCase));
			}
			if (num2 < 0 && selectedSaveIndex >= 0 && selectedSaveIndex < displayedEntries.Count)
			{
				num2 = selectedSaveIndex;
			}
			if (num2 < 0)
			{
				num2 = 0;
			}
			for (int i = 0; i < displayedEntries.Count; i++)
			{
				BuildSaveSlot(i, displayedEntries[i]);
			}
			SelectSave(num2);
		}

		private void BuildSaveSlot(int slotIndex, SaveListEntry entry)
		{
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: Expected O, but got Unknown
			//IL_0148: 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_0170: 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_01b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01de: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01eb: 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_0214: Unknown result type (might be due to invalid IL or missing references)
			//IL_021e: Expected O, but got Unknown
			//IL_02d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0324: Unknown result type (might be due to invalid IL or missing references)
			//IL_0309: Unknown result type (might be due to invalid IL or missing references)
			//IL_03cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_04d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_04c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0542: Unknown result type (might be due to invalid IL or missing references)
			//IL_0535: Unknown result type (might be due to invalid IL or missing references)
			//IL_0589: Unknown result type (might be due to invalid IL or missing references)
			//IL_05be: Unknown result type (might be due to invalid IL or missing references)
			//IL_061c: Unknown result type (might be due to invalid IL or missing references)
			RectTransform slot = new GameObject("SaveSlot", new Type[6]
			{
				typeof(RectTransform),
				typeof(Image),
				typeof(Button),
				typeof(Outline),
				typeof(VerticalLayoutGroup),
				typeof(LayoutElement)
			}).GetComponent<RectTransform>();
			((Transform)slot).SetParent((Transform)(object)saveListContent, false);
			Image component = ((Component)slot).GetComponent<Image>();
			Outline component2 = ((Component)slot).GetComponent<Outline>();
			((Shadow)component2).effectDistance = new Vector2(1f, -1f);
			((Shadow)component2).useGraphicAlpha = true;
			LayoutElement component3 = ((Component)slot).GetComponent<LayoutElement>();
			float preferredHeight = (component3.minHeight = (entry.isCompatible ? 128f : 148f));
			component3.preferredHeight = preferredHeight;
			VerticalLayoutGroup component4 = ((Component)slot).GetComponent<VerticalLayoutGroup>();
			((HorizontalOrVerticalLayoutGroup)component4).spacing = 3f;
			((LayoutGroup)component4).padding = new RectOffset(12, 12, 9, 8);
			((HorizontalOrVerticalLayoutGroup)component4).childControlHeight = true;
			((HorizontalOrVerticalLayoutGroup)component4).childControlWidth = true;
			((HorizontalOrVerticalLayoutGroup)component4).childForceExpandHeight = false;
			((HorizontalOrVerticalLayoutGroup)component4).childForceExpandWidth = true;
			Button component5 = ((Component)slot).GetComponent<Button>();
			((Selectable)component5).transition = (Transition)1;
			ColorBlock colors = default(ColorBlock);
			((ColorBlock)(ref colors)).normalColor = Color.white;
			((ColorBlock)(ref colors)).highlightedColor = new Color(1f, 1f, 1f, 1f);
			((ColorBlock)(ref colors)).pressedColor = new Color(0.92f, 0.92f, 0.92f, 1f);
			((ColorBlock)(ref colors)).selectedColor = new Color(1f, 1f, 1f, 1f);
			((ColorBlock)(ref colors)).disabledColor = Color.white;
			((ColorBlock)(ref colors)).colorMultiplier = 1f;
			((ColorBlock)(ref colors)).fadeDuration = 0.08f;
			((Selectable)component5).colors = colors;
			Navigation navigation = ((Selectable)component5).navigation;
			((Navigation)(ref navigation)).mode = (Mode)0;
			((Selectable)component5).navigation = navigation;
			((UnityEventBase)component5.onClick).RemoveAllListeners();
			((UnityEvent)component5.onClick).AddListener((UnityAction)delegate
			{
				PlayButtonFeedback(slot);
				SelectSave(slotIndex);
			});
			RectTransform val = CreateRow((Transform)(object)slot, 28f);
			HorizontalLayoutGroup component6 = ((Component)val).GetComponent<HorizontalLayoutGroup>();
			((HorizontalOrVerticalLayoutGroup)component6).spacing = 8f;
			((HorizontalOrVerticalLayoutGroup)component6).childForceExpandWidth = false;
			((HorizontalOrVerticalLayoutGroup)component6).childControlWidth = true;
			((HorizontalOrVerticalLayoutGroup)component6).childControlHeight = true;
			string displaySaveName = GetDisplaySaveName(entry);
			TextMeshProUGUI val2 = CreateLabel((Transform)(object)val, displaySaveName, 28f, (TextAlignmentOptions)513, 19);
			((TMP_Text)val2).fontStyle = (FontStyles)0;
			LayoutElement component7 = ((Component)val2).GetComponent<LayoutElement>();
			if ((Object)(object)component7 != (Object)null)
			{
				component7.flexibleWidth = 1f;
			}
			RectTransform component8 = new GameObject("SavedBadge", new Type[3]
			{
				typeof(RectTransform),
				typeof(Image),
				typeof(LayoutElement)
			}).GetComponent<RectTransform>();
			((Transform)component8).SetParent((Transform)(object)val, false);
			((Graphic)((Component)component8).GetComponent<Image>()).color = (entry.isCompatible ? new Color(0f, 0f, 0f, 0.3f) : new Color(0.16f, 0.1f, 0.06f, 0.38f));
			LayoutElement component9 = ((Component)component8).GetComponent<LayoutElement>();
			component9.minWidth = 196f;
			component9.preferredWidth = 196f;
			component9.minHeight = 24f;
			component9.preferredHeight = 24f;
			string text = FormatSavedTime(entry);
			if (text.StartsWith("Saved: ", StringComparison.OrdinalIgnoreCase))
			{
				text = text.Substring("Saved: ".Length);
			}
			((Graphic)CreateLabel((Transform)(object)component8, text, 24f, (TextAlignmentOptions)514, 13)).color = (Color)(((Object)(object)templateButtonText != (Object)null) ? ((Graphic)templateButtonText).color : new Color(0.92f, 0.92f, 0.92f, 0.95f));
			string text2 = FormatLevelDisplayName(entry.metadata);
			string text3 = SaveManagerPlugin.ToDisplaySegmentName((entry.metadata != null) ? entry.metadata.currentSegmentName : "-", (entry.metadata != null) ? entry.metadata.biomeId : string.Empty);
			string text4 = ((entry.metadata != null) ? entry.metadata.levelSeed.ToString(CultureInfo.InvariantCulture) : "-");
			string text5 = ((entry.metadata != null) ? ("Level: " + text2 + "   Segment: " + text3 + "   Seed: " + text4) : "UNKNOWN OR LEGACY SAVE FORMAT");
			((Graphic)CreateLabel((Transform)(object)slot, text5, 22f, (TextAlignmentOptions)513, 14)).color = (Color)(((Object)(object)templateButtonText != (Object)null) ? ((Graphic)templateButtonText).color : new Color(0.9f, 0.9f, 0.9f, 0.92f));
			string text6 = ((entry.metadata != null) ? SaveManagerPlugin.FormatRunSummary(entry.metadata) : "Run: Day -  Time: -  Duration: -");
			((Graphic)CreateLabel((Transform)(object)slot, text6, 21f, (TextAlignmentOptions)513, 13)).color = (Color)(((Object)(object)templateButtonText != (Object)null) ? ((Graphic)templateButtonText).color : new Color(0.86f, 0.86f, 0.86f, 0.9f));
			if (!entry.isCompatible)
			{
				RectTransform component10 = new GameObject("IncompatibleBanner", new Type[3]
				{
					typeof(RectTransform),
					typeof(Image),
					typeof(LayoutElement)
				}).GetComponent<RectTransform>();
				((Transform)component10).SetParent((Transform)(object)slot, false);
				((Graphic)((Component)component10).GetComponent<Image>()).color = new Color(0.26f, 0.16f, 0.08f, 0.72f);
				LayoutElement component11 = ((Component)component10).GetComponent<LayoutElement>();
				component11.minHeight = 24f;
				component11.preferredHeight = 24f;
				((Graphic)CreateLabel((Transform)(object)component10, "INCOMPATIBLE - " + entry.incompatibilityReason, 22f, (TextAlignmentOptions)513, 12)).color = new Color(1f, 0.87f, 0.55f, 0.98f);
			}
			displayedSlotBackgrounds.Add(component);
			displayedSlotOutlines.Add(component2);
			displayedSlotTitles.Add(val2);
		}

		private void SelectSave(int slotIndex)
		{
			if (displayedEntries.Count == 0)
			{
				selectedSaveIndex = -1;
				HideSlotActionPanel();
			}
			else
			{
				selectedSaveIndex = Mathf.Clamp(slotIndex, 0, displayedEntries.Count - 1);
				RefreshSlotSelectionState();
				ShowSlotActionPanel();
			}
		}

		private void RefreshSlotSelectionState()
		{
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_019d: 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_0158: 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_01ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_01df: Unknown result type (might be due to invalid IL or missing references)
			for (int i = 0; i < displayedEntries.Count; i++)
			{
				SaveListEntry saveListEntry = displayedEntries[i];
				bool flag = i == selectedSaveIndex;
				Image val = ((i < displayedSlotBackgrounds.Count) ? displayedSlotBackgrounds[i] : null);
				Outline val2 = ((i < displayedSlotOutlines.Count) ? displayedSlotOutlines[i] : null);
				TextMeshProUGUI val3 = ((i < displayedSlotTitles.Count) ? displayedSlotTitles[i] : null);
				if ((Object)(object)val != (Object)null)
				{
					if (flag)
					{
						((Graphic)val).color = (saveListEntry.isCompatible ? new Color(0.13f, 0.14f, 0.17f, 0.95f) : new Color(0.22f, 0.16f, 0.11f, 0.95f));
					}
					else
					{
						((Graphic)val).color = (saveListEntry.isCompatible ? new Color(0.08f, 0.09f, 0.11f, 0.88f) : new Color(0.16f, 0.12f, 0.08f, 0.86f));
					}
				}
				if ((Object)(object)val2 != (Object)null)
				{
					if (flag)
					{
						((Shadow)val2).effectColor = (saveListEntry.isCompatible ? new Color(0.9f, 0.9f, 0.9f, 0.45f) : new Color(0.92f, 0.82f, 0.64f, 0.48f));
					}
					else
					{
						((Shadow)val2).effectColor = (saveListEntry.isCompatible ? new Color(0.55f, 0.55f, 0.55f, 0.22f) : new Color(0.6f, 0.5f, 0.34f, 0.22f));
					}
				}
				if ((Object)(object)val3 != (Object)null)
				{
					((Graphic)val3).color = (Color)((!flag) ? new Color(0.9f, 0.9f, 0.9f, 0.95f) : (((Object)(object)templateButtonText != (Object)null) ? ((Graphic)templateButtonText).color : Color.white));
				}
			}
		}

		private SaveListEntry GetSelectedEntry()
		{
			if (selectedSaveIndex < 0 || selectedSaveIndex >= displayedEntries.Count)
			{
				return null;
			}
			return displayedEntries[selectedSaveIndex];
		}

		private void ShowSlotActionPanel()
		{
			if (!((Object)(object)slotActionPanel == (Object)null) && GetSelectedEntry() != null)
			{
				UpdateSlotActionPanelState();
				slotActionPanel.transform.SetAsLastSibling();
				slotActionPanel.SetActive(true);
			}
		}

		private void HideSlotActionPanel()
		{
			if ((Object)(object)slotActionPanel != (Object)null)
			{
				slotActionPanel.SetActive(false);
			}
		}

		private void UpdateSlotActionPanelState()
		{
			if ((Object)(object)slotActionPanel == (Object)null || !slotActionPanel.activeSelf)
			{
				return;
			}
			SaveListEntry selectedEntry = GetSelectedEntry();
			if (selectedEntry == null)
			{
				HideSlotActionPanel();
				return;
			}
			bool flag = (Object)(object)plugin != (Object)null && plugin.UiIsLoading();
			bool flag2 = (Object)(object)plugin != (Object)null && plugin.UiCanSaveNow();
			bool flag3 = (Object)(object)plugin != (Object)null && plugin.UiHasPendingQuitSaveDecision();
			string displaySaveName = GetDisplaySaveName(selectedEntry);
			if ((Object)(object)slotActionLabel != (Object)null)
			{
				if (flag3)
				{
					((TMP_Text)slotActionLabel).text = "'" + displaySaveName + "'\nChoose how to finish Quit & Save.";
				}
				else if (selectedEntry.isCompatible)
				{
					((TMP_Text)slotActionLabel).text = "'" + displaySaveName + "'\nChoose an action for this save.";
				}
				else
				{
					string text = (string.IsNullOrWhiteSpace(selectedEntry.incompatibilityReason) ? "Incompatible save format." : selectedEntry.incompatibilityReason);
					((TMP_Text)slotActionLabel).text = "'" + displaySaveName + "'\nINCOMPATIBLE SAVE: " + text;
				}
			}
			if ((Object)(object)loadSelectedButton != (Object)null)
			{
				SetButtonText(((Component)loadSelectedButton).gameObject, flag3 ? "OVERWRITE & QUIT" : "LOAD");
				ApplyButtonLabelStyle(((Component)loadSelectedButton).gameObject, flag3 ? ButtonVisualStyle.Danger : ButtonVisualStyle.Primary);
				ApplyButtonVisualStyle(loadSelectedButton, flag3 ? ButtonVisualStyle.Danger : ButtonVisualStyle.Primary);
				((Selectable)loadSelectedButton).interactable = (flag3 ? (!flag && flag2) : (!flag && selectedEntry.isCompatible));
			}
			if ((Object)(object)overwriteSelectedButton != (Object)null)
			{
				SetButtonText(((Component)overwriteSelectedButton).gameObject, flag3 ? "SAVE & QUIT" : "OVERWRITE");
				ApplyButtonLabelStyle(((Component)overwriteSelectedButton).gameObject, ButtonVisualStyle.Secondary);
				ApplyButtonVisualStyle(overwriteSelectedButton, ButtonVisualStyle.Secondary);
				((Selectable)overwriteSelectedButton).interactable = !flag && flag2;
			}
			if ((Object)(object)deleteSelectedButton != (Object)null)
			{
				bool flag4 = !flag3;
				((Component)deleteSelectedButton).gameObject.SetActive(flag4);
				if (flag4)
				{
					SetButtonText(((Component)deleteSelectedButton).gameObject, "DELETE");
					ApplyButtonLabelStyle(((Component)deleteSelectedButton).gameObject, ButtonVisualStyle.Danger);
					ApplyButtonVisualStyle(deleteSelectedButton, ButtonVisualStyle.Danger);
					((Selectable)deleteSelectedButton).interactable = !flag;
				}
			}
		}

		private void LoadSelectedClicked()
		{
			if ((Object)(object)plugin == (Object)null)
			{
				return;
			}
			if (plugin.UiHasPendingQuitSaveDecision())
			{
				OverwriteAndQuitClicked();
				return;
			}
			SaveListEntry selectedEntry = GetSelectedEntry();
			if (selectedEntry != null && selectedEntry.isCompatible)
			{
				HideSlotActionPanel();
				plugin.UiLoadSave(selectedEntry.fullPath);
			}
		}

		private void OverwriteSelectedClicked()
		{
			if ((Object)(object)plugin == (Object)null)
			{
				return;
			}
			if (plugin.UiHasPendingQuitSaveDecision())
			{
				HideSlotActionPanel();
				SaveAndQuitClicked();
				return;
			}
			SaveListEntry selectedEntry = GetSelectedEntry();
			if (selectedEntry != null)
			{
				string displaySaveName = GetDisplaySaveName(selectedEntry);
				string saveNameHint = ((selectedEntry.metadata != null && !string.IsNullOrWhiteSpace(selectedEntry.metadata.saveName)) ? selectedEntry.metadata.saveName : displaySaveName);
				ShowConfirmation("Overwrite '" + displaySaveName + "' with current run?\nThis will replace the existing save.", delegate
				{
					plugin.UiOverwriteSave(selectedEntry.fullPath, saveNameHint);
					RefreshFromSource();
				});
				HideSlotActionPanel();
			}
		}

		private void DeleteSelectedClicked()
		{
			if ((Object)(object)plugin == (Object)null)
			{
				return;
			}
			if (plugin.UiHasPendingQuitSaveDecision())
			{
				HideSlotActionPanel();
				CancelQuitClicked();
				return;
			}
			SaveListEntry selectedEntry = GetSelectedEntry();
			if (selectedEntry != null)
			{
				string displaySaveName = GetDisplaySaveName(selectedEntry);
				ShowConfirmation("Delete '" + displaySaveName + "' permanently?\nThis cannot be undone.", delegate
				{
					plugin.UiDeleteSave(selectedEntry.fullPath);
					RefreshFromSource();
				});
				HideSlotActionPanel();
			}
		}

		private void QuickSaveClicked()
		{
			if (!((Object)(object)plugin == (Object)null))
			{
				if (!plugin.UiCanSaveNow(showReason: true))
				{
					UpdateStatusLabel();
					return;
				}
				plugin.UiQuickSave();
				RefreshFromSource();
			}
		}

		private void SaveClicked()
		{
			if ((Object)(object)plugin == (Object)null)
			{
				return;
			}
			if (!plugin.UiCanSaveNow(showReason: true))
			{
				UpdateStatusLabel();
				return;
			}
			OpenNameEntryPanel("ENTER SAVE NAME", string.Empty, delegate(string name)
			{
				plugin.UiNamedSave(name);
			});
		}

		private void GoBack()
		{
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Expected O, but got Unknown
			HideSlotActionPanel();
			HideConfirmation();
			HideNameEntryPanel();
			if ((Object)(object)plugin != (Object)null && plugin.UiHasPendingQuitSaveDecision())
			{
				plugin.UiCancelPendingQuit();
			}
			if ((Object)(object)handler != (Object)null && (Object)(object)returnPage != (Object)null)
			{
				handler.TransistionToPage(returnPage, (PageTransistion)new SetActivePageTransistion());
			}
		}

		private void ShowConfirmation(string message, Action action)
		{
			confirmAction = action;
			if ((Object)(object)confirmLabel != (Object)null)
			{
				((TMP_Text)confirmLabel).text = message;
			}
			if ((Object)(object)confirmPanel != (Object)null)
			{
				confirmPanel.transform.SetAsLastSibling();
				confirmPanel.SetActive(true);
			}
		}

		private void ConfirmActionClicked()
		{
			Action action = confirmAction;
			HideConfirmation();
			action?.Invoke();
		}

		private void HideConfirmation()
		{
			confirmAction = null;
			if ((Object)(object)confirmPanel != (Object)null)
			{
				confirmPanel.SetActive(false);
			}
		}

		private void OpenNameEntryPanel(string title, string initialValue, Action<string> onConfirm)
		{
			if ((Object)(object)nameEntryPanel == (Object)null)
			{
				onConfirm?.Invoke(initialValue);
				RefreshFromSource();
				return;
			}
			nameEntryConfirmAction = onConfirm;
			if ((Object)(object)nameEntryTitle != (Object)null)
			{
				((TMP_Text)nameEntryTitle).text = (string.IsNullOrWhiteSpace(title) ? "NAME SAVE" : title);
			}
			if ((Object)(object)nameEntryInput != (Object)null)
			{
				nameEntryInput.text = initialValue ?? string.Empty;
			}
			nameEntryPanel.SetActive(true);
			nameEntryPanel.transform.SetAsLastSibling();
			if ((Object)(object)nameEntryInput != (Object)null)
			{
				nameEntryInput.ActivateInputField();
				((Selectable)nameEntryInput).Select();
			}
		}

		private void ConfirmNameEntry()
		{
			string obj = (((Object)(object)nameEntryInput != (Object)null) ? nameEntryInput.text : string.Empty);
			Action<string> action = nameEntryConfirmAction;
			HideNameEntryPanel();
			action?.Invoke(obj);
			RefreshFromSource();
		}

		private void HideNameEntryPanel()
		{
			nameEntryConfirmAction = null;
			if ((Object)(object)nameEntryPanel != (Object)null)
			{
				nameEntryPanel.SetActive(false);
			}
		}

		private void UpdateStatusLabel()
		{
			if ((Object)(object)statusLabel == (Object)null || (Object)(object)plugin == (Object)null)
			{
				return;
			}
			string text = plugin.UiCurrentStatus();
			if (string.IsNullOrWhiteSpace(text))
			{
				if (plugin.UiHasPendingQuitSaveDecision())
				{
					((TMP_Text)statusLabel).text = "Select a save slot for Overwrite & Quit, or use Save & Quit / Cancel Quit.";
				}
				else
				{
					((TMP_Text)statusLabel).text = "Select a save slot to open Load, Overwrite, or Delete options.";
				}
			}
			else
			{
				((TMP_Text)statusLabel).text = text;
			}
		}

		private void UpdateQuitDecisionRow()
		{
			if (!((Object)(object)quitDecisionRow == (Object)null) && !((Object)(object)plugin == (Object)null))
			{
				bool flag = plugin.UiHasPendingQuitSaveDecision();
				((Component)quitDecisionRow).gameObject.SetActive(flag);
				if ((Object)(object)standardSaveRow != (Object)null)
				{
					((Component)standardSaveRow).gameObject.SetActive(!flag);
				}
			}
		}

		private void QuickSaveAndQuitClicked()
		{
			if (!((Object)(object)plugin == (Object)null))
			{
				plugin.UiQuickSaveAndQuit();
				UpdateQuitDecisionRow();
				UpdateStatusLabel();
			}
		}

		private void SaveAndQuitClicked()
		{
			if (!((Object)(object)plugin == (Object)null))
			{
				OpenNameEntryPanel("ENTER SAVE NAME", string.Empty, delegate(string name)
				{
					plugin.UiNamedSaveAndQuit(name);
				});
				UpdateQuitDecisionRow();
				UpdateStatusLabel();
			}
		}

		private void QuitWithoutSaveClicked()
		{
			if (!((Object)(object)plugin == (Object)null))
			{
				plugin.UiQuitWithoutSaving();
				UpdateQuitDecisionRow();
			}
		}

		private void CancelQuitClicked()
		{
			if (!((Object)(object)plugin == (Object)null))
			{
				plugin.UiCancelPendingQuit();
				UpdateQuitDecisionRow();
			}
		}

		private void OverwriteAndQuitClicked()
		{
			if ((Object)(object)plugin == (Object)null)
			{
				return;
			}
			SaveListEntry selectedEntry = GetSelectedEntry();
			if (selectedEntry == null)
			{
				if ((Object)(object)statusLabel != (Object)null)
				{
					((TMP_Text)statusLabel).text = "Select a save slot, then click Overwrite & Quit.";
				}
				return;
			}
			string displaySaveName = GetDisplaySaveName(selectedEntry);
			string saveNameHint = ((selectedEntry.metadata != null && !string.IsNullOrWhiteSpace(selectedEntry.metadata.saveName)) ? selectedEntry.metadata.saveName : displaySaveName);
			ShowConfirmation("Overwrite '" + displaySaveName + "' and quit to menu?\nThis will replace the existing save.", delegate
			{
				plugin.UiOverwriteSave(selectedEntry.fullPath, saveNameHint);
				if (plugin.UiHasPendingQuitSaveDecision())
				{
					RefreshFromSource();
				}
			});
		}
	}
	internal sealed class ButtonTextColorState : MonoBehaviour
	{
		private static readonly Color EnabledColor = Color.white;

		private static readonly Color DisabledColor = Color.black;

		private Button button;

		private TMP_Text[] tmpTexts = Array.Empty<TMP_Text>();

		private Text[] uiTexts = Array.Empty<Text>();

		private bool hasLastState;

		private bool lastInteractable;

		internal void Bind(Button targetButton)
		{
			button = targetButton;
			RefreshCache();
			Apply(force: true);
		}

		private void Awake()
		{
			if ((Object)(object)button == (Object)null)
			{
				button = ((Component)this).GetComponent<Button>();
			}
			RefreshCache();
		}

		private void OnEnable()
		{
			Apply(force: true);
		}

		private void LateUpdate()
		{
			Apply(force: false);
		}

		private void RefreshCache()
		{
			tmpTexts = ((Component)this).GetComponentsInChildren<TMP_Text>(true);
			uiTexts = ((Component)this).GetComponentsInChildren<Text>(true);
		}

		private void Apply(bool force)
		{
			//IL_0048: 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: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)button == (Object)null)
			{
				return;
			}
			bool flag = ((Selectable)button).IsInteractable();
			if (!force && hasLastState && flag == lastInteractable)
			{
				return;
			}
			hasLastState = true;
			lastInteractable = flag;
			Color color = (flag ? EnabledColor : DisabledColor);
			if (tmpTexts != null)
			{
				for (int i = 0; i < tmpTexts.Length; i++)
				{
					TMP_Text val = tmpTexts[i];
					if ((Object)(object)val != (Object)null)
					{
						((Graphic)val).color = color;
					}
				}
			}
			if (uiTexts == null)
			{
				return;
			}
			for (int j = 0; j < uiTexts.Length; j++)
			{
				Text val2 = uiTexts[j];
				if ((Object)(object)val2 != (Object)null)
				{
					((Graphic)val2).color = color;
				}
			}
		}
	}
	[HarmonyPatch(typeof(PauseMenuMainPage), "Start")]
	internal static class PauseMenuMainPageStartPatch
	{
		private static void Postfix(PauseMenuMainPage __instance)
		{
			SaveManagerPlugin.TryAttachPauseMenuButton(__instance);
		}
	}
	[HarmonyPatch(typeof(PauseMenuMainPage), "OnEnable")]
	internal static class PauseMenuMainPageOnEnablePatch
	{
		private static void Postfix(PauseMenuMainPage __instance)
		{
			SaveManagerPlugin.TryAttachPauseMenuButton(__instance);
		}
	}
	[HarmonyPatch(typeof(PauseMenuMainPage), "OnQuitClicked")]
	internal static class PauseMenuMainPageOnQuitClickedPatch
	{
		private static bool Prefix(PauseMenuMainPage __instance)
		{
			return !SaveManagerPlugin.TryInterceptPauseQuit(__instance);
		}
	}
	[HarmonyPatch(typeof(LevelGeneration), "Generate")]
	internal static class LevelGenerationGeneratePatch
	{
		private static void Prefix(LevelGeneration __instance)
		{
			if (SaveManagerPlugin.TryGetPendingSeed(out var seed))
			{
				__instance.seed = seed;
				Random.InitState(seed);
			}
		}
	}
	[HarmonyPatch(typeof(LevelGeneration), "RandomizeBiomeVariants")]
	internal static class LevelGenerationRandomizeBiomeVariantsPatch
	{
		private static void Prefix()
		{
			if (SaveManagerPlugin.TryGetPendingSeed(out var seed))
			{
				Random.InitState(seed);
			}
		}
	}
	[Serializable]
	public sealed class SaveEnvelope
	{
		public const string SaveMagic = "PEAK_SAVE_MANAGER";

		public const int CurrentFormatVersion = 6;

		public string magic = "PEAK_SAVE_MANAGER";

		public int formatVersion = 6;

		public string pluginGuid;

		public string pluginVersion;

		public SaveMetadata metadata = new SaveMetadata();

		public List<PlayerSnapshot> players = new List<PlayerSnapshot>();

		public List<CampfireSnapshot> campfires = new List<CampfireSnapshot>();

		public List<LuggageSnapshot> luggageStates = new List<LuggageSnapshot>();

		public List<ContainerSnapshot> containerStates = new List<ContainerSnapshot>();

		public List<GroundItemSnapshot> groundItems = new List<GroundItemSnapshot>();

		public List<WorldObjectSnapshot> worldObjects = new List<WorldObjectSnapshot>();
	}
	[Serializable]
	public sealed class SaveMetadata
	{
		public string saveName;

		public DateTime savedAtUtc;

		public string sceneName;

		public string levelName;

		public int? levelNumber;

		public int? dailyLevelIndex;

		public string biomeId;

		public int levelSeed;

		public int currentSegment;

		public string currentSegmentName;

		public int ascent;

		public int playerCount;

		public int? runDay;

		public float? runTimeSeconds;

		public bool? runTimerActive;

		public float? timeOfDay;

		public string inGameTime;
	}
	[Serializable]
	public sealed class PlayerSnapshot
	{
		public string playerName;

		public int actorNumber;

		public Vector3Snapshot position = new Vector3Snapshot();

		public Vector3Snapshot rotation = new Vector3Snapshot();

		public Vector3Snapshot velocity = new Vector3Snapshot();

		public Vector3Snapshot angularVelocity = new Vector3Snapshot();

		public CharacterSnapshot character = new CharacterSnapshot();

		public InventorySnapshot inventory = new InventorySnapshot();
	}
	[Serializable]
	public sealed class CharacterSnapshot
	{
		public bool dead;

		public bool passedOut;

		public bool fullyPassedOut;

		public bool isGrounded;

		public bool isClimbing;

		public bool isRopeClimbing;

		public bool isVineClimbing;

		public bool isSprinting;

		public float currentStamina;

		public float extraStamina;

		public float sinceGrounded;

		public Vector2Snapshot lookValues = new Vector2Snapshot();

		public List<string> checkpointFlagPaths = new List<string>();

		public List<CharacterStatusSnapshot> statuses = new List<CharacterStatusSnapshot>();
	}
	[Serializable]
	public sealed class CharacterStatusSnapshot
	{
		public string statusType;

		public float amount;
	}
	[Serializable]
	public sealed class InventorySnapshot
	{
		public List<ItemSlotSnapshot> mainSlots = new List<ItemSlotSnapshot>();

		public ItemSlotSnapshot tempSlot = ItemSlotSnapshot.Empty();

		public bool hasBackpack;

		public List<ItemSlotSnapshot> backpackSlots = new List<ItemSlotSnapshot>();

		public int? selectedSlotId;

		public int? equippedMainSlotIndex;

		public bool equippedTempSlot;

		public int? equippedBackpackSlotIndex;

		public ushort heldItemId = ushort.MaxValue;
	}
	[Serializable]
	public sealed class ItemSlotSnapshot
	{
		public ushort itemId = ushort.MaxValue;

		public int? itemUses;

		public int? petterItemUses;

		public float? useRemainingPercentage;

		public bool? used;

		public float? fuel;

		public int? cookedAmount;

		public bool? flareActive;

		public float? screamTime;

		public bool? spawnedBees;

		public List<ItemDataEntrySnapshot> dataEntries = new List<ItemDataEntrySnapshot>();

		public static ItemSlotSnapshot Empty()
		{
			return new ItemSlotSnapshot
			{
				itemId = ushort.MaxValue
			};
		}

		public bool HasItem()
		{
			return itemId != ushort.MaxValue;
		}
	}
	[Serializable]
	public sealed class CampfireSnapshot
	{
		public int segmentIndex;

		public string campfireName;

		public int state;

		public float beenBurningFor;

		public int advanceToSegment;
	}
	[Serializable]
	public sealed class LuggageSnapshot
	{
		public string objectName;

		public string objectPath;

		public Vector3Snapshot position = new Vector3Snapshot();

		public int state;

		public bool isRespawnChest;

		public bool respawnChestSpent;

		public bool respawnChestRevivedPlayers;
	}
	[Serializable]
	public sealed class ContainerSnapshot
	{
		public string containerType;

		public string objectName;

		public string objectPath;

		public Vector3Snapshot position = new Vector3Snapshot();

		public int state;

		public bool boolA;

		public bool boolB;

		public float floatA;
	}
	[Serializable]
	public sealed class GroundItemSnapshot
	{
		public ushort itemId = ushort.MaxValue;

		public string objectName;

		public string objectPath;

		public Vector3Snapshot position = new Vector3Snapshot();

		public Vector3Snapshot rotation = new Vector3Snapshot();

		public Vector3Snapshot velocity = new Vector3Snapshot();

		public Vector3Snapshot angularVelocity = new Vector3Snapshot();

		public bool isKinematic;

		public int? itemUses;

		public int? petterItemUses;

		public float? useRemainingPercentage;

		public bool? used;

		public float? fuel;

		public int? cookedAmount;

		public bool? flareActive;

		public float? screamTime;

		public bool? spawnedBees;

		public List<ItemDataEntrySnapshot> dataEntries = new List<ItemDataEntrySnapshot>();
	}
	[Serializable]
	public sealed class WorldObjectSnapshot
	{
		public string kind;

		public string objectName;

		public string objectPath;

		public Vector3Snapshot position = new Vector3Snapshot();

		public Vector3Snapshot rotation = new Vector3Snapshot();

		public bool boolA;

		public float floatA;

		public float floatB;

		public int intA;

		public string stringA;

		public string stringB;

		public List<float> floatListA = new List<float>();
	}
	[Serializable]
	public sealed class ItemDataEntrySnapshot
	{
		public int keyValue;

		public string keyName;

		public string valueType;

		public bool hasValue;

		public int? intValue;

		public float? floatValue;

		public bool? boolValue;

		public string stringValue;

		public Vector4Snapshot colorValue = new Vector4Snapshot();

		public bool hasColorValue;

		public string serializedJson;

		public List<ItemSlotSnapshot> backpackSlots = new List<ItemSlotSnapshot>();
	}
	[Serializable]
	public sealed class Vector3Snapshot
	{
		public float x;

		public float y;

		public float z;

		public Vector3Snapshot()
		{
		}

		public Vector3Snapshot(Vector3 source)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			x = source.x;
			y = source.y;
			z = source.z;
		}

		public Vector3 ToUnity()
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			return new Vector3(x, y, z);
		}
	}
	[Serializable]
	public sealed class Vector2Snapshot
	{
		public float x;

		public float y;

		public Vector2Snapshot()
		{
		}

		public Vector2Snapshot(Vector2 source)
		{
			//IL_0007: 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)
			x = source.x;
			y = source.y;
		}

		public Vector2 ToUnity()
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			return new Vector2(x, y);
		}
	}
	[Serializable]
	public sealed class Vector4Snapshot
	{
		public float x;

		public float y;

		public float z;

		public float w;

		public Vector4Snapshot()
		{
		}

		public Vector4Snapshot(Vector4 source)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			x = source.x;
			y = source.y;
			z = source.z;
			w = source.w;
		}

		public Vector4 ToUnity()
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			return new Vector4(x, y, z, w);
		}
	}
	public sealed class SaveListEntry
	{
		public string fileName;

		public string fullPath;

		public bool isCompatible;

		public string incompatibilityReason;

		public SaveMetadata metadata;

		public DateTime fileTime;

		public long fileSize;
	}
}