using System;
using System.Buffers;
using System.Collections;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using LCReplay.Core;
using LCReplay.Core.Archive;
using LCReplay.Core.Lifecycle;
using LCReplay.Plugin.Capture;
using LCReplay.Plugin.Library;
using LCReplay.Plugin.Playback;
using LCReplay.Plugin.UI;
using Microsoft.CodeAnalysis;
using Newtonsoft.Json;
using TMPro;
using Unity.Collections;
using UnityEngine;
using UnityEngine.Animations;
using UnityEngine.EventSystems;
using UnityEngine.Events;
using UnityEngine.InputSystem;
using UnityEngine.InputSystem.Utilities;
using UnityEngine.Playables;
using UnityEngine.Rendering;
using UnityEngine.SceneManagement;
using UnityEngine.TextCore;
using UnityEngine.TextCore.LowLevel;
using UnityEngine.UI;
using UnityEngine.VFX;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("LCReplay")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyDescription("Local gameplay recorder and isolated free-camera replay for Lethal Company.")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+31677f6cc6ace662863f1d3840f84ade19c50bbc")]
[assembly: AssemblyProduct("LCReplay")]
[assembly: AssemblyTitle("LCReplay")]
[assembly: AssemblyVersion("1.0.0.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[CompilerGenerated]
	[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 LCReplay.Plugin
{
	internal static class AnimationAssetRegistry
	{
		private sealed class Candidate
		{
			internal RuntimeAnimatorController Controller;

			internal Avatar? Avatar;

			internal string Kind = "";
		}

		private static readonly List<Candidate> Candidates = new List<Candidate>();

		private static object? scannedNetworkConfig;

		internal static void Remember(Animator animator, string kind = "")
		{
			if (Object.op_Implicit((Object)(object)animator) && Object.op_Implicit((Object)(object)animator.runtimeAnimatorController))
			{
				if (kind.Length == 0)
				{
					kind = Classify(((Component)animator).gameObject);
				}
				Add(animator.runtimeAnimatorController, animator.avatar, kind);
			}
		}

		private static string Classify(GameObject obj)
		{
			Type type = GameAccess.Type("GameNetcodeStuff.PlayerControllerB");
			if (type != null && (Object.op_Implicit((Object)(object)obj.GetComponentInParent(type)) || Object.op_Implicit((Object)(object)obj.GetComponentInChildren(type, true))))
			{
				return "player";
			}
			Type type2 = GameAccess.Type("EnemyAI");
			if (!(type2 != null) || (!Object.op_Implicit((Object)(object)obj.GetComponentInParent(type2)) && !Object.op_Implicit((Object)(object)obj.GetComponentInChildren(type2, true))))
			{
				return "";
			}
			return "enemy";
		}

		private static void Add(RuntimeAnimatorController controller, Avatar? avatar, string kind)
		{
			if (!Candidates.Any((Candidate candidate) => (Object)(object)candidate.Controller == (Object)(object)controller && (Object)(object)candidate.Avatar == (Object)(object)avatar && candidate.Kind == kind))
			{
				Candidates.Add(new Candidate
				{
					Controller = controller,
					Avatar = avatar,
					Kind = kind
				});
			}
		}

		private static void RememberInstalledPrefabs()
		{
			object obj = GameAccess.Read(GameAccess.Singleton("Unity.Netcode.NetworkManager"), "NetworkConfig");
			if (obj == null || obj == scannedNetworkConfig)
			{
				return;
			}
			object? obj2 = GameAccess.Read(obj, "PlayerPrefab");
			GameObject val = (GameObject)((obj2 is GameObject) ? obj2 : null);
			if (!Object.op_Implicit((Object)(object)val))
			{
				object? obj3 = GameAccess.Read(GameAccess.Singleton("StartOfRound"), "playerPrefab");
				val = (GameObject)((obj3 is GameObject) ? obj3 : null);
			}
			if (Object.op_Implicit((Object)(object)val))
			{
				Animator[] componentsInChildren = val.GetComponentsInChildren<Animator>(true);
				for (int i = 0; i < componentsInChildren.Length; i++)
				{
					Remember(componentsInChildren[i], "player");
				}
			}
			if (!(GameAccess.Read(GameAccess.Read(obj, "Prefabs"), "Prefabs") is IEnumerable enumerable))
			{
				return;
			}
			foreach (object item in enumerable)
			{
				object? obj4 = GameAccess.Read(item, "Prefab");
				GameObject val2 = (GameObject)((obj4 is GameObject) ? obj4 : null);
				if (Object.op_Implicit((Object)(object)val2))
				{
					string kind = Classify(val2);
					Animator[] componentsInChildren = val2.GetComponentsInChildren<Animator>(true);
					for (int i = 0; i < componentsInChildren.Length; i++)
					{
						Remember(componentsInChildren[i], kind);
					}
				}
			}
			scannedNetworkConfig = obj;
		}

		internal static (RuntimeAnimatorController? Controller, Avatar? Avatar) Resolve(string controllerName, string avatarName, string actorKind, IEnumerable<string> recordedClips)
		{
			if (controllerName.Length == 0)
			{
				return (Controller: null, Avatar: null);
			}
			RememberInstalledPrefabs();
			Animator[] array = Resources.FindObjectsOfTypeAll<Animator>();
			foreach (Animator val in array)
			{
				if (Object.op_Implicit((Object)(object)val) && Object.op_Implicit((Object)(object)val.runtimeAnimatorController) && ((Object)val.runtimeAnimatorController).name == controllerName)
				{
					Remember(val);
				}
			}
			RuntimeAnimatorController[] array2 = Resources.FindObjectsOfTypeAll<RuntimeAnimatorController>();
			foreach (RuntimeAnimatorController controller in array2)
			{
				if (Object.op_Implicit((Object)(object)controller) && ((Object)controller).name == controllerName && !Candidates.Any((Candidate candidate) => (Object)(object)candidate.Controller == (Object)(object)controller))
				{
					Add(controller, null, "");
				}
			}
			Candidate[] array3 = Candidates.Where((Candidate candidate) => Object.op_Implicit((Object)(object)candidate.Controller) && ((Object)candidate.Controller).name == controllerName).ToArray();
			if (actorKind == "player" || actorKind == "enemy")
			{
				Candidate[] array4 = array3.Where((Candidate candidate) => candidate.Kind == actorKind).ToArray();
				array3 = ((array4.Length != 0) ? array4 : ((actorKind == "player") ? Array.Empty<Candidate>() : array3.Where((Candidate candidate) => candidate.Kind.Length == 0).ToArray()));
			}
			if (array3.Length == 0)
			{
				return (Controller: null, Avatar: null);
			}
			if (avatarName.Length != 0)
			{
				Candidate[] array5 = array3.Where((Candidate candidate) => Object.op_Implicit((Object)(object)candidate.Avatar) && ((Object)candidate.Avatar).name == avatarName).ToArray();
				if (array5.Length == 0)
				{
					Avatar[] avatars = (from avatar in Resources.FindObjectsOfTypeAll<Avatar>()
						where Object.op_Implicit((Object)(object)avatar) && ((Object)avatar).name == avatarName
						select avatar).Take(2).ToArray();
					if (avatars.Length != 1)
					{
						return (Controller: null, Avatar: null);
					}
					array3 = array3.Where((Candidate candidate) => (Object)(object)candidate.Avatar == (Object)null || (Object)(object)candidate.Avatar == (Object)(object)avatars[0]).ToArray();
					if (array3.Length == 0)
					{
						return (Controller: null, Avatar: null);
					}
					return Select(array3, recordedClips, avatars[0]);
				}
				array3 = array5;
			}
			return Select(array3, recordedClips, null);
		}

		private static (RuntimeAnimatorController? Controller, Avatar? Avatar) Select(Candidate[] candidates, IEnumerable<string> recordedClips, Avatar? fallbackAvatar)
		{
			string[] clips = recordedClips.Where((string name) => !string.IsNullOrEmpty(name)).Distinct<string>(StringComparer.Ordinal).Take(32)
				.ToArray();
			if (candidates.Select((Candidate item) => item.Controller).Distinct().Count() > 1 && clips.Length != 0)
			{
				candidates = candidates.Where(delegate(Candidate candidate2)
				{
					try
					{
						HashSet<string> hashSet = new HashSet<string>(from clip in candidate2.Controller.animationClips
							where Object.op_Implicit((Object)(object)clip)
							select ((Object)clip).name, StringComparer.Ordinal);
						return clips.All(hashSet.Contains);
					}
					catch
					{
						return false;
					}
				}).ToArray();
			}
			RuntimeAnimatorController[] controllers = candidates.Select((Candidate item) => item.Controller).Distinct().ToArray();
			if (controllers.Length != 1)
			{
				return (Controller: null, Avatar: null);
			}
			Candidate candidate = candidates.First((Candidate item) => (Object)(object)item.Controller == (Object)(object)controllers[0]);
			return (Controller: candidate.Controller, Avatar: Object.op_Implicit((Object)(object)candidate.Avatar) ? candidate.Avatar : fallbackAvatar);
		}
	}
	internal static class ItemAssetRegistry
	{
		private sealed class Candidate
		{
			internal string ItemId = "";

			internal AudioClip Clip;
		}

		private sealed class HandCandidate
		{
			internal string Name = "";

			internal bool TwoHandedAnimation;

			internal Vector3 PositionOffset;

			internal Vector3 RotationOffset;
		}

		private static readonly List<Candidate> Candidates = new List<Candidate>();

		private static readonly List<HandCandidate> HandCandidates = new List<HandCandidate>();

		private static readonly Dictionary<string, bool> HandCache = new Dictionary<string, bool>(StringComparer.OrdinalIgnoreCase);

		private static readonly Dictionary<string, float> NextHandScan = new Dictionary<string, float>(StringComparer.OrdinalIgnoreCase);

		private static readonly Dictionary<string, (Vector3 Position, Vector3 Rotation)> HeldPoseCache = new Dictionary<string, (Vector3, Vector3)>(StringComparer.OrdinalIgnoreCase);

		private static readonly Dictionary<string, float> NextHeldPoseScan = new Dictionary<string, float>(StringComparer.OrdinalIgnoreCase);

		private static object? scannedConfig;

		private static void Remember(object? properties)
		{
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: 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_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: 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_00fd: Unknown result type (might be due to invalid IL or missing references)
			if (properties == null)
			{
				return;
			}
			string name = GameAccess.Read(properties, "itemName") as string;
			if (!string.IsNullOrWhiteSpace(name))
			{
				object obj = GameAccess.Read(properties, "twoHandedAnimation");
				if (obj is bool)
				{
					bool twoHanded = (bool)obj;
					obj = GameAccess.Read(properties, "positionOffset");
					if (obj is Vector3)
					{
						Vector3 positionOffset = (Vector3)obj;
						obj = GameAccess.Read(properties, "rotationOffset");
						if (obj is Vector3)
						{
							Vector3 rotationOffset = (Vector3)obj;
							if (GameAccess.Finite(positionOffset) && GameAccess.Finite(rotationOffset) && !HandCandidates.Any((HandCandidate candidate) => candidate.Name == name && candidate.TwoHandedAnimation == twoHanded && candidate.PositionOffset == positionOffset && candidate.RotationOffset == rotationOffset))
							{
								HandCandidates.Add(new HandCandidate
								{
									Name = name,
									TwoHandedAnimation = twoHanded,
									PositionOffset = positionOffset,
									RotationOffset = rotationOffset
								});
							}
						}
					}
				}
			}
			AudioClip clip = default(AudioClip);
			ref AudioClip reference = ref clip;
			object? obj2 = GameAccess.Read(properties, "dropSFX");
			reference = (AudioClip)((obj2 is AudioClip) ? obj2 : null);
			if (Object.op_Implicit((Object)(object)clip))
			{
				string id = GameAccess.Scalar(GameAccess.Read(properties, "itemId")) ?? "";
				if (!Candidates.Any((Candidate candidate) => candidate.ItemId == id && (Object)(object)candidate.Clip == (Object)(object)clip))
				{
					Candidates.Add(new Candidate
					{
						ItemId = id,
						Clip = clip
					});
				}
			}
		}

		private static void Scan()
		{
			object obj = GameAccess.Read(GameAccess.Singleton("Unity.Netcode.NetworkManager"), "NetworkConfig");
			if (obj != null && obj != scannedConfig)
			{
				Type type = GameAccess.Type("GrabbableObject");
				IEnumerable enumerable = GameAccess.Read(GameAccess.Read(obj, "Prefabs"), "Prefabs") as IEnumerable;
				if (type != null && enumerable != null)
				{
					foreach (object item in enumerable)
					{
						object? obj2 = GameAccess.Read(item, "Prefab");
						GameObject val = (GameObject)((obj2 is GameObject) ? obj2 : null);
						if (Object.op_Implicit((Object)(object)val))
						{
							Component componentInChildren = val.GetComponentInChildren(type, true);
							if (Object.op_Implicit((Object)(object)componentInChildren))
							{
								Remember(GameAccess.Read(componentInChildren, "itemProperties"));
							}
						}
					}
				}
				scannedConfig = obj;
			}
			Type type2 = GameAccess.Type("Item");
			if (type2 != null)
			{
				Object[] array = Resources.FindObjectsOfTypeAll(type2);
				for (int i = 0; i < array.Length; i++)
				{
					Remember(array[i]);
				}
			}
		}

		internal static AudioClip? Resolve(string itemId, string clipName)
		{
			if (itemId.Length == 0 && clipName.Length == 0)
			{
				return null;
			}
			AudioClip val = Match(itemId, clipName);
			if ((Object)(object)val != (Object)null)
			{
				return val;
			}
			Scan();
			return Match(itemId, clipName);
		}

		internal static bool? ResolveTwoHandedAnimation(string itemName)
		{
			if (string.IsNullOrWhiteSpace(itemName))
			{
				return null;
			}
			if (HandCache.TryGetValue(itemName, out var value))
			{
				return value;
			}
			if (NextHandScan.TryGetValue(itemName, out var value2) && Time.realtimeSinceStartup < value2)
			{
				return null;
			}
			Scan();
			bool[] array = (from candidate in HandCandidates
				where string.Equals(candidate.Name, itemName, StringComparison.OrdinalIgnoreCase)
				select candidate.TwoHandedAnimation).Distinct().Take(2).ToArray();
			if (array.Length == 1)
			{
				Dictionary<string, bool> handCache = HandCache;
				string key = itemName;
				bool num = array[0];
				bool value3 = num;
				handCache[key] = num;
				return value3;
			}
			NextHandScan[itemName] = Time.realtimeSinceStartup + 1f;
			return null;
		}

		internal static bool TryResolveHeldPose(string itemName, out Vector3 position, out Quaternion rotation)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			position = Vector3.zero;
			rotation = Quaternion.identity;
			if (string.IsNullOrWhiteSpace(itemName))
			{
				return false;
			}
			if (!HeldPoseCache.TryGetValue(itemName, out (Vector3, Vector3) value))
			{
				if (NextHeldPoseScan.TryGetValue(itemName, out var value2) && Time.realtimeSinceStartup < value2)
				{
					return false;
				}
				Scan();
				(Vector3, Vector3)[] array = (from candidate in HandCandidates
					where string.Equals(candidate.Name, itemName, StringComparison.OrdinalIgnoreCase)
					select (PositionOffset: candidate.PositionOffset, RotationOffset: candidate.RotationOffset)).Distinct().Take(2).ToArray();
				if (array.Length != 1)
				{
					NextHeldPoseScan[itemName] = Time.realtimeSinceStartup + 1f;
					return false;
				}
				value = array[0];
				HeldPoseCache[itemName] = value;
			}
			position = value.Item1;
			rotation = Quaternion.Euler(value.Item2);
			return true;
		}

		private static AudioClip? Match(string itemId, string clipName)
		{
			AudioClip[] array = (from candidate in Candidates
				where Object.op_Implicit((Object)(object)candidate.Clip) && (itemId.Length == 0 || candidate.ItemId == itemId) && (clipName.Length == 0 || ((Object)candidate.Clip).name == clipName)
				select candidate.Clip).Distinct().Take(2).ToArray();
			if (array.Length != 1)
			{
				return null;
			}
			return array[0];
		}
	}
	internal sealed class LiveReplayInput : IDisposable
	{
		private readonly Dictionary<InputAction, bool> actions = new Dictionary<InputAction, bool>();

		private readonly HashSet<InputActionAsset> assets = new HashSet<InputActionAsset>();

		private object? hudOwner;

		private bool disposed;

		internal void Block(Component player)
		{
			if (disposed)
			{
				return;
			}
			Add(InputSystem.actions);
			object value = GameAccess.Read(player, "playerActions");
			object? obj = GameAccess.Read(value, "asset");
			Add((InputActionAsset?)((obj is InputActionAsset) ? obj : null));
			object obj2 = GameAccess.Singleton("HUDManager");
			if (hudOwner != obj2)
			{
				hudOwner = obj2;
				ResetSpectatorVoteHold(obj2);
			}
			object value2 = GameAccess.Read(obj2, "playerActions");
			object? obj3 = GameAccess.Read(value2, "asset");
			Add((InputActionAsset?)((obj3 is InputActionAsset) ? obj3 : null));
			foreach (InputAction key in actions.Keys)
			{
				if (key.enabled)
				{
					key.Disable();
				}
			}
		}

		private void Add(InputActionAsset? asset)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: 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_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)asset) || !assets.Add(asset))
			{
				return;
			}
			Enumerator<InputActionMap> enumerator = asset.actionMaps.GetEnumerator();
			try
			{
				while (enumerator.MoveNext())
				{
					Enumerator<InputAction> enumerator2 = enumerator.Current.actions.GetEnumerator();
					try
					{
						while (enumerator2.MoveNext())
						{
							InputAction current = enumerator2.Current;
							actions[current] = current.enabled;
						}
					}
					finally
					{
						((IDisposable)enumerator2/*cast due to .constrained prefix*/).Dispose();
					}
				}
			}
			finally
			{
				((IDisposable)enumerator/*cast due to .constrained prefix*/).Dispose();
			}
		}

		public void Dispose()
		{
			if (disposed)
			{
				return;
			}
			disposed = true;
			ResetSpectatorVoteHold(hudOwner);
			object obj = GameAccess.Singleton("HUDManager");
			if (obj != hudOwner)
			{
				ResetSpectatorVoteHold(obj);
			}
			foreach (KeyValuePair<InputAction, bool> action in actions)
			{
				try
				{
					if (action.Value)
					{
						action.Key.Enable();
					}
				}
				catch (Exception)
				{
				}
			}
			actions.Clear();
			assets.Clear();
			hudOwner = null;
		}

		private static void ResetSpectatorVoteHold(object? hud)
		{
			if (hud == null)
			{
				return;
			}
			try
			{
				hud.GetType().GetField("holdButtonToEndGameEarlyHoldTime", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.SetValue(hud, 0f);
			}
			catch (Exception)
			{
			}
		}
	}
	internal static class NativeSoundAssets
	{
		private static readonly Dictionary<string, Dictionary<string, AudioClip>> Catalogs = new Dictionary<string, Dictionary<string, AudioClip>>(StringComparer.Ordinal);

		private static readonly Dictionary<string, WeakReference<AudioClip>?> UniqueClips = new Dictionary<string, WeakReference<AudioClip>>(StringComparer.Ordinal);

		private static readonly Dictionary<string, AudioSource?> Sources = new Dictionary<string, AudioSource>(StringComparer.Ordinal);

		private static float nextScan;

		private static Component? playerPrefab;

		private static Component? Prefab(string key)
		{
			if (key != "player")
			{
				return PrefabAssetRegistry.ResolvePrefab(key);
			}
			if (Object.op_Implicit((Object)(object)playerPrefab))
			{
				return playerPrefab;
			}
			Type type = GameAccess.Type("GameNetcodeStuff.PlayerControllerB");
			if (type == null)
			{
				return null;
			}
			object? obj = GameAccess.Read(GameAccess.Singleton("StartOfRound"), "playerPrefab");
			GameObject val = (GameObject)((obj is GameObject) ? obj : null);
			playerPrefab = (Component?)(Object.op_Implicit((Object)(object)val) ? ((object)val.GetComponentInChildren(type, true)) : ((object)Resources.FindObjectsOfTypeAll(type).OfType<Component>().FirstOrDefault((Func<Component, bool>)delegate(Component component)
			{
				//IL_000e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0013: Unknown result type (might be due to invalid IL or missing references)
				if (Object.op_Implicit((Object)(object)component))
				{
					Scene scene = component.gameObject.scene;
					return !((Scene)(ref scene)).IsValid();
				}
				return false;
			})));
			return playerPrefab;
		}

		internal static string Identity(Component owner, AudioClip clip)
		{
			return Catalog(owner).FirstOrDefault<KeyValuePair<string, AudioClip>>((KeyValuePair<string, AudioClip> pair) => (Object)(object)pair.Value == (Object)(object)clip).Key ?? "";
		}

		internal static Dictionary<string, AudioClip> Catalog(Component owner)
		{
			Dictionary<string, AudioClip> dictionary = new Dictionary<string, AudioClip>(StringComparer.Ordinal);
			MonoBehaviour[] componentsInChildren = owner.GetComponentsInChildren<MonoBehaviour>(true);
			foreach (MonoBehaviour val in componentsInChildren)
			{
				if (Object.op_Implicit((Object)(object)val) && !(((object)val).GetType().Namespace ?? "").StartsWith("UnityEngine", StringComparison.Ordinal))
				{
					string path = EntityTracker.RelativePath(owner.transform, ((Component)val).transform) + "|" + ((object)val).GetType().FullName;
					Fields(val, path, dictionary, 0);
				}
			}
			AudioSource[] componentsInChildren2 = owner.GetComponentsInChildren<AudioSource>(true);
			foreach (AudioSource val2 in componentsInChildren2)
			{
				if (Object.op_Implicit((Object)(object)val2.clip))
				{
					dictionary[EntityTracker.RelativePath(owner.transform, ((Component)val2).transform) + "|AudioSource|clip"] = val2.clip;
				}
			}
			return dictionary;
		}

		internal static Dictionary<string, AudioClip>? InstalledCatalog(string key)
		{
			if (Catalogs.TryGetValue(key, out Dictionary<string, AudioClip> value))
			{
				return value;
			}
			Component val = Prefab(key);
			if (!Object.op_Implicit((Object)(object)val))
			{
				return null;
			}
			value = Catalog(val);
			if (Catalogs.Count < 1024)
			{
				Catalogs[key] = value;
			}
			return value;
		}

		private static void Fields(object obj, string path, Dictionary<string, AudioClip> clips, int depth)
		{
			Type type = obj.GetType();
			while (type != null && type != typeof(MonoBehaviour) && type != typeof(ScriptableObject))
			{
				FieldInfo[] fields = type.GetFields(BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				foreach (FieldInfo fieldInfo in fields)
				{
					if (fieldInfo.IsStatic)
					{
						continue;
					}
					string text = path + "|" + fieldInfo.Name;
					if (fieldInfo.FieldType == typeof(AudioClip))
					{
						object? value = fieldInfo.GetValue(obj);
						AudioClip val = (AudioClip)((value is AudioClip) ? value : null);
						if (val != null && Object.op_Implicit((Object)(object)val))
						{
							clips[text] = val;
						}
						continue;
					}
					if (fieldInfo.FieldType == typeof(AudioClip[]) || fieldInfo.FieldType == typeof(List<AudioClip>))
					{
						if (!(fieldInfo.GetValue(obj) is IEnumerable enumerable))
						{
							continue;
						}
						int num = 0;
						foreach (object item in enumerable)
						{
							AudioClip val2 = (AudioClip)((item is AudioClip) ? item : null);
							if (val2 != null && Object.op_Implicit((Object)(object)val2))
							{
								clips[text + "|" + num] = val2;
							}
							if (++num >= 1024)
							{
								break;
							}
						}
						continue;
					}
					if (depth == 0 && typeof(ScriptableObject).IsAssignableFrom(fieldInfo.FieldType))
					{
						object? value2 = fieldInfo.GetValue(obj);
						ScriptableObject val3 = (ScriptableObject)((value2 is ScriptableObject) ? value2 : null);
						if (val3 != null && Object.op_Implicit((Object)(object)val3))
						{
							Fields(val3, text, clips, depth + 1);
							continue;
						}
					}
					if (depth >= 2 || !fieldInfo.FieldType.IsArray || !(fieldInfo.FieldType.GetElementType()?.Name == "EnemyBehaviourState") || !(fieldInfo.GetValue(obj) is IEnumerable enumerable2))
					{
						continue;
					}
					int num2 = 0;
					foreach (object item2 in enumerable2)
					{
						if (item2 != null)
						{
							Fields(item2, text + "|" + num2, clips, depth + 1);
						}
						if (++num2 >= 128)
						{
							break;
						}
					}
				}
				type = type.BaseType;
			}
		}

		internal static AudioClip? Resolve(string prefabKey, string identity, string name, out Component? prefab)
		{
			prefab = ((prefabKey.Length == 0) ? null : Prefab(prefabKey));
			if (!Object.op_Implicit((Object)(object)prefab) && prefabKey.StartsWith("enemy:", StringComparison.Ordinal))
			{
				return null;
			}
			if (Object.op_Implicit((Object)(object)prefab))
			{
				Dictionary<string, AudioClip> dictionary = InstalledCatalog(prefabKey);
				if (identity.Length != 0 && dictionary.TryGetValue(identity, out var value) && Object.op_Implicit((Object)(object)value) && ((Object)value).name == name)
				{
					return value;
				}
				AudioClip[] array = dictionary.Values.Where((AudioClip clip) => Object.op_Implicit((Object)(object)clip) && ((Object)clip).name == name).Distinct().Take(2)
					.ToArray();
				if (array.Length == 1)
				{
					return array[0];
				}
				if (array.Length > 1 || prefabKey.StartsWith("enemy:", StringComparison.Ordinal))
				{
					return null;
				}
			}
			WeakReference<AudioClip> value2;
			bool num = UniqueClips.TryGetValue(name, out value2);
			AudioClip target = null;
			value2?.TryGetTarget(out target);
			if ((!num || (value2 != null && !Object.op_Implicit((Object)(object)target))) && Time.realtimeSinceStartup >= nextScan)
			{
				nextScan = Time.realtimeSinceStartup + 2f;
				UniqueClips.Clear();
				AudioClip[] array2 = Resources.FindObjectsOfTypeAll<AudioClip>();
				foreach (AudioClip val in array2)
				{
					if (!Object.op_Implicit((Object)(object)val) || ((Object)val).name.StartsWith("LCReplay", StringComparison.Ordinal) || ((Object)val).name.StartsWith("LC Replay", StringComparison.Ordinal) || ((Object)val).name.StartsWith("Dissonance", StringComparison.OrdinalIgnoreCase))
					{
						continue;
					}
					if (UniqueClips.TryGetValue(((Object)val).name, out WeakReference<AudioClip> value3))
					{
						if (value3 == null || !value3.TryGetTarget(out var target2) || (Object)(object)target2 != (Object)(object)val)
						{
							UniqueClips[((Object)val).name] = null;
						}
					}
					else
					{
						UniqueClips[((Object)val).name] = new WeakReference<AudioClip>(val);
					}
				}
				target = null;
				if (UniqueClips.TryGetValue(name, out value2))
				{
					value2?.TryGetTarget(out target);
				}
			}
			if (!Object.op_Implicit((Object)(object)target) || !(((Object)target).name == name))
			{
				return null;
			}
			return target;
		}

		internal static AudioSource? Source(Component? prefab, string path, int index)
		{
			if (!Object.op_Implicit((Object)(object)prefab))
			{
				return null;
			}
			string key = ((Object)prefab).GetInstanceID() + "\n" + index + "\n" + path;
			if (Sources.TryGetValue(key, out AudioSource value) && Object.op_Implicit((Object)(object)value))
			{
				return value;
			}
			Transform val = ((IEnumerable<Transform>)prefab.GetComponentsInChildren<Transform>(true)).FirstOrDefault((Func<Transform, bool>)((Transform child) => EntityTracker.RelativePath(prefab.transform, child) == path));
			AudioSource val2 = (Object.op_Implicit((Object)(object)val) ? ((Component)val).GetComponents<AudioSource>().ElementAtOrDefault(Math.Max(0, index)) : null);
			if (!Object.op_Implicit((Object)(object)val2))
			{
				string leaf = path.Substring(path.LastIndexOf('/') + 1);
				AudioSource[] array = (from audio in (from field in ((object)prefab).GetType().GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)
						where field.FieldType == typeof(AudioSource)
						select field).Select(delegate(FieldInfo field)
					{
						object? value2 = field.GetValue(prefab);
						return (AudioSource)((value2 is AudioSource) ? value2 : null);
					})
					where Object.op_Implicit((Object)(object)audio) && EntityTracker.RelativePath(prefab.transform, ((Component)audio).transform).Split('/').Last() == leaf
					select audio).Distinct().Take(2).ToArray();
				if (array.Length == 1)
				{
					val2 = array[0];
				}
			}
			if (Object.op_Implicit((Object)(object)val2) && Sources.Count < 4096)
			{
				Sources[key] = val2;
			}
			return val2;
		}
	}
	internal static class PrefabAssetRegistry
	{
		private static object? scannedConfig;

		private static float nextScan;

		private static readonly Dictionary<string, Component> Prefabs = new Dictionary<string, Component>(StringComparer.Ordinal);

		private static readonly Dictionary<string, Renderer> Renderers = new Dictionary<string, Renderer>(StringComparer.Ordinal);

		private static readonly Dictionary<string, Animator> Animators = new Dictionary<string, Animator>(StringComparer.Ordinal);

		private static readonly Dictionary<string, GeometrySnapshot> Meshes = new Dictionary<string, GeometrySnapshot>(StringComparer.Ordinal);

		private static readonly Queue<string> meshOrder = new Queue<string>();

		private static long meshBytes;

		internal static RuntimeAnimatorController? LocalPlayerController { get; private set; }

		internal static RuntimeAnimatorController? RemotePlayerController { get; private set; }

		internal static bool CachePlayerAssets(Component prefab, RuntimeAnimatorController? local, RuntimeAnimatorController? remote)
		{
			//IL_0019: 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)
			Type type = GameAccess.Type("GameNetcodeStuff.PlayerControllerB");
			if (Object.op_Implicit((Object)(object)prefab))
			{
				Scene scene = prefab.gameObject.scene;
				if (!((Scene)(ref scene)).IsValid() && !(type == null) && type.IsInstanceOfType(prefab))
				{
					Add(prefab, "player");
					if (Object.op_Implicit((Object)(object)local))
					{
						LocalPlayerController = local;
					}
					if (Object.op_Implicit((Object)(object)remote))
					{
						RemotePlayerController = remote;
					}
					return true;
				}
			}
			return false;
		}

		internal static string Key(Component component, string kind)
		{
			if (kind == "player")
			{
				return "player";
			}
			if (kind == "hazard")
			{
				return "hazard:" + ((object)component).GetType().Name;
			}
			string text = GameAccess.Scalar(GameAccess.Read(GameAccess.Read(component, (kind == "enemy") ? "enemyType" : "itemProperties"), (kind == "enemy") ? "enemyName" : "itemId"));
			if (!string.IsNullOrEmpty(text))
			{
				return kind + ":" + text;
			}
			return "";
		}

		internal static void Warm(bool force = false)
		{
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			//IL_01c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0343: Unknown result type (might be due to invalid IL or missing references)
			//IL_0348: Unknown result type (might be due to invalid IL or missing references)
			object? obj = GameAccess.Singleton("StartOfRound");
			Component val = (Component)((obj is Component) ? obj : null);
			if (val != null && Object.op_Implicit((Object)(object)val))
			{
				ReplayParticleAssets.CacheShipMagnet(val);
			}
			object obj2 = GameAccess.Read(GameAccess.Singleton("Unity.Netcode.NetworkManager"), "NetworkConfig");
			Scene scene;
			if (!Prefabs.TryGetValue("player", out Component value) || !Object.op_Implicit((Object)(object)value))
			{
				Type type = GameAccess.Type("GameNetcodeStuff.PlayerControllerB");
				object value2 = GameAccess.Singleton("StartOfRound");
				object? obj3 = GameAccess.Read(value2, "playerPrefab");
				GameObject val2 = (GameObject)((obj3 is GameObject) ? obj3 : null);
				if (!Object.op_Implicit((Object)(object)val2))
				{
					object? obj4 = GameAccess.Read(obj2, "PlayerPrefab");
					val2 = (GameObject)((obj4 is GameObject) ? obj4 : null);
				}
				if (!Object.op_Implicit((Object)(object)val2))
				{
					Type type2 = GameAccess.Type("StartOfRound");
					if ((object)type2 != null)
					{
						Object[] array = Resources.FindObjectsOfTypeAll(type2);
						foreach (Object val3 in array)
						{
							object? obj5 = GameAccess.Read(val3, "playerPrefab");
							GameObject val4 = (GameObject)((obj5 is GameObject) ? obj5 : null);
							if (val4 != null && Object.op_Implicit((Object)(object)val4))
							{
								scene = val4.scene;
								if (!((Scene)(ref scene)).IsValid())
								{
									val2 = val4;
									value2 = val3;
									break;
								}
							}
						}
					}
				}
				if (type != null && Object.op_Implicit((Object)(object)val2))
				{
					scene = val2.scene;
					if (!((Scene)(ref scene)).IsValid())
					{
						Component componentInChildren = val2.GetComponentInChildren(type, true);
						if (componentInChildren != null)
						{
							object local = (object)/*isinst with value type is only supported in some contexts*/;
							object? obj6 = GameAccess.Read(value2, "otherClientsAnimatorController");
							CachePlayerAssets(componentInChildren, (RuntimeAnimatorController?)local, (RuntimeAnimatorController?)((obj6 is RuntimeAnimatorController) ? obj6 : null));
						}
					}
				}
				if (type != null && (!Prefabs.TryGetValue("player", out value) || !Object.op_Implicit((Object)(object)value)))
				{
					foreach (Component item in Resources.FindObjectsOfTypeAll(type).OfType<Component>())
					{
						if (Object.op_Implicit((Object)(object)item))
						{
							scene = item.gameObject.scene;
							if (!((Scene)(ref scene)).IsValid())
							{
								Add(item, "player");
								break;
							}
						}
					}
				}
			}
			if ((!force && obj2 != null && obj2 == scannedConfig) || (!force && obj2 == null && Time.realtimeSinceStartup < nextScan))
			{
				return;
			}
			nextScan = Time.realtimeSinceStartup + 2f;
			string[] array2 = new string[2] { "Turret", "Landmine" };
			foreach (string text in array2)
			{
				Type type3 = GameAccess.Type(text);
				if (type3 == null)
				{
					continue;
				}
				Component val5 = Resources.FindObjectsOfTypeAll(type3).OfType<Component>().FirstOrDefault((Func<Component, bool>)delegate(Component component)
				{
					//IL_000e: Unknown result type (might be due to invalid IL or missing references)
					//IL_0013: Unknown result type (might be due to invalid IL or missing references)
					if (Object.op_Implicit((Object)(object)component))
					{
						Scene scene2 = component.gameObject.scene;
						return !((Scene)(ref scene2)).IsValid();
					}
					return false;
				});
				if (Object.op_Implicit((Object)(object)val5))
				{
					Prefabs["hazard:" + text] = val5;
				}
			}
			array2 = new string[2] { "enemy", "item" };
			foreach (string text2 in array2)
			{
				Type type4 = GameAccess.Type((text2 == "enemy") ? "EnemyAI" : "GrabbableObject");
				if (type4 == null)
				{
					continue;
				}
				foreach (Component item2 in Resources.FindObjectsOfTypeAll(type4).OfType<Component>())
				{
					if (Object.op_Implicit((Object)(object)item2))
					{
						scene = item2.gameObject.scene;
						if (!((Scene)(ref scene)).IsValid())
						{
							Add(item2, text2);
						}
					}
				}
			}
			if (!(GameAccess.Read(GameAccess.Read(obj2, "Prefabs"), "Prefabs") is IEnumerable enumerable))
			{
				return;
			}
			foreach (object item3 in enumerable)
			{
				object? obj7 = GameAccess.Read(item3, "Prefab");
				GameObject val6 = (GameObject)((obj7 is GameObject) ? obj7 : null);
				if (!Object.op_Implicit((Object)(object)val6))
				{
					continue;
				}
				array2 = new string[2] { "enemy", "item" };
				foreach (string text3 in array2)
				{
					Type type5 = GameAccess.Type((text3 == "enemy") ? "EnemyAI" : "GrabbableObject");
					if (!(type5 == null))
					{
						Component componentInChildren2 = val6.GetComponentInChildren(type5, true);
						if (Object.op_Implicit((Object)(object)componentInChildren2))
						{
							Add(componentInChildren2, text3);
						}
					}
				}
			}
			scannedConfig = obj2;
		}

		private static void Add(Component component, string kind)
		{
			string text = Key(component, kind);
			if (text.Length == 0 || (Prefabs.TryGetValue(text, out Component value) && Object.op_Implicit((Object)(object)value)))
			{
				return;
			}
			Prefabs[text] = component;
			Renderer[] componentsInChildren = component.GetComponentsInChildren<Renderer>(true);
			foreach (Renderer val in componentsInChildren)
			{
				if (val is MeshRenderer || val is SkinnedMeshRenderer)
				{
					Renderers[text + "\n" + EntityTracker.RelativePath(component.transform, ((Component)val).transform)] = val;
				}
			}
			Animator[] componentsInChildren2 = component.GetComponentsInChildren<Animator>(true);
			foreach (Animator val2 in componentsInChildren2)
			{
				Animators[text + "\n" + EntityTracker.RelativePath(component.transform, ((Component)val2).transform)] = val2;
				AnimationAssetRegistry.Remember(val2, kind);
			}
		}

		internal static bool Reference(EntityTracker.Entry owner, Renderer renderer, GeometrySnapshot geometry)
		{
			//IL_00b4: 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)
			if (owner.Kind != "enemy" && owner.Kind != "item" && owner.Kind != "player")
			{
				return false;
			}
			Warm();
			string text = Key(owner.Component, owner.Kind);
			if (owner.Kind == "enemy" && (!Prefabs.TryGetValue(text, out Component value) || !Object.op_Implicit((Object)(object)value)))
			{
				object? obj = GameAccess.Read(GameAccess.Read(owner.Component, "enemyType"), "enemyPrefab");
				GameObject val = (GameObject)((obj is GameObject) ? obj : null);
				Type type = GameAccess.Type("EnemyAI");
				if (Object.op_Implicit((Object)(object)val))
				{
					Scene scene = val.scene;
					if (!((Scene)(ref scene)).IsValid() && type != null)
					{
						Component componentInChildren = val.GetComponentInChildren(type, true);
						if (componentInChildren != null)
						{
							Add(componentInChildren, "enemy");
						}
					}
				}
			}
			string text2 = EntityTracker.RelativePath(owner.Component.transform, ((Component)renderer).transform);
			if (text2.Length == 0 || !Renderers.TryGetValue(text + "\n" + text2, out Renderer value2) || !Object.op_Implicit((Object)(object)value2) || (Object)(object)Mesh(renderer) != (Object)(object)Mesh(value2))
			{
				return false;
			}
			geometry.PrefabKey = text;
			geometry.PrefabRendererPath = text2;
			geometry.MeshName = ((Object)Mesh(value2)).name;
			geometry.IsBoundsProxy = false;
			return true;
		}

		internal static bool NativeMaterials(Renderer renderer, GeometrySnapshot geometry)
		{
			if (!Renderers.TryGetValue(geometry.PrefabKey + "\n" + geometry.PrefabRendererPath, out Renderer value) || !Object.op_Implicit((Object)(object)value))
			{
				return false;
			}
			Material[] sharedMaterials = renderer.sharedMaterials;
			Material[] source = value.sharedMaterials;
			if (sharedMaterials.Length == source.Length)
			{
				return !sharedMaterials.Where((Material material, int index) => (Object)(object)material != (Object)(object)source[index]).Any();
			}
			return false;
		}

		internal static void Restore(WorldSnapshot world, ReplaySession session)
		{
			//IL_0218: Unknown result type (might be due to invalid IL or missing references)
			//IL_021f: Expected O, but got Unknown
			//IL_0514: Unknown result type (might be due to invalid IL or missing references)
			//IL_0519: Unknown result type (might be due to invalid IL or missing references)
			//IL_0573: Unknown result type (might be due to invalid IL or missing references)
			//IL_057a: Expected O, but got Unknown
			//IL_05b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_05bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_05c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_05d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0556: Unknown result type (might be due to invalid IL or missing references)
			//IL_055b: Unknown result type (might be due to invalid IL or missing references)
			Warm();
			Dictionary<string, EntitySnapshot> dictionary = (from actor in session.Frames.SelectMany((ReplayFrame frame) => frame.Entities)
				where actor.Kind == "enemy"
				group actor by actor.Id).ToDictionary((IGrouping<string, EntitySnapshot> group) => group.Key, (IGrouping<string, EntitySnapshot> group) => group.First());
			foreach (GeometrySnapshot geometry in world.Geometry)
			{
				bool flag = geometry.PrefabKey.Length != 0 && geometry.MaterialIds.Count != 0;
				string text = geometry.PrefabKey;
				string text2 = geometry.PrefabRendererPath;
				if (text.Length == 0 && dictionary.TryGetValue(geometry.EntityId, out var value))
				{
					text = "enemy:" + value.Name;
					if (!Prefabs.TryGetValue(text, out Component value2) || !Object.op_Implicit((Object)(object)value2))
					{
						continue;
					}
					Renderer[] array = (from renderer in value2.GetComponentsInChildren<Renderer>(true)
						where Object.op_Implicit((Object)(object)renderer) && ((Object)renderer).name == geometry.Name && Object.op_Implicit((Object)(object)Mesh(renderer)) && (((Object)Mesh(renderer)).name == geometry.MeshName || geometry.IsBoundsProxy)
						select renderer).ToArray();
					if (array.Length != 1)
					{
						continue;
					}
					text2 = EntityTracker.RelativePath(value2.transform, ((Component)array[0]).transform);
				}
				string text3 = text + "\n" + text2;
				if (!Renderers.TryGetValue(text3, out Renderer value3) || !Object.op_Implicit((Object)(object)value3) || !Prefabs.TryGetValue(text, out Component value4) || !Object.op_Implicit((Object)(object)value4))
				{
					continue;
				}
				if (!Meshes.TryGetValue(text3, out GeometrySnapshot value5))
				{
					value5 = new GeometrySnapshot();
					Mesh val = Mesh(value3);
					if (!Object.op_Implicit((Object)(object)val) || !MeshSnapshotReader.Read(val, value5, 1000000, 6000000))
					{
						continue;
					}
					SkinnedMeshRenderer val2 = (SkinnedMeshRenderer)(object)((value3 is SkinnedMeshRenderer) ? value3 : null);
					if (val2 != null && !MeshSnapshotReader.Skin(val2, value4.transform, value5))
					{
						continue;
					}
					long num = Bytes(value5);
					if (num <= 67108864)
					{
						while (meshBytes + num > 67108864 && meshOrder.Count != 0)
						{
							string key = meshOrder.Dequeue();
							if (Meshes.TryGetValue(key, out GeometrySnapshot value6))
							{
								meshBytes -= Bytes(value6);
								Meshes.Remove(key);
							}
						}
						Meshes[text3] = value5;
						meshOrder.Enqueue(text3);
						meshBytes += num;
					}
				}
				geometry.Vertices = value5.Vertices;
				geometry.Normals = value5.Normals;
				geometry.Uvs = value5.Uvs;
				geometry.Uvs1 = value5.Uvs1;
				geometry.Uvs2 = value5.Uvs2;
				geometry.Uvs3 = value5.Uvs3;
				geometry.Tangents = value5.Tangents;
				geometry.Triangles = value5.Triangles;
				geometry.SubmeshTriangles = value5.SubmeshTriangles;
				geometry.BonePaths = value5.BonePaths;
				geometry.BindPoses = value5.BindPoses;
				geometry.BoneIndices = value5.BoneIndices;
				geometry.BoneWeights = value5.BoneWeights;
				geometry.RigBones = value5.RigBones;
				geometry.RootBonePath = value5.RootBonePath;
				geometry.AnimatorPath = value5.AnimatorPath;
				geometry.AnimatorController = value5.AnimatorController;
				geometry.AnimatorAvatar = value5.AnimatorAvatar;
				geometry.IsBoundsProxy = false;
				geometry.PrefabKey = text;
				geometry.PrefabRendererPath = text2;
				if (flag)
				{
					continue;
				}
				geometry.MaterialIds = new List<string>();
				Material[] sharedMaterials = value3.sharedMaterials;
				foreach (Material val3 in sharedMaterials)
				{
					if (!Object.op_Implicit((Object)(object)val3) || !Object.op_Implicit((Object)(object)val3.shader))
					{
						geometry.MaterialIds.Add("");
						continue;
					}
					string id = "native-prefab:" + ((Object)val3).GetInstanceID();
					if (!world.Materials.Any((MaterialSnapshot snapshot) => snapshot.Id == id))
					{
						Color val4 = Color.white;
						string[] array2 = new string[3] { "_BaseColor", "_UnlitColor", "_Color" };
						foreach (string text4 in array2)
						{
							if (val3.HasProperty(text4))
							{
								val4 = val3.GetColor(text4);
								break;
							}
						}
						List<MaterialSnapshot> materials = world.Materials;
						MaterialSnapshot val5 = new MaterialSnapshot();
						val5.Id = id;
						val5.Name = ((Object)val3).name;
						val5.ShaderName = ((Object)val3.shader).name;
						val5.Color = new float[4] { val4.r, val4.g, val4.b, val4.a };
						materials.Add(val5);
					}
					geometry.MaterialIds.Add(id);
				}
			}
		}

		private static Mesh? Mesh(Renderer renderer)
		{
			SkinnedMeshRenderer val = (SkinnedMeshRenderer)(object)((renderer is SkinnedMeshRenderer) ? renderer : null);
			if (val == null)
			{
				MeshFilter component = ((Component)renderer).GetComponent<MeshFilter>();
				if (component == null)
				{
					return null;
				}
				return component.sharedMesh;
			}
			return val.sharedMesh;
		}

		internal static Mesh? ResolveMesh(GeometrySnapshot geometry)
		{
			if (geometry.PrefabKey.Length == 0 || geometry.PrefabRendererPath.Length == 0 || !Renderers.TryGetValue(geometry.PrefabKey + "\n" + geometry.PrefabRendererPath, out Renderer value) || !Object.op_Implicit((Object)(object)value))
			{
				return null;
			}
			Mesh val = Mesh(value);
			if (!Object.op_Implicit((Object)(object)val) || val.vertexCount != geometry.Vertices.Length / 3)
			{
				return null;
			}
			return val;
		}

		internal static Animator? ResolveAnimator(string key, string path)
		{
			if (!Animators.TryGetValue(key + "\n" + path, out Animator value) || !Object.op_Implicit((Object)(object)value))
			{
				return null;
			}
			return value;
		}

		internal static Component? ResolvePrefab(string key)
		{
			Warm();
			if (!Prefabs.TryGetValue(key, out Component value) || !Object.op_Implicit((Object)(object)value))
			{
				return null;
			}
			return value;
		}

		private static long Bytes(GeometrySnapshot geometry)
		{
			return 4 * (geometry.Vertices.Length + geometry.Normals.Length + geometry.Uvs.Length + geometry.Uvs1.Length + geometry.Uvs2.Length + geometry.Uvs3.Length + geometry.Tangents.Length + geometry.Triangles.Length + geometry.BoneWeights.Length + geometry.BoneIndices.Length + geometry.BindPoses.Length + ((IEnumerable<int[]>)geometry.SubmeshTriangles).Sum((Func<int[], long>)((int[] indices) => indices.Length)));
		}
	}
	internal static class RenderVisibilityPolicy
	{
		private static readonly string[] VegetationNames = new string[13]
		{
			"tree", "grass", "leaf", "leaves", "bush", "flower", "forest", "foliage", "vine", "plant",
			"fern", "shrub", "moss"
		};

		internal static bool IsGroundSurface(string name)
		{
			if (string.IsNullOrEmpty(name))
			{
				return false;
			}
			if (name.IndexOf("terrain", StringComparison.OrdinalIgnoreCase) < 0 && name.IndexOf("ground", StringComparison.OrdinalIgnoreCase) < 0 && name.IndexOf("landscape", StringComparison.OrdinalIgnoreCase) < 0)
			{
				return name.IndexOf("splatmap", StringComparison.OrdinalIgnoreCase) >= 0;
			}
			return true;
		}

		internal static bool IsRockSurface(string name)
		{
			if (string.IsNullOrEmpty(name))
			{
				return false;
			}
			if (name.IndexOf("rock", StringComparison.OrdinalIgnoreCase) < 0 && name.IndexOf("stone", StringComparison.OrdinalIgnoreCase) < 0 && name.IndexOf("boulder", StringComparison.OrdinalIgnoreCase) < 0)
			{
				return name.IndexOf("cliff", StringComparison.OrdinalIgnoreCase) >= 0;
			}
			return true;
		}

		internal static bool IsArchitectureSurface(string name)
		{
			if (string.IsNullOrEmpty(name))
			{
				return false;
			}
			if (name.IndexOf("wall", StringComparison.OrdinalIgnoreCase) < 0 && name.IndexOf("floor", StringComparison.OrdinalIgnoreCase) < 0)
			{
				return name.IndexOf("ceiling", StringComparison.OrdinalIgnoreCase) >= 0;
			}
			return true;
		}

		internal static bool IsVegetation(string name)
		{
			if (string.IsNullOrEmpty(name))
			{
				return false;
			}
			string[] vegetationNames = VegetationNames;
			foreach (string value in vegetationNames)
			{
				if (name.IndexOf(value, StringComparison.OrdinalIgnoreCase) >= 0)
				{
					return true;
				}
			}
			return false;
		}

		internal static bool IsDebugMaterial(string name)
		{
			if (!name.StartsWith("testTrigger", StringComparison.OrdinalIgnoreCase))
			{
				return name.StartsWith("wireframe_", StringComparison.OrdinalIgnoreCase);
			}
			return true;
		}

		internal static bool IsDebugObject(string name)
		{
			if (!name.StartsWith("ImpVis_", StringComparison.Ordinal) && !name.StartsWith("ImpGizmo_", StringComparison.Ordinal))
			{
				switch (name)
				{
				default:
					if (!string.Equals(name, "ScanSphere", StringComparison.OrdinalIgnoreCase) && !(name == "MapDot"))
					{
						return name.StartsWith("MapDot (", StringComparison.Ordinal);
					}
					break;
				case "VehicleBounds":
				case "InsideTruckNavBounds":
				case "OntopOfTruckBounds":
				case "WindshieldInteractBlocker":
					break;
				}
			}
			return true;
		}

		internal static bool IsRadarPath(string path)
		{
			if (!path.StartsWith("MapDot[", StringComparison.Ordinal) && !path.StartsWith("MapDot (", StringComparison.Ordinal) && path.IndexOf("/MapDot[", StringComparison.Ordinal) < 0)
			{
				return path.IndexOf("/MapDot (", StringComparison.Ordinal) >= 0;
			}
			return true;
		}

		internal static bool IsFirstPersonOverlay(string name)
		{
			if (!string.Equals(name, "ScavengerHelmet", StringComparison.OrdinalIgnoreCase) && !string.Equals(name, "ScreenHelmetGoopPreload", StringComparison.OrdinalIgnoreCase))
			{
				return string.Equals(name, "VisorCracks", StringComparison.OrdinalIgnoreCase);
			}
			return true;
		}

		internal static bool IsDebugGeometry(GeometrySnapshot geometry, ISet<string> debugMaterials)
		{
			if (IsDebugObject(geometry.Name) || IsFirstPersonOverlay(geometry.Name))
			{
				return true;
			}
			if (geometry.MaterialIds.Count == 0)
			{
				return false;
			}
			foreach (string materialId in geometry.MaterialIds)
			{
				if (materialId.Length == 0 || !debugMaterials.Contains(materialId))
				{
					return false;
				}
			}
			return true;
		}
	}
	public static class ReplayApi
	{
		private static readonly Dictionary<string, Func<IDictionary<string, string>>> Providers = new Dictionary<string, Func<IDictionary<string, string>>>();

		internal static Action<ReplayEvent>? EventSink;

		public static bool IsRecording => EventSink != null;

		public static void RegisterStateProvider(string id, Func<IDictionary<string, string>> provider)
		{
			if (string.IsNullOrWhiteSpace(id) || id.Length > 128)
			{
				throw new ArgumentException("Provider id must contain 1 to 128 characters.", "id");
			}
			if (provider == null)
			{
				throw new ArgumentNullException("provider");
			}
			lock (Providers)
			{
				if (Providers.Count >= 64 && !Providers.ContainsKey(id))
				{
					throw new InvalidOperationException("Replay supports at most 64 state providers.");
				}
				Providers[id] = provider;
			}
		}

		public static void UnregisterStateProvider(string id)
		{
			lock (Providers)
			{
				Providers.Remove(id);
			}
		}

		public static void LogEvent(string category, string name, IDictionary<string, string>? data = null)
		{
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: 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_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Expected O, but got Unknown
			Action<ReplayEvent> eventSink = EventSink;
			if (eventSink == null)
			{
				return;
			}
			Dictionary<string, string> dictionary = new Dictionary<string, string>();
			if (data != null)
			{
				foreach (KeyValuePair<string, string> datum in data)
				{
					if (dictionary.Count >= 128)
					{
						dictionary["$truncated"] = "128 event fields";
						break;
					}
					dictionary[Limit(datum.Key, 128)] = Limit(datum.Value, 1024);
				}
			}
			eventSink(new ReplayEvent
			{
				Category = Limit(category ?? "custom", 128),
				Name = Limit(name ?? "event", 256),
				Data = dictionary
			});
		}

		private static string Limit(string? value, int length)
		{
			if (value != null)
			{
				if (value.Length <= length)
				{
					return value;
				}
				return value.Substring(0, length);
			}
			return "";
		}

		internal static void CaptureProviders(Dictionary<string, string> state, Action<string> log)
		{
			KeyValuePair<string, Func<IDictionary<string, string>>>[] array;
			lock (Providers)
			{
				array = new KeyValuePair<string, Func<IDictionary<string, string>>>[Providers.Count];
				((ICollection<KeyValuePair<string, Func<IDictionary<string, string>>>>)Providers).CopyTo(array, 0);
			}
			KeyValuePair<string, Func<IDictionary<string, string>>>[] array2 = array;
			for (int i = 0; i < array2.Length; i++)
			{
				KeyValuePair<string, Func<IDictionary<string, string>>> keyValuePair = array2[i];
				if (state.Count >= 1000)
				{
					state["$providersTruncated"] = "frame field limit";
					break;
				}
				try
				{
					int num = 0;
					foreach (KeyValuePair<string, string> item in keyValuePair.Value())
					{
						if (++num > 128 || state.Count >= 1000)
						{
							state["mod:" + keyValuePair.Key + ":$truncated"] = "provider/frame field limit";
							break;
						}
						string value = item.Value ?? "";
						state["mod:" + keyValuePair.Key + ":" + Limit(item.Key, 128)] = Limit(value, 1024);
					}
				}
				catch (Exception ex)
				{
					log("State provider disabled after error: " + keyValuePair.Key + " / " + ex.Message);
					lock (Providers)
					{
						if (Providers.TryGetValue(keyValuePair.Key, out Func<IDictionary<string, string>> value2) && value2 == keyValuePair.Value)
						{
							Providers.Remove(keyValuePair.Key);
						}
					}
				}
			}
		}
	}
	internal sealed class ReplayBookmarkInput : IDisposable
	{
		internal const string InputUtilsGuid = "com.rune580.LethalCompanyInputUtils";

		private readonly ConfigEntry<KeyCode> fallback;

		private Func<bool>? pressed;

		private Action? disable;

		internal ReplayBookmarkInput(ConfigEntry<KeyCode> fallback, Action<string> log)
		{
			this.fallback = fallback;
			if (!Chainloader.PluginInfos.ContainsKey("com.rune580.LethalCompanyInputUtils"))
			{
				return;
			}
			try
			{
				AttachInputUtils();
				log("Replay bookmark key registered with InputUtils's game settings.");
			}
			catch (Exception ex)
			{
				log("Replay bookmark uses the configured fallback key: " + ex.Message);
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private void AttachInputUtils()
		{
			BaseUnityPlugin instance = Chainloader.PluginInfos["com.rune580.LethalCompanyInputUtils"].Instance;
			BepInPlugin metadata = Chainloader.PluginInfos["pasta.replay"].Metadata;
			object actions = ReplayKeybinds.Create(((object)instance).GetType().Assembly, metadata);
			PropertyInfo property = actions.GetType().GetProperty("AddBookmark");
			InputAction action = null;
			pressed = delegate
			{
				InputAction obj = action ?? (action = (InputAction)/*isinst with value type is only supported in some contexts*/);
				return obj != null && obj.WasPerformedThisFrame();
			};
			disable = delegate
			{
				actions.GetType().GetMethod("Disable").Invoke(actions, null);
			};
		}

		internal bool WasPressed()
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			if (pressed == null)
			{
				return ReplayInput.WasPressed(((object)fallback.Value/*cast due to .constrained prefix*/).ToString());
			}
			return pressed();
		}

		public void Dispose()
		{
			disable?.Invoke();
			pressed = null;
			disable = null;
		}
	}
	internal static class ReplayIsolation
	{
		private static readonly HashSet<int> scenes;

		private static object? networkSceneManager;

		private static Func<Scene, bool>? networkFilter;

		internal static bool PlaybackActive { get; set; }

		static ReplayIsolation()
		{
			scenes = new HashSet<int>();
			SceneManager.sceneUnloaded += delegate(Scene scene)
			{
				scenes.Remove(((Scene)(ref scene)).handle);
			};
		}

		internal static void Register(Scene scene)
		{
			if (((Scene)(ref scene)).IsValid())
			{
				scenes.Add(((Scene)(ref scene)).handle);
			}
		}

		internal static void Unregister(Scene scene)
		{
			if (((Scene)(ref scene)).IsValid() && !((Scene)(ref scene)).isLoaded)
			{
				scenes.Remove(((Scene)(ref scene)).handle);
			}
		}

		internal static void Unloaded(Scene scene)
		{
			scenes.Remove(((Scene)(ref scene)).handle);
		}

		internal static bool IsReplayScene(Scene scene)
		{
			if (((Scene)(ref scene)).IsValid())
			{
				return scenes.Contains(((Scene)(ref scene)).handle);
			}
			return false;
		}

		internal static bool EnsureNetworkExclusion()
		{
			object obj = GameAccess.Read(GameAccess.Singleton("Unity.Netcode.NetworkManager"), "SceneManager");
			if (obj == null)
			{
				return false;
			}
			FieldInfo field = obj.GetType().GetField("ExcludeSceneFromSychronization", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			if (field?.FieldType != typeof(Func<Scene, bool>))
			{
				return false;
			}
			try
			{
				Func<Scene, bool> current = field.GetValue(obj) as Func<Scene, bool>;
				if (obj == networkSceneManager && (object)current == networkFilter)
				{
					return true;
				}
				Func<Scene, bool> value = (Scene scene) => !IsReplayScene(scene) && (current?.Invoke(scene) ?? true);
				field.SetValue(obj, value);
				networkSceneManager = obj;
				networkFilter = value;
				return true;
			}
			catch (Exception)
			{
				return false;
			}
		}
	}
	internal static class ReplayKeybinds
	{
		internal static object Create(Assembly sdk, BepInPlugin metadata)
		{
			Type type = sdk.GetType("LethalCompanyInputUtils.Api.LcInputActions", throwOnError: true);
			Type type2 = sdk.GetType("LethalCompanyInputUtils.Api.InputActionAttribute", throwOnError: true);
			TypeBuilder typeBuilder = AssemblyBuilder.DefineDynamicAssembly(new AssemblyName("LCReplay.OptionalInputUtils"), AssemblyBuilderAccess.Run).DefineDynamicModule("Keybinds").DefineType("LCReplay.BookmarkActions", TypeAttributes.Public | TypeAttributes.Sealed, type);
			ILGenerator iLGenerator = typeBuilder.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, new Type[1] { typeof(BepInPlugin) }).GetILGenerator();
			iLGenerator.Emit(OpCodes.Ldarg_0);
			iLGenerator.Emit(OpCodes.Ldarg_1);
			iLGenerator.Emit(OpCodes.Call, type.GetConstructor(BindingFlags.Instance | BindingFlags.NonPublic, null, new Type[1] { typeof(BepInPlugin) }, null));
			iLGenerator.Emit(OpCodes.Ret);
			MethodInfo getMethod = type.GetProperty("MapName", BindingFlags.Instance | BindingFlags.NonPublic).GetGetMethod(nonPublic: true);
			MethodBuilder methodBuilder = typeBuilder.DefineMethod("get_MapName", MethodAttributes.Family | MethodAttributes.Virtual | MethodAttributes.SpecialName, typeof(string), Type.EmptyTypes);
			iLGenerator = methodBuilder.GetILGenerator();
			iLGenerator.Emit(OpCodes.Ldstr, "Replay");
			iLGenerator.Emit(OpCodes.Ret);
			typeBuilder.DefineMethodOverride(methodBuilder, getMethod);
			FieldBuilder field = typeBuilder.DefineField("bookmark", typeof(InputAction), FieldAttributes.Private);
			PropertyBuilder propertyBuilder = typeBuilder.DefineProperty("AddBookmark", PropertyAttributes.None, typeof(InputAction), null);
			MethodBuilder methodBuilder2 = typeBuilder.DefineMethod("get_AddBookmark", MethodAttributes.Public | MethodAttributes.SpecialName, typeof(InputAction), Type.EmptyTypes);
			iLGenerator = methodBuilder2.GetILGenerator();
			iLGenerator.Emit(OpCodes.Ldarg_0);
			iLGenerator.Emit(OpCodes.Ldfld, field);
			iLGenerator.Emit(OpCodes.Ret);
			MethodBuilder methodBuilder3 = typeBuilder.DefineMethod("set_AddBookmark", MethodAttributes.Public | MethodAttributes.SpecialName, typeof(void), new Type[1] { typeof(InputAction) });
			iLGenerator = methodBuilder3.GetILGenerator();
			iLGenerator.Emit(OpCodes.Ldarg_0);
			iLGenerator.Emit(OpCodes.Ldarg_1);
			iLGenerator.Emit(OpCodes.Stfld, field);
			iLGenerator.Emit(OpCodes.Ret);
			propertyBuilder.SetGetMethod(methodBuilder2);
			propertyBuilder.SetSetMethod(methodBuilder3);
			propertyBuilder.SetCustomAttribute(new CustomAttributeBuilder(type2.GetConstructor(new Type[1] { typeof(string) }), new object[1] { "<Keyboard>/backquote" }, new PropertyInfo[2]
			{
				type2.GetProperty("Name"),
				type2.GetProperty("ActionId")
			}, new object[2] { "Add replay bookmark", "AddBookmark" }));
			MethodBuilder methodBuilder4 = typeBuilder.DefineMethod("OnAssetLoaded", MethodAttributes.Public | MethodAttributes.Virtual, typeof(void), Type.EmptyTypes);
			iLGenerator = methodBuilder4.GetILGenerator();
			iLGenerator.Emit(OpCodes.Ldarg_0);
			iLGenerator.Emit(OpCodes.Call, type.GetMethod("Enable"));
			iLGenerator.Emit(OpCodes.Ret);
			typeBuilder.DefineMethodOverride(methodBuilder4, type.GetMethod("OnAssetLoaded"));
			return Activator.CreateInstance(typeBuilder.CreateType(), metadata);
		}
	}
	internal static class ReplayLightProperties
	{
		private static readonly Dictionary<string, (float Min, float Max)> Floats = new Dictionary<string, (float, float)>(StringComparer.Ordinal)
		{
			["shapeRadius"] = (0f, 10000f),
			["shapeWidth"] = (0f, 10000f),
			["shapeHeight"] = (0f, 10000f),
			["aspectRatio"] = (0.01f, 1000f),
			["innerSpotPercent"] = (0f, 100f),
			["volumetricDimmer"] = (0f, 16f),
			["volumetricShadowDimmer"] = (0f, 16f),
			["fadeDistance"] = (0f, 100000f),
			["volumetricFadeDistance"] = (0f, 100000f),
			["maxSmoothness"] = (0f, 1f),
			["angularDiameter"] = (0f, 90f),
			["normalBias"] = (0f, 64f),
			["slopeBias"] = (0f, 64f),
			["shadowNearPlane"] = (0f, 1000f)
		};

		private static readonly HashSet<string> Bools = new HashSet<string>(StringComparer.Ordinal) { "applyRangeAttenuation", "affectDiffuse", "affectSpecular", "enableSpotReflector", "interactsWithSky" };

		private static readonly HashSet<string> Enums = new HashSet<string>(StringComparer.Ordinal) { "type", "spotLightShape", "areaLightShape" };

		internal static List<EnvironmentParameterSnapshot> Capture(Component? data)
		{
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Expected O, but got Unknown
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: 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_0194: 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_01b1: Expected O, but got Unknown
			List<EnvironmentParameterSnapshot> list = new List<EnvironmentParameterSnapshot>();
			if (!Object.op_Implicit((Object)(object)data))
			{
				return list;
			}
			foreach (KeyValuePair<string, (float, float)> @float in Floats)
			{
				if (GameAccess.Read(data, @float.Key) is float num && GameAccess.Finite(num))
				{
					EnvironmentParameterSnapshot val = new EnvironmentParameterSnapshot();
					val.Name = @float.Key;
					val.Kind = "float";
					val.Values = new float[1] { Mathf.Clamp(num, @float.Value.Item1, @float.Value.Item2) };
					list.Add(val);
				}
			}
			foreach (string @bool in Bools)
			{
				if (GameAccess.Read(data, @bool) is bool flag)
				{
					EnvironmentParameterSnapshot val = new EnvironmentParameterSnapshot();
					val.Name = @bool;
					val.Kind = "bool";
					val.Values = new float[1] { flag ? 1f : 0f };
					list.Add(val);
				}
			}
			foreach (string @enum in Enums)
			{
				object obj = GameAccess.Read(data, @enum);
				if (obj != null && obj.GetType().IsEnum)
				{
					list.Add(new EnvironmentParameterSnapshot
					{
						Name = @enum,
						Kind = "enum",
						Text = obj.ToString()
					});
				}
			}
			return list;
		}

		internal static void Apply(Component? data, IReadOnlyList<EnvironmentParameterSnapshot> parameters, Light light, float intensity)
		{
			//IL_01c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0215: Unknown result type (might be due to invalid IL or missing references)
			//IL_021b: Invalid comparison between Unknown and I4
			//IL_0225: Unknown result type (might be due to invalid IL or missing references)
			//IL_022b: Invalid comparison between Unknown and I4
			//IL_022e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0234: Invalid comparison between Unknown and I4
			if (!Object.op_Implicit((Object)(object)data))
			{
				light.intensity = intensity;
				return;
			}
			foreach (EnvironmentParameterSnapshot parameter in parameters)
			{
				if (parameter.Name == "type" && parameter.Kind == "enum")
				{
					SetEnum(data, "type", parameter.Text);
				}
			}
			foreach (EnvironmentParameterSnapshot parameter2 in parameters)
			{
				if (parameter2.Name != "type" && parameter2.Kind == "enum" && Enums.Contains(parameter2.Name))
				{
					SetEnum(data, parameter2.Name, parameter2.Text);
				}
			}
			foreach (EnvironmentParameterSnapshot parameter3 in parameters)
			{
				if (parameter3.Values.Length != 1)
				{
					continue;
				}
				float num = parameter3.Values[0];
				if (GameAccess.Finite(num))
				{
					if (parameter3.Kind == "float" && Floats.TryGetValue(parameter3.Name, out (float, float) value))
					{
						Set(data, parameter3.Name, Mathf.Clamp(num, value.Item1, value.Item2));
					}
					else if (parameter3.Kind == "bool" && Bools.Contains(parameter3.Name))
					{
						Set(data, parameter3.Name, num != 0f);
					}
				}
			}
			bool flag = (int)light.type == 0 && GameAccess.Read(data, "spotLightShape")?.ToString() == "Box";
			bool flag2 = GameAccess.Read(data, "type")?.ToString() == "Area";
			string value2 = (((int)light.type == 1 || flag) ? "Lux" : ((flag2 || (int)light.type == 3 || (int)light.type == 4) ? "Nits" : "Candela"));
			SetEnum(data, "lightUnit", value2);
			Set(data, "intensity", intensity);
			light.intensity = intensity;
		}

		private static void Set(Component data, string name, object value)
		{
			try
			{
				PropertyInfo property = ((object)data).GetType().GetProperty(name, BindingFlags.Instance | BindingFlags.Public);
				if ((object)property != null && property.CanWrite)
				{
					property.SetValue(data, value, null);
				}
				else
				{
					((object)data).GetType().GetField(name, BindingFlags.Instance | BindingFlags.Public)?.SetValue(data, value);
				}
			}
			catch
			{
			}
		}

		private static void SetEnum(Component data, string name, string value)
		{
			PropertyInfo property = ((object)data).GetType().GetProperty(name, BindingFlags.Instance | BindingFlags.Public);
			if ((object)property != null && property.CanWrite && property.PropertyType.IsEnum && Enum.IsDefined(property.PropertyType, value))
			{
				Set(data, name, Enum.Parse(property.PropertyType, value));
			}
		}
	}
	[BepInPlugin("pasta.replay", "LC Replay", "1.0.0")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public sealed class ReplayPlugin : BaseUnityPlugin
	{
		private sealed class SaveResult
		{
			internal readonly string Path;

			internal readonly double Duration;

			internal readonly Exception? Error;

			internal readonly bool MetadataError;

			internal SaveResult(string path, double duration, Exception? error, bool metadataError)
			{
				Path = path;
				Duration = duration;
				Error = error;
				MetadataError = metadataError;
			}
		}

		public const string Guid = "pasta.replay";

		public const string Version = "1.0.0";

		private GUIStyle? overlayLabel;

		private GUIStyle? errorNoticeLabel;

		private ConfigEntry<bool> bones;

		private ConfigEntry<bool> world;

		private ConfigEntry<bool> chat;

		private ConfigEntry<bool> noShadow;

		private ConfigEntry<bool> showDebugOverlay;

		private ConfigEntry<bool> cinematicMove;

		private ConfigEntry<bool> showFog;

		private ConfigEntry<int> rate;

		private ConfigEntry<int> maxFields;

		private ConfigEntry<int> maxObjects;

		private ConfigEntry<int> maxVertices;

		private ConfigEntry<float> replayResolution;

		private ConfigEntry<float> replayGamma;

		private ConfigEntry<float> cameraSpeed;

		private ConfigEntry<string> folder;

		private ConfigEntry<string> extraTypes;

		private ReplayBookmarkInput? bookmarkInput;

		private EventHooks? hooks;

		private Recorder? recorder;

		private ReplayViewer? viewer;

		private ReplayViewer? cachedViewer;

		private string? viewerPath;

		private string? cachedViewerPath;

		private int viewerSceneHandle;

		private bool viewerConnected;

		private int cachedSceneHandle;

		private bool cachedConnected;

		private List<(string Path, long Length, DateTime ModifiedUtc)>? cachedFiles;

		private ReplayLibraryWindow? library;

		private ReplayMenuButton? menuButton;

		private ReplayPauseMenuButton? pauseMenuButton;

		private Harmony? inputHarmony;

		private static ReplayPlugin? activeInputGuard;

		private ReplayRuntime? runtime;

		private ReplayArchive? archive;

		private ArchiveIndex index = new ArchiveIndex();

		private ArchiveRun? run;

		private ArchiveSession? session;

		private ArchiveDay? day;

		private ArchiveSegment? segment;

		private IReadOnlyList<WorldSnapshot>? reusableWorld;

		private readonly List<Task<SaveResult>> pendingSaves = new List<Task<SaveResult>>();

		private readonly List<Task> pendingGroupSaves = new List<Task>();

		private DayLifecycle dayLifecycle = new DayLifecycle();

		private Component? sessionRound;

		private Component? deletedLobbyRound;

		private Task<ArchiveIndex>? scanning;

		private Task<LoadedRecording>? loading;

		private IEnumerator<float>? loadingPlayerAssets;

		private CancellationTokenSource? loadingCancellation;

		private bool rescanRequested;

		private bool recordingBlocked;

		private bool wasConnected;

		private bool quitting;

		private bool checkpointRequested;

		private bool dayHadRecoveryGap;

		private int recordingRetryFailures;

		private float nextRecordingRetryAt;

		private bool loadCancelled;

		private bool closeLibraryAfterSceneCleanup;

		private bool shutdownCompleted;

		private bool inputReported;

		private bool inputReadyReported;

		private Component? playbackPlayer;

		private bool savedMoveInput;

		private bool savedLookInput;

		private LiveReplayInput? liveReplayInput;

		private int part;

		private float nextMemberScan;

		private string status = "Gameplay is recorded and saved automatically.";

		private string recordingFailure = "";

		private string errorNotice = "";

		private float errorNoticeUntil;

		private float errorNoticeStarted;

		private bool errorNoticePending;

		private string? loadingPath;

		private float loadingSpeed = 1f;

		private int loadingPercent;

		private string loadingStage = "";

		private string ReplayDirectory => Path.GetFullPath(Path.IsPathRooted(folder.Value) ? folder.Value : Path.Combine(Paths.BepInExRootPath, folder.Value));

		private void Awake()
		{
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Expected O, but got Unknown
			//IL_0132: Unknown result type (might be due to invalid IL or missing references)
			//IL_013c: Expected O, but got Unknown
			//IL_016d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0177: Expected O, but got Unknown
			//IL_01ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b5: Expected O, but got Unknown
			//IL_0609: Unknown result type (might be due to invalid IL or missing references)
			//IL_060e: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b7: Expected O, but got Unknown
			//IL_0307: Unknown result type (might be due to invalid IL or missing references)
			//IL_0311: Expected O, but got Unknown
			//IL_03fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0405: Expected O, but got Unknown
			//IL_0467: Unknown result type (might be due to invalid IL or missing references)
			//IL_0471: Expected O, but got Unknown
			string text = Path.Combine(Paths.ConfigPath, "io.lcreplay.recorder.cfg");
			if (!File.Exists(((BaseUnityPlugin)this).Config.ConfigFilePath) && File.Exists(text))
			{
				try
				{
					File.Copy(text, ((BaseUnityPlugin)this).Config.ConfigFilePath, overwrite: false);
					((BaseUnityPlugin)this).Config.Reload();
				}
				catch (Exception ex)
				{
					((BaseUnityPlugin)this).Logger.LogWarning((object)("Could not migrate legacy replay settings: " + ex.Message));
				}
			}
			activeInputGuard = this;
			rate = ((BaseUnityPlugin)this).Config.Bind<int>("Recording", "SampleRate", 10, new ConfigDescription("Automatic recording snapshots per second.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 60), Array.Empty<object>()));
			bones = ((BaseUnityPlugin)this).Config.Bind<bool>("Recording", "CaptureBones", false, "Also record player and item bone poses on each sample. Enemy visual poses are always recorded after animation and procedural movement; other actors use installed Animator controllers when off.");
			world = ((BaseUnityPlugin)this).Config.Bind<bool>("Recording", "CaptureWorld", true, "Save bounded geometry, textures and actor appearance for offline replay.");
			chat = ((BaseUnityPlugin)this).Config.Bind<bool>("Recording", "CaptureChat", false, "Capture displayed text chat. Restart required.");
			maxFields = ((BaseUnityPlugin)this).Config.Bind<int>("Limits", "FieldsPerEntity", 192, new ConfigDescription("Primitive fields per component.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(32, 512), Array.Empty<object>()));
			maxObjects = ((BaseUnityPlugin)this).Config.Bind<int>("Limits", "WorldObjects", 4000, new ConfigDescription("Render object budget per world snapshot.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(100, 20000), Array.Empty<object>()));
			maxVertices = ((BaseUnityPlugin)this).Config.Bind<int>("Limits", "WorldVertices", 500000, new ConfigDescription("Unique mesh vertex budget per world snapshot; repeated room meshes share data.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1000, 1000000), Array.Empty<object>()));
			ConfigEntry<int> val = ((BaseUnityPlugin)this).Config.Bind<int>("Compatibility", "CaptureSettingsVersion", 0, "Internal capture settings migration version.");
			if (val.Value < 4)
			{
				if (maxVertices.Value == 120000)
				{
					maxVertices.Value = 500000;
				}
				val.Value = 4;
			}
			if (val.Value < 5)
			{
				bones.Value = false;
				val.Value = 5;
			}
			if (val.Value < 6)
			{
				val.Value = 6;
			}
			folder = ((BaseUnityPlugin)this).Config.Bind<string>("Storage", "ReplayDirectory", "replays", "Absolute folder, or relative to BepInEx. Restart after changing.");
			extraTypes = ((BaseUnityPlugin)this).Config.Bind<string>("Compatibility", "ExtraTrackedTypes", "", "Comma-separated full Unity Component names supplied by other mods.");
			replayResolution = ((BaseUnityPlugin)this).Config.Bind<float>("Playback", "ResolutionMultiplier", 1f, new ConfigDescription("Replay resolution relative to the HDLethalCompany vanilla baseline: 1 = 860x520. Independent of window size; UI stays sharp. Replaces RenderResolutionScale.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.25f, 4.5f), Array.Empty<object>()));
			ConfigEntry<int> val2 = ((BaseUnityPlugin)this).Config.Bind<int>("Compatibility", "PlaybackSettingsVersion", 0, "Internal playback defaults migration version.");
			replayGamma = ((BaseUnityPlugin)this).Config.Bind<float>("Playback", "Gamma", 1f, new ConfigDescription("Replay image gamma; 1.0 is neutral.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.5f, 2f), Array.Empty<object>()));
			noShadow = ((BaseUnityPlugin)this).Config.Bind<bool>("Playback", "NoShadow", false, "Keep outside illumination inside the facility and disable replay light shadows.");
			showFog = ((BaseUnityPlugin)this).Config.Bind<bool>("Playback", "ShowFog", true, "Render recorded HDRP fog, local fog and fog-named scenery in replay.");
			if (val2.Value < 3)
			{
				replayResolution.Value = 1f;
				replayGamma.Value = 1f;
				noShadow.Value = false;
				showFog.Value = true;
				val2.Value = 3;
				((BaseUnityPlugin)this).Config.Save();
			}
			cinematicMove = ((BaseUnityPlugin)this).Config.Bind<bool>("Playback", "CinematicMove", false, "Use smooth acceleration and deceleration for the replay free camera. Press C in replay to toggle.");
			cameraSpeed = ((BaseUnityPlugin)this).Config.Bind<float>("Playback", "CameraSpeed", 8f, new ConfigDescription("Free camera speed in replay.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(1f, 30f), Array.Empty<object>()));
			showDebugOverlay = ((BaseUnityPlugin)this).Config.Bind<bool>("Debug", "ShowOverlay", false, "Show the recording status in the top-left corner during gameplay. Errors appear briefly in the top-right corner regardless of this setting.");
			ConfigEntry<KeyCode> fallback = ((BaseUnityPlugin)this).Config.Bind<KeyCode>("Input", "BookmarkKey", (KeyCode)96, "Recording bookmark key when InputUtils is absent. With InputUtils, change Add replay bookmark in the game's Controls menu.");
			bookmarkInput = new ReplayBookmarkInput(fallback, delegate(string message)
			{
				((BaseUnityPlugin)this).Logger.LogInfo((object)message);
			});
			try
			{
				archive = new ReplayArchive(ReplayDirectory);
				((BaseUnityPlugin)this).Logger.LogInfo((object)("Replay archive directory: " + archive.RootDirectory));
				library = new ReplayLibraryWindow();
				menuButton = new ReplayMenuButton(OpenLibrary, delegate(string message)
				{
					((BaseUnityPlugin)this).Logger.LogWarning((object)message);
				}, delegate(string message)
				{
					((BaseUnityPlugin)this).Logger.LogInfo((object)message);
				});
				pauseMenuButton = new ReplayPauseMenuButton(OpenLibrary, delegate(string message)
				{
					((BaseUnityPlugin)this).Logger.LogWarning((object)message);
				});
				InstallInputGuards();
				library.RefreshRequested += RefreshArchive;
				library.PlayRequested += delegate(string path)
				{
					LoadReplay(path);
				};
				library.OpenFolderRequested += OpenFolder;
				library.DeleteRequested += DeleteRecording;
				library.CloseRequested += CloseLibrary;
				hooks = new EventHooks(delegate(ReplayEvent evt)
				{
					recorder?.Event(evt);
					if (evt.Name.Contains("OnShipLanded"))
					{
						recorder?.RefreshEnvironmentAfterLanding();
					}
					else if (evt.Name.Contains("StartGame"))
					{
						recorder?.MarkWorldDirty();
					}
					else if (evt.Name == "SandSpiderAI.SpawnWebTrapClientRpc")
					{
						recorder?.NoticeSpiderWeb();
					}
				}, chat.Value, delegate(string message)
				{
					((BaseUnityPlugin)this).Logger.LogWarning((object)message);
				});
				((BaseUnityPlugin)this).Logger.LogInfo((object)string.Format("LC Replay {0}: automatic quota/deadline archive; {1} event hooks active.", "1.0.0", hooks.Installed.Count));
			}
			catch (Exception error)
			{
				ReportRecordingFailure("Initialization failed", error);
			}
			SceneManager.sceneLoaded += SceneLoaded;
			Application.quitting += ApplicationQuitting;
			((BaseUnityPlugin)this).Logger.LogInfo((object)"Replay bootstrap ready; waiting for a loaded scene before creating the runtime.");
			Scene activeScene = SceneManager.GetActiveScene();
			if (((Scene)(ref activeScene)).isLoaded)
			{
				EnsureRuntime();
			}
		}

		private void SceneLoaded(Scene scene, LoadSceneMode mode)
		{
			EnsureRuntime();
		}

		private void EnsureRuntime()
		{
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			if (quitting || shutdownCompleted || Object.op_Implicit((Object)(object)runtime))
			{
				return;
			}
			try
			{
				runtime = ReplayRuntime.Create(RunFrame, DrawUi, RunLateFrame, delegate
				{
					((BaseUnityPlugin)this).Logger.LogInfo((object)"Replay runtime active: independent persistent frame and UI driver.");
				}, delegate(string stage, Exception ex)
				{
					ShowErrorNotice("Replay runtime " + stage + " failed: " + ex.Message);
					((BaseUnityPlugin)this).Logger.LogError((object)("Replay runtime " + stage + " failed: " + ex));
				});
				ManualLogSource logger = ((BaseUnityPlugin)this).Logger;
				Scene activeScene = SceneManager.GetActiveScene();
				logger.LogInfo((object)("Replay runtime created after scene load: " + ((Scene)(ref activeScene)).name + "."));
			}
			catch (Exception error)
			{
				ReportRecordingFailure("Replay runtime initialization failed", error);
			}
		}

		private void RunFrame()
		{
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: 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)
			if (quitting)
			{
				return;
			}
			NativePlayerAssetLoader.Tick();
			if (viewer != null || cachedViewer != null || loading != null || SceneAssetReplay.HasPendingLoads || ReplayViewer.HasPendingSceneCleanup || NativePlayerAssetLoader.RequiresIsolation)
			{
				ReplayIsolation.EnsureNetworkExclusion();
			}
			Scene activeScene;
			if (cachedViewer != null)
			{
				if (cachedConnected == GameAccess.Connected)
				{
					int num = cachedSceneHandle;
					activeScene = SceneManager.GetActiveScene();
					if (num == ((Scene)(ref activeScene)).handle)
					{
						goto IL_0071;
					}
				}
				DiscardCachedViewer();
			}
			goto IL_0071;
			IL_01d1:
			object replayPauseMenuButton;
			int allowed;
			((ReplayPauseMenuButton)replayPauseMenuButton).Tick((byte)allowed != 0);
			goto IL_01d6;
			IL_01d6:
			if (viewer != null)
			{
				BlockLocalPlayerInput();
				if (viewer.CloseRequested || ReplayInput.WasPressed("Escape") || ReplayInput.WasPressed("F11"))
				{
					CloseViewer(reopenLibrary: true);
					return;
				}
				try
				{
					viewer.Tick(Time.unscaledDeltaTime);
				}
				catch (Exception ex)
				{
					((BaseUnityPlugin)this).Logger.LogError((object)ex);
					CloseViewer(reopenLibrary: true, allowCache: false);
					status = "Playback error: " + ex.Message;
					ShowErrorNotice(status);
				}
				if (viewer?.Error != null)
				{
					Exception error = viewer.Error;
					((BaseUnityPlugin)this).Logger.LogError((object)error);
					CloseViewer(reopenLibrary: true, allowCache: false);
					status = "A recording part could not be loaded: " + error.Message;
					ShowErrorNotice(status);
				}
				return;
			}
			bool connected;
			CompleteLoad(connected);
			if (viewer != null)
			{
				return;
			}
			if (ReplayInput.WasPressed("F9"))
			{
				ReplayLibraryWindow? replayLibraryWindow = library;
				if (replayLibraryWindow != null && replayLibraryWindow.IsOpen)
				{
					if (!library.DismissDialog())
					{
						CloseLibrary();
					}
				}
				else
				{
					OpenLibrary();
				}
			}
			ReplayLibraryWindow? replayLibraryWindow2 = library;
			if (replayLibraryWindow2 != null && replayLibraryWindow2.IsOpen)
			{
				library.Tick();
				BlockLocalPlayerInput();
				ReplayLibraryWindow? replayLibraryWindow3 = library;
				string text = status;
				bool networkStateKnown = GameAccess.NetworkStateKnown;
				bool isLoading = loading != null || scanning != null;
				string text2 = recordingFailure;
				float loadProgress = ((loading != null) ? ((float)Volatile.Read(in loadingPercent) / 100f) : 0f);
				string loadStage = ((loading != null) ? Volatile.Read(in loadingStage) : ((scanning != null) ? "Scanning archive" : ""));
				ArchiveDay? obj = day;
				replayLibraryWindow3.DrawGui(text, networkStateKnown, isLoading, text2, loadProgress, loadStage, ((obj != null) ? ((ArchiveFolder)obj).Id : null) ?? "");
				if (ReplayInput.WasPressed("Escape") && !library.DismissDialog())
				{
					CloseLibrary();
				}
			}
			if (ReplayInput.WasPressed("F8") && GameAccess.CanRecord && archive != null && hooks != null)
			{
				try
				{
					if (recordingBlocked && day != null)
					{
						archive.EndDay(day, "interrupted");
						day = null;
						segment = null;
						part = 0;
						reusableWorld = null;
					}
					recordingBlocked = false;
					nextRecordingRetryAt = 0f;
					recordingRetryFailures = 0;
					if (recorder != null)
					{
						checkpointRequested = true;
					}
				}
				catch (Exception error2)
				{
					RecoverRecording("Save checkpoint failed", error2);
				}
			}
			ReplayBookmarkInput? replayBookmarkInput = bookmarkInput;
			if (replayBookmarkInput != null && replayBookmarkInput.WasPressed())
			{
				AddRecordingBookmark();
			}
			if (ReplayInput.WasPressed("F11"))
			{
				OpenLibrary();
			}
			return;
			IL_0197:
			replayPauseMenuButton = pauseMenuButton;
			if (replayPauseMenuButton == null)
			{
				goto IL_01d6;
			}
			if (connected && viewer == null)
			{
				ReplayLibraryWindow? replayLibraryWindow4 = library;
				if (replayLibraryWindow4 == null || !replayLibraryWindow4.IsOpen)
				{
					allowed = ((loading == null) ? 1 : 0);
					goto IL_01d1;
				}
			}
			allowed = 0;
			goto IL_01d1;
			IL_0071:
			if (closeLibraryAfterSceneCleanup && !SceneAssetReplay.HasPendingLoads && !ReplayViewer.HasPendingSceneCleanup)
			{
				CloseLibrary();
			}
			bool available = ReplayInput.Available;
			if (!inputReported || (available && !inputReadyReported))
			{
				((BaseUnityPlugin)this).Logger.LogInfo((object)(available ? "Replay keyboard input ready (F9 opens the archive)." : "Replay keyboard input is not ready; waiting for an Input System keyboard."));
				inputReported = true;
				inputReadyReported |= available;
			}
			connected = GameAccess.Connected;
			if (viewer != null)
			{
				if (viewerConnected == connected)
				{
					int num2 = viewerSceneHandle;
					activeScene = SceneManager.GetActiveScene();
					if (num2 == ((Scene)(ref activeScene)).handle)
					{
						goto IL_0115;
					}
				}
				CloseViewer(reopenLibrary: false, allowCache: false);
				status = "Replay closed after the live game changed scenes.";
				return;
			}
			goto IL_0115;
			IL_0115:
			if (!connected && wasConnected)
			{
				EndSession();
				recordingBlocked = false;
				recordingRetryFailures = 0;
				nextRecordingRetryAt = 0f;
			}
			wasConnected = connected;
			CompleteSaves();
			ResumeRecordingWhenReady();
			CompleteScan();
			ReplayMenuButton? replayMenuButton = menuButton;
			if (replayMenuButton == null)
			{
				goto IL_0197;
			}
			int allowed2;
			if (!connected && viewer == null)
			{
				ReplayLibraryWindow? replayLibraryWindow5 = library;
				if (replayLibraryWindow5 == null || !replayLibraryWindow5.IsOpen)
				{
					allowed2 = ((loading == null) ? 1 : 0);
					goto IL_0192;
				}
			}
			allowed2 = 0;
			goto IL_0192;
			IL_0192:
			replayMenuButton.Tick((byte)allowed2 != 0);
			goto IL_0197;
		}

		private void RunLateFrame()
		{
			//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_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Expected O, but got Unknown
			if (quitting)
			{
				return;
			}
			viewer?.RefreshCursor();
			if (hooks != null && archive != null && GameAccess.CanRecord)
			{
				try
				{
					if (checkpointRequested)
					{
						recorder?.Event(new ReplayEvent
						{
							Category = "capture",
							Name = "manual-checkpoint"
						});
					}
					RecordAutomatically(viewer != null);
				}
				catch (Exception error)
				{
					RecoverRecording("Automatic recording stopped", error);
				}
			}
			checkpointRequested = false;
		}

		private unsafe void RecordAutomatically(bool playbackActive = false)
		{
			//IL_023a: Unknown result type (might be due to invalid IL or missing references)
			//IL_023f: Unknown result type (might be due to invalid IL or missing references)
			//IL_024c: Unknown result type (might be due to invalid IL or missing references)
			//IL_024f: Invalid comparison between Unknown and I4
			//IL_0260: Unknown result type (might be due to invalid IL or missing references)
			//IL_0265: 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_0283: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b2: Expected O, but got Unknown
			//IL_0428: Unknown result type (might be due to invalid IL or missing references)
			//IL_0229: Unknown result type (might be due to invalid IL or missing references)
			//IL_0233: Expected O, but got Unknown
			//IL_049d: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_04b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_04f9: Expected O, but got Unknown
			//IL_0507: Unknown result type (might be due to invalid IL or missing references)
			//IL_050a: Invalid comparison between Unknown and I4
			if (recordingBlocked)
			{
				return;
			}
			object obj = GameAccess.Singleton("StartOfRound");
			if (session != null)
			{
				Component val = (Component)((obj is Component) ? obj : null);
				if (val != null && (Object)(object)val != (Object)(object)sessionRound)
				{
					EndSession();
				}
			}
			if (recordingBlocked)
			{
				return;
			}
			if (!(GameAccess.Read(obj, "inShipPhase") is bool flag))
			{
				throw new InvalidOperationException("This game version does not expose round phase (inShipPhase).");
			}
			if ((Object)(object)deletedLobbyRound != (Object)null)
			{
				if (obj == deletedLobbyRound && flag)
				{
					return;
				}
				deletedLobbyRound = null;
			}
			ArchiveQuotaSnapshot val2 = CurrentQuota();
			if (session == null && (!val2.Target.HasValue || val2.Target.Value <= 0 || !val2.DeadlineDaysRemaining.HasValue || (val2.DeadlineDaysRemaining.Value == 0 && (!(GameAccess.Read(GameAccess.Singleton("TimeOfDay"), "timeUntilDeadline") is float num) || !(num > 0f)))))
			{
				return;
			}
			if (session == null)
			{
				object value = GameAccess.Singleton("GameNetworkManager");
				string text = (GameAccess.Read(value, "steamLobbyName") as string)?.Trim();
				if (string.IsNullOrWhiteSpace(text) && GameAccess.IsHost)
				{
					text = (GameAccess.Read(GameAccess.Read(value, "lobbyHostSettings"), "lobbyName") as string)?.Trim();
				}
				if (string.IsNullOrWhiteSpace(text))
				{
					text = "Unknown lobby";
				}
				if (run != null && !string.Equals(((ArchiveFolder)run).Label, text, StringComparison.Ordinal))
				{
					archive.EndRun(run);
					run = null;
				}
				run = run ?? archive.BeginRun(DateTimeOffset.UtcNow, text);
				session = archive.BeginQuota(run, DateTimeOffset.UtcNow, val2, GameAccess.IsHost ? "host-observed" : "client-observed");
				sessionRound = (Component?)((obj is Component) ? obj : null);
				dayLifecycle = new DayLifecycle();
			}
			DayTransition val3 = dayLifecycle.Observe(flag);
			if (day != null && (int)val3 == 2)
			{
				recorder?.Event(new ReplayEvent
				{
					Category = "day",
					Name = ((object)(*(DayTransition*)(&val3))/*cast due to .constrained prefix*/).ToString(),
					Data = new Dictionary<string, string> { ["day"] = dayLifecycle.DayNumber.ToString() }
				});
				recorder?.Tick(forceFrame: true, playbackActive);
				StopSegment();
				ArchiveDay val4 = day;
				day = null;
				part = 0;
				archive.EndDay(val4, (recordingBlocked || dayHadRecoveryGap) ? "interrupted" : "saved");
				dayHadRecoveryGap = false;
			}
			else
			{
				if (day == null && dayLifecycle.HasReturned)
				{
					return;
				}
				if (day == null && session.QuotaRemaining != val2.Remaining)
				{
					archive.EndSession(session);
					session = archive.BeginQuota(run, DateTimeOffset.UtcNow, val2, GameAccess.IsHost ? "host-observed" : "client-observed");
				}
				if (day == null)
				{
					BeginDay(obj, val2);
				}
				if (day == null)
				{
					return;
				}
				if (Time.realtimeSinceStartup >= nextMemberScan)
				{
					nextMemberScan = Time.realtimeSinceStartup + 2f;
					if (archive.UpdateMembers(day, CurrentMembers(obj)))
					{
						RefreshArchiveIfOpen();
					}
				}
				string text2 = CurrentMoon(obj);
				if ((!dayLifecycle.HasReturned && text2 != day.Moon) || (int)val3 != 0)
				{
					archive.UpdateDay(day, dayLifecycle.HasReturned ? day.Moon : text2, dayLifecycle.HasReturned ? "returned" : (dayLifecycle.HasDeparted ? "exploring" : "preparing"));
				}
				if (recorder == null)
				{
					StartSegment();
				}
				if (recorder != null)
				{
					if ((int)val3 != 0)
					{
						recorder.Event(new ReplayEvent
						{
							Category = "day",
							Name = ((object)(*(DayTransition*)(&val3))/*cast due to .constrained prefix*/).ToString(),
							Data = new Dictionary<string, string> { ["day"] = dayLifecycle.DayNumber.ToString() }
						});
					}
					recorder.Tick(checkpointRequested || (int)val3 == 2, playbackActive);
					if (recorder.Error != null)
					{
						Exception error = recorder.Error;
						RecoverRecording("Automatic saving stopped", error);
					}
					else if (recorder.Duration >= 30.0)
					{
						recordingRetryFailures = 0;
					}
				}
			}
		}

		private void BeginDay(object? round, ArchiveQuotaSnapshot quota)
		{
			int? num = null;
			if (GameAccess.IsHost && GameAccess.Read(GameAccess.Read(round, "gameStats"), "daysSpent") is int num2 && num2 >= 0 && num2 < 1000000)
			{
				num = num2 + 1;
			}
			day = archive.BeginQuotaDay(session, dayLifecycle.DayNumber, DateTimeOffset.UtcNow, CurrentMoon(round), quota, num);
			nextMemberScan = 0f;
			dayHadRecoveryGap = false;
			reusableWorld = null;
			archive.UpdateDay(day, day.Moon, dayLifecycle.HasReturned ? "returned" : (dayLifecycle.HasDeparted ? "exploring" : "preparing"));
			part = 0;
			RefreshArchiveIfOpen();
		}

		private static string CurrentMoon(object? round)
		{
			return GameAccess.Scalar(GameAccess.Read(GameAccess.Read(round, "currentLevel"), "PlanetName")) ?? "Unknown moon";
		}

		private static ArchiveQuotaSnapshot CurrentQuota()
		{
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: 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_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Expected O, but got Unknown
			object value = GameAccess.Singleton("TimeOfDay");
			int? num = NonnegativeInt(GameAccess.Read(value, "daysUntilDeadline"));
			object obj = GameAccess.Read(value, "timeUntilDeadline");
			object obj2 = GameAccess.Read(value, "totalTime");
			if (obj is float num2 && obj2 is float num3)
			{
				num = QuotaDay.Remaining(num2, num3, num);
			}
			return new ArchiveQuotaSnapshot
			{
				Target = NonnegativeInt(GameAccess.Read(value, "profitQuota")),
				Fulfilled = NonnegativeInt(GameAccess.Read(value, "quotaFulfilled")),
				DeadlineDaysRemaining = num,
				DeadlineDaysTotal = NonnegativeInt(GameAccess.Read(GameAccess.Read(value, "quotaVariables"), "deadlineDaysAmount")),
				QuotaCycle = NonnegativeInt(GameAccess.Read(value, "timesFulfilledQuota"))
			};
		}

		private static int? NonnegativeInt(object? value)
		{
			if (value == null)
			{
				return null;
			}
			try
			{
				return Math.Max(0, Convert.ToInt32(value, CultureInfo.InvariantCulture));
			}
			catch
			{
				return null;
			}
		}

		private static IEnumerable<string> CurrentMembers(object? round)
		{
			if (!(GameAccess.Read(round, "allPlayerScripts") is IEnumerable enumerable))
			{
				yield break;
			}
			foreach (object item in enumerable)
			{
				if (item != null && GameAccess.Bool(item, "isPlayerControlled") && GameAccess.Read(item, "playerUsername") is string text && !string.IsNullOrWhiteSpace(text))
				{
					yield return text;
				}
			}
		}

		private void StartSegment()
		{
			if (recorder != null || recordingBlocked || day == null || hooks == null)
			{
				return;
			}
			segment = archive.AllocateSegment(day, ++part);
			if (day.Members.Count != 0)
			{
				segment.Metadata["members"] = string.Join(", ", day.Members);
			}
			part = segment.Part;
			try
			{
				recorder = new Recorder(((ArchiveFolder)day).DirectoryPath, rate.Value, bones.Value, world.Value, maxFields.Value, maxObjects.Value, maxVertices.Value, extraTypes.Value, hooks, chat.Value, delegate(string message)
				{
					((BaseUnityPlugin)this).Logger.LogInfo((object)message);
				}, ((ArchiveFolder)day).Id, part, segment.FilePath, segment.Metadata, reusableWorld);
				ReplayApi.EventSink = recorder.Event;
				recordingFailure = "";
				library?.SetRecordingPath(segment.FilePath);
				status = "Quota " + (day.QuotaRemaining?.ToString() ?? "unknown") + " / Deadline " + (day.DeadlineDaysRemaining?.ToString() ?? "unknown") + " days - recording and saving automatically";
				((BaseUnityPlugin)this).Logger.LogInfo((object)("Recording " + segment.FilePath));
				RefreshArchiveIfOpen();
			}
			catch (Exception ex)
			{
				try
				{
					archive.CompleteSegment(segment, 0.0, false, ex.Message, (int?)