using System;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.IO.Compression;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
using Concentus;
using Concentus.Enums;
using Concentus.Oggfile;
using HarmonyLib;
using Il2Cpp;
using Il2CppInterop.Runtime.InteropTypes;
using Il2CppInterop.Runtime.InteropTypes.Arrays;
using Il2CppPhoton.Pun;
using Il2CppPhoton.Realtime;
using Il2CppPhoton.Voice;
using Il2CppPhoton.Voice.PUN;
using Il2CppPhoton.Voice.Unity;
using Il2CppRUMBLE.Audio;
using Il2CppRUMBLE.Combat.ShiftStones;
using Il2CppRUMBLE.Environment;
using Il2CppRUMBLE.Environment.MatchFlow;
using Il2CppRUMBLE.Input;
using Il2CppRUMBLE.Interactions.InteractionBase;
using Il2CppRUMBLE.Managers;
using Il2CppRUMBLE.MoveSystem;
using Il2CppRUMBLE.Networking;
using Il2CppRUMBLE.Networking.MatchFlow;
using Il2CppRUMBLE.Players;
using Il2CppRUMBLE.Players.Scaling;
using Il2CppRUMBLE.Players.Subsystems;
using Il2CppRUMBLE.Pools;
using Il2CppRUMBLE.Poses;
using Il2CppRUMBLE.Recording.LCK;
using Il2CppRUMBLE.Slabs.Forms;
using Il2CppRUMBLE.Social;
using Il2CppRUMBLE.Social.Phone;
using Il2CppRUMBLE.Utilities;
using Il2CppSystem;
using Il2CppSystem.Collections.Generic;
using Il2CppSystem.IO;
using Il2CppTMPro;
using MelonLoader;
using MelonLoader.Preferences;
using MelonLoader.Utils;
using Newtonsoft.Json;
using ReplayMod.Core;
using ReplayMod.Replay;
using ReplayMod.Replay.Files;
using ReplayMod.Replay.Serialization;
using ReplayMod.Replay.UI;
using RumbleModdingAPI.RMAPI;
using UIFramework;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.InputSystem.XR;
using UnityEngine.Rendering;
using UnityEngine.SceneManagement;
using UnityEngine.UI;
using UnityEngine.VFX;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: MelonInfo(typeof(Main), "ReplayMod", "1.2.0", "ERROR", null)]
[assembly: MelonGame("Buckethead Entertainment", "RUMBLE")]
[assembly: MelonColor(255, 255, 0, 0)]
[assembly: MelonAuthorColor(255, 255, 0, 0)]
[assembly: MelonAdditionalDependencies(new string[] { "RumbleModdingAPI", "UIFramework" })]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = "")]
[assembly: AssemblyCompany("ReplayMod")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("ReplayMod")]
[assembly: AssemblyTitle("ReplayMod")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.All)]
	public sealed class NullableAttribute : Attribute
	{
		public NullableAttribute(byte flag)
		{
		}

		public NullableAttribute(byte[] flags)
		{
		}
	}
	[AttributeUsage(AttributeTargets.All)]
	public sealed class NullableContextAttribute : Attribute
	{
		public NullableContextAttribute(byte flag)
		{
		}
	}
}
namespace ReplayMod
{
	public static class BinaryExtensions
	{
		public static void Write(this BinaryWriter bw, Vector3 v)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			bw.Write(v.x);
			bw.Write(v.y);
			bw.Write(v.z);
		}

		public static void Write(this BinaryWriter bw, Quaternion q)
		{
			int num = 0;
			float num2 = Mathf.Abs(((Quaternion)(ref q))[0]);
			for (int i = 1; i < 4; i++)
			{
				float num3 = Mathf.Abs(((Quaternion)(ref q))[i]);
				if (num3 > num2)
				{
					num = i;
					num2 = num3;
				}
			}
			float num4 = ((((Quaternion)(ref q))[num] < 0f) ? (-1f) : 1f);
			for (int j = 0; j < 4; j++)
			{
				if (j != num)
				{
					ushort value = (ushort)(Mathf.Clamp01(((Quaternion)(ref q))[j] * num4 * 0.5f + 0.5f) * 65535f);
					bw.Write(value);
				}
			}
			bw.Write((byte)num);
		}

		public static Vector3 ReadVector3(this BinaryReader br)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			return new Vector3(br.ReadSingle(), br.ReadSingle(), br.ReadSingle());
		}

		public static Quaternion ReadQuaternion(this BinaryReader br)
		{
			//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_010a: Unknown result type (might be due to invalid IL or missing references)
			float[] array = new float[4];
			ushort num = br.ReadUInt16();
			ushort num2 = br.ReadUInt16();
			ushort num3 = br.ReadUInt16();
			byte b = br.ReadByte();
			float[] array2 = new float[3]
			{
				((float)(int)num / 65535f - 0.5f) * 2f,
				((float)(int)num2 / 65535f - 0.5f) * 2f,
				((float)(int)num3 / 65535f - 0.5f) * 2f
			};
			int num4 = 0;
			for (int i = 0; i < 4; i++)
			{
				if (i != b)
				{
					array[i] = array2[num4++];
				}
			}
			float num5 = 0f;
			for (int j = 0; j < 4; j++)
			{
				if (j != b)
				{
					num5 += array[j] * array[j];
				}
			}
			array[b] = Mathf.Sqrt(1f - num5);
			return new Quaternion(array[0], array[1], array[2], array[3]);
		}

		public static void Write<TField>(this BinaryWriter bw, TField field, Vector3 v) where TField : Enum
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			bw.Write(Convert.ToByte(field));
			bw.Write((ushort)12);
			bw.Write(v);
		}

		public static void Write<TField>(this BinaryWriter bw, TField field, Quaternion q) where TField : Enum
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			bw.Write(Convert.ToByte(field));
			bw.Write((ushort)7);
			bw.Write(q);
		}

		public static void Write<TField>(this BinaryWriter bw, TField field, short v) where TField : Enum
		{
			bw.Write(Convert.ToByte(field));
			bw.Write((ushort)2);
			bw.Write(v);
		}

		public static void Write<TField>(this BinaryWriter bw, TField field, bool v) where TField : Enum
		{
			bw.Write(Convert.ToByte(field));
			bw.Write((ushort)1);
			bw.Write(v);
		}

		public static void Write<TField>(this BinaryWriter bw, TField field, float f) where TField : Enum
		{
			bw.Write(Convert.ToByte(field));
			bw.Write((ushort)4);
			bw.Write(f);
		}

		public static void Write<TField>(this BinaryWriter bw, TField field, string s) where TField : Enum
		{
			byte[] bytes = Encoding.UTF8.GetBytes(s);
			bw.Write(Convert.ToByte(field));
			bw.Write((ushort)bytes.Length);
			bw.Write(bytes);
		}

		public static void Write<TField>(this BinaryWriter bw, TField field, int v) where TField : Enum
		{
			bw.Write(Convert.ToByte(field));
			bw.Write((ushort)4);
			bw.Write(v);
		}

		public static void Write<TField>(this BinaryWriter bw, TField field, byte v) where TField : Enum
		{
			bw.Write(Convert.ToByte(field));
			bw.Write((ushort)1);
			bw.Write(v);
		}

		public static void Write<TField>(this BinaryWriter bw, TField field, long v) where TField : Enum
		{
			bw.Write(Convert.ToByte(field));
			bw.Write((ushort)8);
			bw.Write(v);
		}

		public static void Write<TField>(this BinaryWriter bw, TField field, double v) where TField : Enum
		{
			bw.Write(Convert.ToByte(field));
			bw.Write((ushort)8);
			bw.Write(v);
		}

		public static void Write<TField>(this BinaryWriter bw, TField field, Vector2 v) where TField : Enum
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			bw.Write(Convert.ToByte(field));
			bw.Write((ushort)8);
			bw.Write(v.x);
			bw.Write(v.y);
		}

		public static void Write<TField>(this BinaryWriter bw, TField field, Color32 c) where TField : Enum
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			bw.Write(Convert.ToByte(field));
			bw.Write((ushort)4);
			bw.Write(c.r);
			bw.Write(c.g);
			bw.Write(c.b);
			bw.Write(c.a);
		}

		public static void Write<TField, TEnum>(this BinaryWriter bw, TField field, TEnum value) where TField : Enum where TEnum : Enum
		{
			bw.Write(Convert.ToByte(field));
			bw.Write((ushort)4);
			bw.Write(Convert.ToInt32(value));
		}
	}
	public class ReplayCodec
	{
		public static byte[] Compress(byte[] data)
		{
			using MemoryStream memoryStream = new MemoryStream();
			using (BrotliStream brotliStream = new BrotliStream(memoryStream, CompressionLevel.Optimal, leaveOpen: true))
			{
				brotliStream.Write(data, 0, data.Length);
			}
			return memoryStream.ToArray();
		}

		public static byte[] Decompress(byte[] compressed)
		{
			using MemoryStream stream = new MemoryStream(compressed);
			using BrotliStream brotliStream = new BrotliStream(stream, CompressionMode.Decompress);
			using MemoryStream memoryStream = new MemoryStream();
			brotliStream.CopyTo(memoryStream);
			return memoryStream.ToArray();
		}
	}
}
namespace ReplayMod.Replay
{
	public static class ReplayAPI
	{
		public sealed class FrameExtensionWriter
		{
			private readonly BinaryWriter _entriesWriter;

			private readonly int _extensionId;

			private readonly Action _incrementEntryCount;

			internal FrameExtensionWriter(BinaryWriter entriesWriter, int extensionId, Action incrementEntryCount)
			{
				_entriesWriter = entriesWriter;
				_extensionId = extensionId;
				_incrementEntryCount = incrementEntryCount;
			}

			public void WriteChunk(int subIndex, Action<BinaryWriter> write)
			{
				using MemoryStream memoryStream = new MemoryStream();
				using BinaryWriter obj = new BinaryWriter(memoryStream);
				write(obj);
				if (memoryStream.Length != 0)
				{
					_entriesWriter.Write((byte)250);
					_entriesWriter.Write(_extensionId);
					_entriesWriter.Write(subIndex);
					_entriesWriter.Write((int)memoryStream.Length);
					_entriesWriter.Write(memoryStream.ToArray());
					_incrementEntryCount?.Invoke();
				}
			}
		}

		public sealed class ArchiveBuilder
		{
			private readonly ZipArchive _zip;

			private readonly string _modId;

			internal ArchiveBuilder(ZipArchive zip, string modId)
			{
				_zip = zip;
				_modId = modId;
			}

			public void AddFile(string path, byte[] data, CompressionLevel level = CompressionLevel.Optimal)
			{
				ZipArchiveEntry zipArchiveEntry = _zip.CreateEntry("extensions/" + _modId + "/" + path, level);
				using Stream stream = zipArchiveEntry.Open();
				stream.Write(data, 0, data.Length);
			}
		}

		public sealed class ArchiveReader
		{
			private readonly ZipArchive _zip;

			private readonly string _modId;

			internal ArchiveReader(ZipArchive zip, string modId)
			{
				_zip = zip;
				_modId = modId;
			}

			private string GetFullPath(string relativePath)
			{
				return "extensions/" + _modId + "/" + relativePath;
			}

			public bool TryGetFile(string relativePath, out byte[] data)
			{
				ZipArchiveEntry entry = _zip.GetEntry(GetFullPath(relativePath));
				if (entry == null)
				{
					data = null;
					return false;
				}
				using Stream stream = entry.Open();
				using MemoryStream memoryStream = new MemoryStream();
				stream.CopyTo(memoryStream);
				data = memoryStream.ToArray();
				return true;
			}

			public bool FileExists(string relativePath)
			{
				return _zip.GetEntry(GetFullPath(relativePath)) != null;
			}
		}

		private static readonly List<ReplayExtension> _extensions = new List<ReplayExtension>();

		private static readonly Dictionary<int, Action<BinaryReader, Frame>> _frameReaders = new Dictionary<int, Action<BinaryReader, Frame>>();

		private static readonly Dictionary<int, Action<FrameExtensionWriter, Frame>> _frameWriters = new Dictionary<int, Action<FrameExtensionWriter, Frame>>();

		public static bool IsRecording => Main.Recording.isRecording;

		public static bool IsBuffering => Main.Recording.isBuffering;

		public static bool IsPlaying => Main.Playback.isPlaying;

		public static bool IsPaused => Main.Playback.isPaused;

		public static float CurrentTime => Main.Playback.elapsedPlaybackTime;

		public static float Duration => (Main.Playback.currentReplay?.Header?.Duration).GetValueOrDefault();

		public static Version FormatVersion => new Version("1.1.0");

		public static string RootFolder => ReplayFiles.explorer.RootPath;

		public static string CurrentFolder => ReplayFiles.explorer.CurrentFolderPath;

		public static IReadOnlyList<ReplayExplorer.Entry> Entries => ReplayFiles.explorer.currentReplayEntries;

		public static ReplayExplorer.Entry SelectedEntry => ReplayFiles.explorer.currentlySelectedEntry;

		public static int ExplorerCurrentPage
		{
			get
			{
				return ReplayFiles.explorer.currentPage;
			}
			set
			{
				ReplayFiles.explorer.currentPage = value;
			}
		}

		public static int PageCount => ReplayFiles.explorer.pageCount;

		public static IReadOnlyList<ReplayPlayback.Clone> Players => Main.Playback.PlaybackPlayers;

		public static IReadOnlyList<ReplayPlayback.Clone> PlayerPool => Main.Playback.playerPool;

		public static IReadOnlyList<GameObject> Structures => Main.Playback.PlaybackStructures;

		public static ReplayInfo CurrentReplay => Main.Playback.currentReplay;

		internal static IEnumerable<ReplayExtension> Extensions => _extensions;

		public static event Action<ReplayExplorer.Entry, string> onReplaySelected;

		public static event Action<string> onExplorerFolderChanged;

		public static event Action onExplorerRefreshed;

		public static event Action<ReplayInfo> onReplayStarted;

		public static event Action<ReplayInfo> onReplayEnded;

		public static event Action onRecordingStarted;

		public static event Action onRecordingStopped;

		public static event Action<float> onReplayTimeChanged;

		public static event Action<bool> onReplayPauseChanged;

		public static event Action<Frame, Frame> OnPlaybackFrame;

		public static event Action<Frame, bool> OnRecordFrame;

		public static event Action<ReplayInfo, bool, string> onReplaySaved;

		public static event Action<string> onReplayDeleted;

		public static event Action<ReplaySerializer.ReplayHeader, string> onReplayRenamed;

		internal static void ReplaySelectedInternal(ReplayExplorer.Entry entry, string path)
		{
			ReplayAPI.onReplaySelected?.Invoke(entry, path);
		}

		internal static void ExplorerFolderChangedInternal(string path)
		{
			ReplayAPI.onExplorerFolderChanged?.Invoke(path);
		}

		internal static void ExplorerRefreshedInternal()
		{
			ReplayAPI.onExplorerRefreshed?.Invoke();
		}

		internal static void ReplayStartedInternal(ReplayInfo info)
		{
			ReplayAPI.onReplayStarted?.Invoke(info);
		}

		internal static void ReplayEndedInternal(ReplayInfo info)
		{
			ReplayAPI.onReplayEnded?.Invoke(info);
		}

		internal static void RecordingStartedInternal()
		{
			ReplayAPI.onRecordingStarted?.Invoke();
		}

		internal static void RecordingStoppedInternal()
		{
			ReplayAPI.onRecordingStopped?.Invoke();
		}

		internal static void ReplayTimeChangedInternal(float time)
		{
			ReplayAPI.onReplayTimeChanged?.Invoke(time);
		}

		internal static void ReplayPauseChangedInternal(bool paused)
		{
			ReplayAPI.onReplayPauseChanged?.Invoke(paused);
		}

		internal static void OnPlaybackFrameInternal(Frame frame, Frame nextFrame)
		{
			ReplayAPI.OnPlaybackFrame?.Invoke(frame, nextFrame);
		}

		internal static void OnRecordFrameInternal(Frame frame, bool isBuffer)
		{
			ReplayAPI.OnRecordFrame?.Invoke(frame, isBuffer);
		}

		internal static void ReplaySavedInternal(ReplayInfo info, bool isBuffer, string path)
		{
			ReplayAPI.onReplaySaved?.Invoke(info, isBuffer, path);
		}

		internal static void ReplayDeletedInternal(string path)
		{
			ReplayAPI.onReplayDeleted?.Invoke(path);
		}

		internal static void ReplayRenamedInternal(ReplaySerializer.ReplayHeader header, string newPath)
		{
			ReplayAPI.onReplayRenamed?.Invoke(header, newPath);
		}

		public static bool SelectEntry(int index)
		{
			return ReplayFiles.explorer.Select(index);
		}

		public static void Enter(string path)
		{
			ReplayFiles.explorer.Enter(path);
		}

		public static void GoUp()
		{
			ReplayFiles.explorer.GoUp();
		}

		public static void Refresh()
		{
			ReplayFiles.explorer.Refresh();
			ReplayFiles.RefreshUI();
		}

		public static IReadOnlyList<ReplayExplorer.Entry> GetPage()
		{
			return ReplayFiles.explorer.GetPage();
		}

		public static string GetMetadataFormat(string sceneName)
		{
			return ReplayFiles.GetMetadataFormat(sceneName);
		}

		public static string FormatReplayTemplate(string template, ReplaySerializer.ReplayHeader replayInfo)
		{
			return ReplayFormatting.FormatReplayString(template, replayInfo);
		}

		public static string GetReplayDisplayName(string replayPath, ReplaySerializer.ReplayHeader replayInfo, string alternativeName = null, bool displayTitle = true)
		{
			return ReplayFormatting.GetReplayDisplayName(replayPath, replayInfo, alternativeName, displayTitle);
		}

		public static void Play(string path)
		{
			Main.Playback.LoadReplay(path);
		}

		public static void LoadSelectedReplay()
		{
			Main.instance.LoadSelectedReplay();
		}

		public static void Stop()
		{
			Main.Playback.StopReplay();
		}

		public static void StartRecording()
		{
			Main.Recording.StartRecording();
		}

		public static void StopRecording()
		{
			Main.Recording.StopRecording();
		}

		public static void StartBuffering()
		{
			Main.Recording.StartBuffering();
		}

		public static void SaveBuffer()
		{
			Main.Recording.SaveReplayBuffer();
		}

		public static void TogglePlayback(bool playing)
		{
			Main.Playback.TogglePlayback(playing);
		}

		public static void Seek(float time)
		{
			Main.Playback.SetPlaybackTime(time);
		}

		public static void Seek(int frame)
		{
			Main.Playback.SetPlaybackFrame(frame);
		}

		public static void SetSpeed(float speed)
		{
			Main.Playback.SetPlaybackSpeed(speed);
		}

		public static int ComputeStableId(string input)
		{
			int num = -2128831035;
			foreach (char c in input)
			{
				num ^= c;
				num *= 16777619;
			}
			return num;
		}

		public static ReplayExtension RegisterExtension(ReplayExtension extension)
		{
			if (_extensions.Any((ReplayExtension e) => e.Id == extension.Id))
			{
				((MelonBase)Main.instance).LoggerInstance.Error("Extension with an ID `" + extension.Id + "` already registered");
				return null;
			}
			_extensions.Add(extension);
			((MelonBase)Main.instance).LoggerInstance.Msg("Extension '" + extension.Id + "' created");
			return extension;
		}

		internal static void InvokeArchiveBuild(ZipArchive zip)
		{
			foreach (ReplayExtension extension in Extensions)
			{
				ArchiveBuilder builder = new ArchiveBuilder(zip, extension.Id);
				extension.OnBuild(builder);
			}
		}

		internal static void InvokeArchiveRead(ZipArchive zip)
		{
			foreach (ReplayExtension extension in Extensions)
			{
				ArchiveReader reader = new ArchiveReader(zip, extension.Id);
				extension.OnRead(reader);
			}
		}
	}
	public abstract class ReplayExtension
	{
		public abstract string Id { get; }

		public MelonPreferences_Category Settings { get; internal set; }

		public MelonPreferences_Entry<bool> Enabled { get; internal set; }

		public bool IsEnabled => Enabled.Value;

		public int FrameExtensionId => ReplayAPI.ComputeStableId(Id);

		public virtual void OnBuild(ReplayAPI.ArchiveBuilder builder)
		{
		}

		public virtual void OnRead(ReplayAPI.ArchiveReader reader)
		{
		}

		public virtual void OnRecordFrame(Frame frame, bool isBuffer)
		{
		}

		public virtual void OnWriteFrame(ReplayAPI.FrameExtensionWriter writer, Frame frame)
		{
		}

		public virtual void OnReadFrame(BinaryReader reader, Frame frame, int index)
		{
		}

		public virtual void OnPlaybackFrame(Frame frame, Frame nextFrame)
		{
		}
	}
	public static class ReplayCache
	{
		public static Dictionary<string, StackType> NameToStackType = new Dictionary<string, StackType>(StringComparer.OrdinalIgnoreCase)
		{
			{
				"RockSlide",
				StackType.Dash
			},
			{
				"Jump",
				StackType.Jump
			},
			{
				"Flick",
				StackType.Flick
			},
			{
				"Parry",
				StackType.Parry
			},
			{
				"HoldLeft",
				StackType.HoldLeft
			},
			{
				"HoldRight",
				StackType.HoldRight
			},
			{
				"Stomp",
				StackType.Ground
			},
			{
				"Straight",
				StackType.Straight
			},
			{
				"Uppercut",
				StackType.Uppercut
			},
			{
				"Kick",
				StackType.Kick
			},
			{
				"Explode",
				StackType.Explode
			}
		};

		public static readonly Dictionary<string, FXOneShotType> AudioCallToFX = new Dictionary<string, FXOneShotType>
		{
			{
				"Call_Structure_Impact_Light",
				FXOneShotType.ImpactLight
			},
			{
				"Call_Structure_Impact_Medium",
				FXOneShotType.ImpactMedium
			},
			{
				"Call_Structure_Impact_Heavy",
				FXOneShotType.ImpactHeavy
			},
			{
				"Call_Structure_Impact_Massive",
				FXOneShotType.ImpactMassive
			},
			{
				"Call_Structure_Ground",
				FXOneShotType.GroundedSFX
			},
			{
				"Call_RockCam_Spawn",
				FXOneShotType.RockCamSpawn
			},
			{
				"Call_RockCam_Despawn",
				FXOneShotType.RockCamDespawn
			},
			{
				"Call_RockCam_Stick",
				FXOneShotType.RockCamStick
			},
			{
				"Call_Bodyhit_Hard",
				FXOneShotType.Fistbump
			},
			{
				"Call_FistBumpBonus",
				FXOneShotType.FistbumpGoin
			}
		};

		public static readonly Dictionary<string, FXOneShotType> VFXNameToFX = new Dictionary<string, FXOneShotType>
		{
			{
				"StructureCollision_VFX",
				FXOneShotType.StructureCollision
			},
			{
				"Ricochet_VFX",
				FXOneShotType.Ricochet
			},
			{
				"VFX_Dust_Modifier_Ground",
				FXOneShotType.Grounded
			},
			{
				"VFX_Dust_Modifier_Unground",
				FXOneShotType.Ungrounded
			},
			{
				"VFX_Dust_Structure_Impact",
				FXOneShotType.DustImpact
			},
			{
				"VFX_Dust_Structure_Spawn",
				FXOneShotType.Spawn
			},
			{
				"VFX_Dust_Structure_Break",
				FXOneShotType.Break
			},
			{
				"RockCamSpawn_VFX",
				FXOneShotType.RockCamSpawn
			},
			{
				"RockCamDespawn_VFX",
				FXOneShotType.RockCamDespawn
			},
			{
				"PlayerBoxInteractionVFX",
				FXOneShotType.Fistbump
			},
			{
				"FistbumpCoin",
				FXOneShotType.FistbumpGoin
			},
			{
				"Hitmarker",
				FXOneShotType.Hitmarker
			}
		};

		public static readonly Dictionary<FXOneShotType, string> FXToVFXName = new Dictionary<FXOneShotType, string>
		{
			{
				FXOneShotType.StructureCollision,
				"StructureCollision_VFX"
			},
			{
				FXOneShotType.Ricochet,
				"Ricochet_VFX"
			},
			{
				FXOneShotType.Grounded,
				"Ground_VFX"
			},
			{
				FXOneShotType.Ungrounded,
				"Unground_VFX"
			},
			{
				FXOneShotType.DustImpact,
				"DustImpact_VFX"
			},
			{
				FXOneShotType.Spawn,
				"DustSpawn_VFX"
			},
			{
				FXOneShotType.Break,
				"DustBreak_VFX"
			},
			{
				FXOneShotType.RockCamSpawn,
				"RockCamSpawn_VFX"
			},
			{
				FXOneShotType.RockCamDespawn,
				"RockCamDespawn_VFX"
			},
			{
				FXOneShotType.Fistbump,
				"PlayerBoxInteractionVFX"
			},
			{
				FXOneShotType.FistbumpGoin,
				"PlayerFistBumpBonusVFX"
			},
			{
				FXOneShotType.Jump,
				"Jump_VFX"
			},
			{
				FXOneShotType.Dash,
				"Dash_VFX"
			}
		};

		public static readonly Dictionary<FXOneShotType, string> FXToSFXName = new Dictionary<FXOneShotType, string>
		{
			{
				FXOneShotType.ImpactLight,
				"Call_Structure_Impact_Light"
			},
			{
				FXOneShotType.ImpactMedium,
				"Call_Structure_Impact_Medium"
			},
			{
				FXOneShotType.ImpactHeavy,
				"Call_Structure_Impact_Heavy"
			},
			{
				FXOneShotType.ImpactMassive,
				"Call_Structure_Impact_Massive"
			},
			{
				FXOneShotType.GroundedSFX,
				"Call_Structure_Ground"
			},
			{
				FXOneShotType.RockCamSpawn,
				"Call_RockCam_Spawn"
			},
			{
				FXOneShotType.RockCamDespawn,
				"Call_RockCam_Despawn"
			},
			{
				FXOneShotType.RockCamStick,
				"Call_RockCam_Stick"
			},
			{
				FXOneShotType.Fistbump,
				"Call_Bodyhit_Hard"
			},
			{
				FXOneShotType.FistbumpGoin,
				"Call_FistBumpBonus"
			}
		};

		public static Dictionary<StructureType, Pool<PooledMonoBehaviour>> structurePools;

		public static Dictionary<string, AudioCall> SFX;

		public static void BuildCacheTables()
		{
			structurePools = new Dictionary<StructureType, Pool<PooledMonoBehaviour>>();
			SFX = new Dictionary<string, AudioCall>();
			foreach (Pool<PooledMonoBehaviour> item in (Il2CppArrayBase<Pool<PooledMonoBehaviour>>)(object)Singleton<PoolManager>.instance.availablePools)
			{
				string resourceName = item.poolItem.resourceName;
				if (resourceName.Contains("RockCube"))
				{
					structurePools[StructureType.Cube] = item;
				}
				else if (resourceName.Contains("PrisonedPillar"))
				{
					structurePools[StructureType.PrisonedPillar] = item;
				}
				else if (resourceName.Contains("WrappedWall"))
				{
					structurePools[StructureType.WrappedWall] = item;
				}
				else if (resourceName.Contains("DockedDisk"))
				{
					structurePools[StructureType.DockedDisk] = item;
				}
				else if (resourceName.Contains("CageCube"))
				{
					structurePools[StructureType.CageCube] = item;
				}
				else if (resourceName.Contains("Pillar"))
				{
					structurePools[StructureType.Pillar] = item;
				}
				else if (resourceName.Contains("Disc"))
				{
					structurePools[StructureType.Disc] = item;
				}
				else if (resourceName.Contains("Wall"))
				{
					structurePools[StructureType.Wall] = item;
				}
				else if (resourceName == "Ball")
				{
					structurePools[StructureType.Ball] = item;
				}
				else if (resourceName.Contains("LargeRock"))
				{
					structurePools[StructureType.LargeRock] = item;
				}
				else if (resourceName.Contains("SmallRock"))
				{
					structurePools[StructureType.SmallRock] = item;
				}
				else if (resourceName.Contains("BoulderBall"))
				{
					structurePools[StructureType.CagedBall] = item;
					structurePools[StructureType.TetheredCagedBall] = item;
				}
				else if (resourceName.Contains("StructureTarget"))
				{
					structurePools[StructureType.Target] = item;
				}
			}
			AudioCall[] array = Il2CppArrayBase<AudioCall>.op_Implicit(Resources.FindObjectsOfTypeAll<AudioCall>());
			AudioCall[] array2 = array;
			foreach (AudioCall val in array2)
			{
				if (!((Object)(object)val == (Object)null) && !string.IsNullOrEmpty(((Object)val).name))
				{
					SFX[((Object)val).name] = val;
				}
			}
		}
	}
	public static class ReplayVoices
	{
		public class VoiceStreamWriter : IDisposable
		{
			public readonly int VoiceId;

			public readonly string Path;

			private readonly FileStream _fileStream;

			private readonly IOpusEncoder _encoder;

			private readonly OpusOggWriteStream _wav;

			public bool HasFrames { get; private set; }

			public float LastWriteTimestamp { get; private set; }

			public int SampleRate { get; private set; }

			public int Channels { get; private set; }

			public VoiceStreamWriter(int voiceId, int sampleRate, int channels, string path, int bitrate = 30000, int complexity = 8, float initalTimeStamp = 0f)
			{
				//IL_0080: Unknown result type (might be due to invalid IL or missing references)
				//IL_0086: Expected O, but got Unknown
				//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e3: Expected O, but got Unknown
				LastWriteTimestamp = Time.time;
				VoiceId = voiceId;
				Path = path;
				SampleRate = sampleRate;
				Channels = channels;
				_fileStream = File.Create(path);
				_encoder = OpusCodecFactory.CreateEncoder(sampleRate, channels, (OpusApplication)2048, (TextWriter)null);
				_encoder.Bitrate = bitrate;
				_encoder.Complexity = complexity;
				_encoder.SignalType = (OpusSignal)3001;
				OpusTags val = new OpusTags();
				val.Fields.Add("Type", "Rumble ReplayMod Captured Voice");
				val.Fields.Add("Origin", "https://github.com/xLoadingx/ReplayMod");
				val.Fields.Add("Encoder", "https://github.com/lostromb/concentus");
				_wav = new OpusOggWriteStream(_encoder, (Stream)_fileStream, val, 0, 5, false);
			}

			public void Write(float[] samples)
			{
				if (samples != null && samples.Length != 0)
				{
					HasFrames = true;
					int num = (int)((Time.time - LastWriteTimestamp) * (float)SampleRate);
					if (num >= SampleRate / 8)
					{
						Main.DebugLog($"Voice {VoiceId} silent for {Time.time - LastWriteTimestamp} seconds or {num} samples");
						_wav.WriteSamples(new float[num], 0, num);
					}
					_wav.WriteSamples(samples, 0, samples.Length);
					LastWriteTimestamp = Time.time;
				}
			}

			public void Dispose()
			{
				_wav.Finish();
				_fileStream?.Dispose();
			}
		}

		private static PunVoiceClient voice;

		private static readonly Dictionary<(int actorId, int voiceId), VoiceStreamWriter> writers = new Dictionary<(int, int), VoiceStreamWriter>();

		public static string VoiceCacheDir = Path.Combine(MelonEnvironment.UserDataDirectory, "ReplayMod", "VoiceCache");

		public static List<VoiceTrackInfo> VoiceTrackInfos = new List<VoiceTrackInfo>();

		public static bool isRecording;

		private static bool subscribed;

		public static bool HasActiveWriters => writers.Count > 0;

		public static void StartRecording()
		{
			if (!Main.instance.VoiceRecording.Value)
			{
				return;
			}
			isRecording = true;
			VoiceTrackInfos.Clear();
			if (Directory.Exists(VoiceCacheDir))
			{
				string[] files = Directory.GetFiles(VoiceCacheDir);
				foreach (string path in files)
				{
					File.Delete(path);
				}
			}
			else
			{
				Directory.CreateDirectory(VoiceCacheDir);
			}
			PunVoiceClient instance = PunVoiceClient.instance;
			if (instance != null)
			{
				if (!subscribed)
				{
					((VoiceConnection)instance).RemoteVoiceAdded = ((VoiceConnection)instance).RemoteVoiceAdded + Action<RemoteVoiceLink>.op_Implicit((Action<RemoteVoiceLink>)OnRemoteVoiceLinkAdded);
					subscribed = true;
				}
				if (((Il2CppArrayBase<LocalVoice>)(object)((Il2CppObjectBase)((VoiceConnection)instance).VoiceClient.LocalVoices).Cast<Il2CppReferenceArray<LocalVoice>>()).Length == 0)
				{
					Main.DebugLog("Local voices is empty");
				}
				Enumerator<RemoteVoiceLink> enumerator = ((VoiceConnection)instance).cachedRemoteVoices.GetEnumerator();
				while (enumerator.MoveNext())
				{
					RemoteVoiceLink current = enumerator.Current;
					OnRemoteVoiceLinkAdded(current);
				}
				Directory.CreateDirectory(VoiceCacheDir);
			}
		}

		public static void StopRecording()
		{
			isRecording = false;
			foreach (var item in writers.Keys.ToList())
			{
				stopWriter(item.actorId, item.voiceId);
			}
		}

		public static AudioClip LoadVoiceClipFromFile(string path)
		{
			byte[] data = File.ReadAllBytes(path);
			int sampleRate;
			int channels;
			float[] array = DecodeOpus(data, out sampleRate, out channels);
			AudioClip val = AudioClip.Create(Path.GetFileNameWithoutExtension(path), array.Length / channels, channels, sampleRate, false);
			((Object)val).hideFlags = (HideFlags)32;
			val.SetData(Il2CppStructArray<float>.op_Implicit(array), 0);
			return val;
		}

		public static float[] DecodeOpus(byte[] data, out int sampleRate, out int channels)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Expected O, but got Unknown
			using MemoryStream memoryStream = new MemoryStream(data);
			IOpusDecoder val = OpusCodecFactory.CreateDecoder(48000, 1, (TextWriter)null);
			OpusOggReadStream val2 = new OpusOggReadStream(val, (Stream)memoryStream);
			sampleRate = 48000;
			channels = 1;
			List<float> list = new List<float>();
			while (val2.HasNextPacket)
			{
				short[] array = val2.DecodeNextPacket();
				if (array != null)
				{
					for (int i = 0; i < array.Length; i++)
					{
						list.Add((float)array[i] / 32768f);
					}
				}
			}
			return list.ToArray();
		}

		public static void Cleanup()
		{
			VoiceTrackInfos.Clear();
			if (Directory.Exists(VoiceCacheDir))
			{
				Directory.Delete(VoiceCacheDir, recursive: true);
			}
		}

		private static void stopWriter(int actorId, int voiceId)
		{
			if (writers.Remove((actorId, voiceId), out var value))
			{
				value.Dispose();
				if (!value.HasFrames && File.Exists(value.Path))
				{
					File.Delete(value.Path);
				}
			}
		}

		public static void OnRemoteVoiceLinkAdded(RemoteVoiceLink link)
		{
			if (!isRecording)
			{
				return;
			}
			int playerId = link.PlayerId;
			int voiceId = link.VoiceId;
			float startTime = Time.time - Main.Recording.recordingStartTime;
			Main.DebugLog($"VoiceAdded actor={playerId} voice={voiceId}");
			Player val = ((IEnumerable<Player>)Singleton<PlayerManager>.instance.AllPlayers.ToArray()).FirstOrDefault((Func<Player, bool>)((Player p) => p.Data.GeneralData.ActorNo == playerId));
			string name = ((val != null) ? val.Data.GeneralData.PublicUsername : null) ?? "Unknown";
			string masterId = ((val != null) ? val.Data.GeneralData.PlayFabMasterId : null);
			name = Utilities.CleanName(name);
			RemoteVoiceLink obj = link;
			obj.FloatFrameDecoded += Action<FrameOut<float>>.op_Implicit((Action<FrameOut<float>>)delegate(FrameOut<float> frame)
			{
				if (isRecording)
				{
					if (!writers.TryGetValue((playerId, voiceId), out var value))
					{
						string text = $"p{name}_{masterId}_v{voiceId}_{Time.frameCount}.ogg";
						string path = Path.Combine(VoiceCacheDir, text);
						value = new VoiceStreamWriter(voiceId, link.VoiceInfo.SamplingRate, link.VoiceInfo.Channels, path, Mathf.Clamp(Main.instance.voiceBitrate.Value, 8, 128), 8, startTime);
						writers.Add((playerId, voiceId), value);
						VoiceTrackInfos.Add(new VoiceTrackInfo(masterId, playerId, voiceId, text, startTime));
					}
					value.Write(Il2CppArrayBase<float>.op_Implicit(frame.Buf));
				}
			});
			RemoteVoiceLink obj2 = link;
			obj2.RemoteVoiceRemoved += Action.op_Implicit((Action)delegate
			{
				stopWriter(playerId, voiceId);
			});
		}
	}
	public static class Utilities
	{
		private static GameObject customMultiplayerMaps;

		public static string GetFriendlySceneName(string scene)
		{
			if (1 == 0)
			{
			}
			string result = ((scene == "Map0") ? "Ring" : ((!(scene == "Map1")) ? scene : "Pit"));
			if (1 == 0)
			{
			}
			return result;
		}

		public static string GetActiveCustomMapName()
		{
			if (customMultiplayerMaps == null)
			{
				customMultiplayerMaps = GameObject.Find("CustomMultiplayerMaps");
			}
			if ((Object)(object)customMultiplayerMaps == (Object)null)
			{
				return null;
			}
			for (int i = 0; i < customMultiplayerMaps.transform.childCount; i++)
			{
				Transform child = customMultiplayerMaps.transform.GetChild(i);
				if (((Component)child).gameObject.activeInHierarchy)
				{
					return ((Object)child).name;
				}
			}
			return null;
		}

		public static string[] RebuildCustomMapFromScene()
		{
			//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_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = GameObject.Find("CustomMapParent");
			if ((Object)(object)val == (Object)null)
			{
				return null;
			}
			List<string> list = new List<string>();
			list.Add("1");
			list.Add(val.transform.childCount.ToString());
			for (int i = 0; i < val.transform.childCount; i++)
			{
				Transform child = val.transform.GetChild(i);
				string name = ((Object)child).name;
				Color val2 = Color.white;
				Renderer component = ((Component)child).GetComponent<Renderer>();
				if ((Object)(object)component != (Object)null && (Object)(object)component.material != (Object)null && component.material.HasProperty("_Color"))
				{
					val2 = component.material.color;
				}
				Vector3 position = child.position;
				Quaternion rotation = child.rotation;
				Vector3 eulerAngles = ((Quaternion)(ref rotation)).eulerAngles;
				Vector3 localScale = child.localScale;
				list.Add(name);
				list.Add(val2.r.ToString(CultureInfo.InvariantCulture));
				list.Add(val2.g.ToString(CultureInfo.InvariantCulture));
				list.Add(val2.b.ToString(CultureInfo.InvariantCulture));
				list.Add(position.x.ToString(CultureInfo.InvariantCulture));
				list.Add(position.y.ToString(CultureInfo.InvariantCulture));
				list.Add(position.z.ToString(CultureInfo.InvariantCulture));
				list.Add(eulerAngles.x.ToString(CultureInfo.InvariantCulture));
				list.Add(eulerAngles.y.ToString(CultureInfo.InvariantCulture));
				list.Add(eulerAngles.z.ToString(CultureInfo.InvariantCulture));
				list.Add(localScale.x.ToString(CultureInfo.InvariantCulture));
				list.Add(localScale.y.ToString(CultureInfo.InvariantCulture));
				list.Add(localScale.z.ToString(CultureInfo.InvariantCulture));
			}
			return list.ToArray();
		}

		public static GameObject GetCustomMap(string mapName)
		{
			//IL_002e: 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_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			if (customMultiplayerMaps == null)
			{
				customMultiplayerMaps = GameObject.Find("CustomMultiplayerMaps");
			}
			if ((Object)(object)customMultiplayerMaps == (Object)null)
			{
				Main.ReplayError("Selected replay uses a custom map, but custom maps are not installed.");
				return null;
			}
			Transform obj = customMultiplayerMaps.transform.Find(mapName);
			GameObject val = ((obj != null) ? ((Component)obj).gameObject : null);
			if ((Object)(object)val == (Object)null)
			{
				Main.ReplayError("Could not find the custom map '" + mapName + ".");
				return null;
			}
			return val;
		}

		public static string CleanName(string name)
		{
			if (string.IsNullOrWhiteSpace(name))
			{
				return "Unknown";
			}
			string text = Regex.Replace(name, "<.*?>", string.Empty);
			StringBuilder stringBuilder = new StringBuilder(text.Length);
			string text2 = text;
			foreach (char c in text2)
			{
				if (!char.IsSurrogate(c))
				{
					stringBuilder.Append(c);
				}
			}
			text = stringBuilder.ToString();
			char[] invalidFileNameChars = Path.GetInvalidFileNameChars();
			foreach (char c2 in invalidFileNameChars)
			{
				text = text.Replace(c2.ToString(), "");
			}
			text = Regex.Replace(text, "\\s+", " ").Trim();
			text = text.Replace("\\", "_").Replace("/", "_");
			return string.IsNullOrEmpty(text) ? "Unknown" : text;
		}

		public static bool IsReplayClone(PlayerController controller)
		{
			if ((Object)(object)controller == (Object)null || Main.Playback.PlaybackPlayers == null)
			{
				return false;
			}
			return Object.op_Implicit((Object)(object)((Component)controller).GetComponent<ReplayPlayback.Clone>());
		}

		public static IEnumerable<GameObject> EnumerateMatchPedestals()
		{
			return from p in ((IEnumerable<Pedestal>)Object.FindObjectsOfType<Pedestal>(true)).Where(delegate(Pedestal p)
				{
					//IL_0006: Unknown result type (might be due to invalid IL or missing references)
					//IL_000b: Unknown result type (might be due to invalid IL or missing references)
					Scene scene = ((Component)p).gameObject.scene;
					return ((Scene)(ref scene)).buildIndex != -1;
				})
				select ((Component)p).gameObject;
		}

		public static IEnumerator LoadMap(int index, float fadeDuration = 2f, Action onLoaded = null, float onLoadedDelay = 0.01f)
		{
			SceneSingleton<CombatManager>.instance.CleanStructureList();
			foreach (Structure structure in SceneSingleton<CombatManager>.instance.structures.ToArray())
			{
				if (!((Object)(object)structure == (Object)null))
				{
					try
					{
						structure.Kill(Vector3.zero, false, false, true);
					}
					catch
					{
					}
				}
			}
			Singleton<SceneManager>.instance.LoadSceneAsync(index, false, false, fadeDuration, (LoadSceneMode)0, (AudioCall)null);
			while (Singleton<SceneManager>.instance.IsLoadingScene)
			{
				yield return null;
			}
			yield return (object)new WaitForSeconds(onLoadedDelay);
			onLoaded?.Invoke();
		}

		public static bool HasVFXType(string type, Transform obj)
		{
			Il2CppArrayBase<ReplayPlayback.ReplayTag> componentsInChildren = ((Component)obj).GetComponentsInChildren<ReplayPlayback.ReplayTag>();
			foreach (ReplayPlayback.ReplayTag item in componentsInChildren)
			{
				if (item.Type == type)
				{
					return true;
				}
			}
			return false;
		}

		public static Vector3 GetPositionOverMesh(float a, float b, MeshRenderer renderer)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			float num = Mathf.Clamp01(a / b);
			Bounds localBounds = ((Renderer)renderer).localBounds;
			float x = Mathf.Lerp(((Bounds)(ref localBounds)).min.x, ((Bounds)(ref localBounds)).max.x, num);
			Vector3 center = ((Bounds)(ref localBounds)).center;
			center.x = x;
			return ((Component)renderer).transform.TransformPoint(center);
		}

		public static float GetProgressFromMeshPosition(Vector3 worldPos, MeshRenderer renderer)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = ((Component)renderer).transform.InverseTransformPoint(worldPos);
			Bounds localBounds = ((Renderer)renderer).localBounds;
			float x = ((Bounds)(ref localBounds)).min.x;
			float x2 = ((Bounds)(ref localBounds)).max.x;
			if (Mathf.Approximately(x2, x))
			{
				return 0f;
			}
			float num = Mathf.InverseLerp(x, x2, val.x);
			return Mathf.Clamp01(num);
		}

		public static Marker[] AddMarkers(ReplaySerializer.ReplayHeader header, MeshRenderer timelineRenderer, bool hideMarkers = true)
		{
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			foreach (ReplayPlayback.ReplayTag componentsInChild in ((Component)((Component)timelineRenderer).transform).GetComponentsInChildren<ReplayPlayback.ReplayTag>())
			{
				Object.Destroy((Object)(object)((Component)componentsInChild).gameObject);
			}
			if (header.Markers == null)
			{
				return null;
			}
			Marker[] markers = header.Markers;
			Marker[] array = markers;
			Color val2 = default(Color);
			foreach (Marker marker in array)
			{
				Vector3 positionOverMesh = GetPositionOverMesh(marker.time, header.Duration, timelineRenderer);
				GameObject val = Object.Instantiate<GameObject>(ReplayPlaybackControls.markerPrefab, ((Component)timelineRenderer).transform);
				if (!hideMarkers)
				{
					val.layer = LayerMask.NameToLayer("Default");
				}
				val.transform.localScale = new Vector3(0.0062f, 1.0836f, 0.0128f);
				val.transform.position = positionOverMesh;
				((Color)(ref val2))..ctor(marker.r, marker.g, marker.b, 1f);
				((Renderer)val.GetComponent<MeshRenderer>()).material.SetColor("_Overlay", val2);
				val.AddComponent<ReplayPlayback.ReplayTag>();
				val.SetActive(true);
			}
			return markers;
		}

		public static string FormatBytes(long bytes)
		{
			if (!((double)bytes >= 1048576.0))
			{
				if (!((double)bytes >= 1024.0))
				{
					return $"{bytes} B";
				}
				return $"{(double)bytes / 1024.0:0.##} KB";
			}
			return $"{(double)bytes / 1048576.0:0.##} MB";
		}

		public static float EaseInOut(float t)
		{
			return (t < 0.5f) ? (2f * t * t) : (1f - Mathf.Pow(-2f * t + 2f, 2f) / 2f);
		}

		public static float EaseOut(float t)
		{
			return 1f - Mathf.Pow(1f - t, 4f);
		}

		public static float EaseIn(float t)
		{
			return Mathf.Pow(t, 3f);
		}

		public static IEnumerator LerpValue<T>(Func<T> getter, Action<T> setter, Func<T, T, float, T> lerpFunc, T targetValue, float duration, Func<float, float> easing = null, Action done = null, float delay = 0f, Func<bool> isValid = null)
		{
			yield return (object)new WaitForSeconds(delay);
			T startValue = getter();
			float t = 0f;
			while (t < 1f)
			{
				if (isValid != null && !isValid())
				{
					yield break;
				}
				t += Time.deltaTime / duration;
				float easedT = easing?.Invoke(Mathf.Clamp01(t)) ?? t;
				setter(lerpFunc(startValue, targetValue, easedT));
				yield return null;
			}
			setter(targetValue);
			done?.Invoke();
		}

		public static Color32 RandomColor()
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			float value = Random.value;
			float num = Random.Range(0.6f, 0.9f);
			float num2 = Random.Range(0.7f, 1f);
			Color val = Color.HSVToRGB(value, num, num2);
			return Color32.op_Implicit(val);
		}

		public static T[] NewArray<T>(int count, T[] copyFrom = null) where T : new()
		{
			T[] array = new T[count];
			for (int i = 0; i < count; i++)
			{
				array[i] = ((copyFrom != null && i < copyFrom.Length) ? copyFrom[i] : new T());
			}
			return array;
		}

		public static int GetPageCount(int itemCount, int pageSize)
		{
			return (itemCount + pageSize - 1) / pageSize;
		}

		public static string FormatPage(int currentPage, int pageCount)
		{
			return (pageCount == 0) ? "0 / 0" : $"{currentPage + 1} / {pageCount}";
		}
	}
	[RegisterTypeInIl2Cpp]
	public class LookAtPlayer : MonoBehaviour
	{
		public bool lockX;

		public bool lockY;

		public bool lockZ;

		private void Update()
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: 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_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: 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)
			((Component)this).transform.rotation = Quaternion.Euler(0f, 270f, 0f);
			Camera main = Camera.main;
			if (!Object.op_Implicit((Object)(object)main))
			{
				return;
			}
			Vector3 val = ((Component)main).transform.position - ((Component)this).transform.position;
			if (!(((Vector3)(ref val)).sqrMagnitude < 0.0001f))
			{
				Quaternion val2 = Quaternion.LookRotation(val, Vector3.up) * Quaternion.Euler(0f, 180f, 0f);
				Vector3 eulerAngles = ((Quaternion)(ref val2)).eulerAngles;
				Quaternion rotation = ((Component)this).transform.rotation;
				Vector3 eulerAngles2 = ((Quaternion)(ref rotation)).eulerAngles;
				if (lockX)
				{
					eulerAngles.x = eulerAngles2.x;
				}
				if (lockY)
				{
					eulerAngles.y = eulerAngles2.y;
				}
				if (lockZ)
				{
					eulerAngles.z = eulerAngles2.z;
				}
				((Component)this).transform.rotation = Quaternion.Euler(eulerAngles);
			}
		}
	}
	[RegisterTypeInIl2Cpp]
	public class DeleteAfterSeconds : MonoBehaviour
	{
		public float destroyTime = 10f;

		private float spawnTime;

		public void Awake()
		{
			spawnTime = Main.Playback.elapsedPlaybackTime;
		}

		public void Update()
		{
			if (Mathf.Abs(Main.Playback.elapsedPlaybackTime - spawnTime) >= destroyTime)
			{
				Object.Destroy((Object)(object)((Component)this).gameObject);
			}
		}
	}
}
namespace ReplayMod.Replay.UI
{
	public static class ReplayCrystals
	{
		[RegisterTypeInIl2Cpp]
		public class Crystal : MonoBehaviour
		{
			public string ReplayPath;

			public string Title;

			public TextMeshPro titleText;

			public Color32 BaseColor;

			private Renderer rend;

			private MaterialPropertyBlock mpb;

			public bool isGrabbed;

			public bool isAnimation;

			public bool hasLeftTable;

			private Vector3 basePosition;

			private Vector3 velocity;

			private Vector3 lastPosition;

			private Vector3 angularVelocity;

			private Quaternion lastRotation;

			private bool hasSavedAfterRelease;

			private object scaleRoutine;

			private object positionRoutine;

			private bool isTextVisible;

			private void Awake()
			{
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				//IL_000d: 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)
				basePosition = ((Component)this).transform.position;
				lastPosition = ((Component)this).transform.position;
			}

			public CrystalState CaptureState()
			{
				//IL_002b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0042: Unknown result type (might be due to invalid IL or missing references)
				//IL_0059: Unknown result type (might be due to invalid IL or missing references)
				//IL_006b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0070: Unknown result type (might be due to invalid IL or missing references)
				CrystalState result = default(CrystalState);
				result.ReplayPath = ReplayPath;
				result.Title = Title;
				result.x = ((Component)this).transform.position.x;
				result.y = ((Component)this).transform.position.y;
				result.z = ((Component)this).transform.position.z;
				result.BaseColor = BaseColor;
				return result;
			}

			public void RestoreState(CrystalState state)
			{
				//IL_000f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0014: Unknown result type (might be due to invalid IL or missing references)
				//IL_002c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0031: Unknown result type (might be due to invalid IL or missing references)
				//IL_003d: Unknown result type (might be due to invalid IL or missing references)
				ReplayPath = state.ReplayPath;
				BaseColor = state.BaseColor;
				basePosition = new Vector3(state.x, state.y, state.z);
				((Component)this).transform.position = basePosition;
				Title = state.Title;
				((TMP_Text)titleText).text = state.Title;
				((TMP_Text)titleText).ForceMeshUpdate(false, false);
				ApplyVisuals();
			}

			public void ApplyVisuals()
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0048: Unknown result type (might be due to invalid IL or missing references)
				//IL_0037: Unknown result type (might be due to invalid IL or missing references)
				//IL_0041: Expected O, but got Unknown
				//IL_0080: Unknown result type (might be due to invalid IL or missing references)
				Color baseColor = Color32.op_Implicit(BaseColor);
				if ((Object)(object)rend == (Object)null)
				{
					rend = ((Component)this).GetComponent<Renderer>();
				}
				if (mpb == null)
				{
					mpb = new MaterialPropertyBlock();
				}
				ApplyBlockToRenderer(rend, baseColor);
				foreach (Renderer componentsInChild in ((Component)this).GetComponentsInChildren<Renderer>(true))
				{
					if (!((Object)(object)componentsInChild == (Object)(object)rend))
					{
						ApplyBlockToRenderer(componentsInChild, baseColor);
					}
				}
			}

			private void ApplyBlockToRenderer(Renderer r, Color baseColor)
			{
				//IL_0025: 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_0038: Unknown result type (might be due to invalid IL or missing references)
				//IL_004e: Unknown result type (might be due to invalid IL or missing references)
				//IL_004f: Unknown result type (might be due to invalid IL or missing references)
				if (!((Object)(object)r == (Object)null))
				{
					mpb.Clear();
					mpb.SetColor("_Base_Color", baseColor);
					mpb.SetColor("_Edge_Color", DeriveEdge(baseColor));
					mpb.SetColor("_Shadow_Color", DeriveShadow(baseColor));
					r.SetPropertyBlock(mpb);
				}
			}

			public void ShowText()
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_000c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0020: Unknown result type (might be due to invalid IL or missing references)
				Animate(Vector3.one * 0.02f, new Vector3(0f, 0f, 0.0049f));
				isTextVisible = true;
			}

			public void HideText()
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				Animate(Vector3.zero, Vector3.zero);
				isTextVisible = false;
			}

			private void Animate(Vector3 scale, Vector3 position)
			{
				//IL_003f: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
				if (scaleRoutine != null)
				{
					MelonCoroutines.Stop(scaleRoutine);
				}
				scaleRoutine = MelonCoroutines.Start(Utilities.LerpValue((Func<Vector3>)(() => titleText.transform.localScale), (Action<Vector3>)delegate(Vector3 v)
				{
					//IL_000b: Unknown result type (might be due to invalid IL or missing references)
					titleText.transform.localScale = v;
				}, (Func<Vector3, Vector3, float, Vector3>)Vector3.Lerp, scale, 0.5f, (Func<float, float>)Utilities.EaseInOut, (Action)null, 0f, (Func<bool>)(() => (Object)(object)titleText.transform != (Object)null)));
				if (positionRoutine != null)
				{
					MelonCoroutines.Stop(positionRoutine);
				}
				positionRoutine = MelonCoroutines.Start(Utilities.LerpValue((Func<Vector3>)(() => titleText.transform.localPosition), (Action<Vector3>)delegate(Vector3 v)
				{
					//IL_000b: Unknown result type (might be due to invalid IL or missing references)
					titleText.transform.localPosition = v;
				}, (Func<Vector3, Vector3, float, Vector3>)Vector3.Lerp, position, 0.5f, (Func<float, float>)Utilities.EaseInOut, (Action)null, 0f, (Func<bool>)(() => (Object)(object)titleText.transform != (Object)null)));
			}

			public void Grab()
			{
				//IL_002e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0033: Unknown result type (might be due to invalid IL or missing references)
				if (!isGrabbed && !isAnimation)
				{
					isGrabbed = true;
					hasLeftTable = true;
					hasSavedAfterRelease = false;
					velocity = Vector3.zero;
					HideText();
				}
			}

			public void Release()
			{
				if (isGrabbed)
				{
					isGrabbed = false;
				}
			}

			private void Update()
			{
				//IL_003c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0041: Unknown result type (might be due to invalid IL or missing references)
				//IL_004d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0053: Unknown result type (might be due to invalid IL or missing references)
				//IL_0058: Unknown result type (might be due to invalid IL or missing references)
				//IL_0062: Unknown result type (might be due to invalid IL or missing references)
				//IL_0067: Unknown result type (might be due to invalid IL or missing references)
				//IL_0072: Unknown result type (might be due to invalid IL or missing references)
				//IL_0077: Unknown result type (might be due to invalid IL or missing references)
				//IL_0078: Unknown result type (might be due to invalid IL or missing references)
				//IL_007a: Unknown result type (might be due to invalid IL or missing references)
				//IL_007f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0084: Unknown result type (might be due to invalid IL or missing references)
				//IL_0089: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
				//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
				if (!isAnimation)
				{
					if (!isGrabbed)
					{
						ApplyThrowVelocity();
						HandleProximity();
					}
					else
					{
						basePosition = ((Component)this).transform.position;
						velocity = (((Component)this).transform.position - lastPosition) / Time.deltaTime;
						Quaternion rotation = ((Component)this).transform.rotation;
						Quaternion val = rotation * Quaternion.Inverse(lastRotation);
						float num = default(float);
						Vector3 val2 = default(Vector3);
						((Quaternion)(ref val)).ToAngleAxis(ref num, ref val2);
						if (num > 180f)
						{
							num -= 360f;
						}
						angularVelocity = val2 * (num * Mathf.Deg2Rad) / Time.deltaTime;
						lastRotation = rotation;
					}
					lastPosition = ((Component)this).transform.position;
				}
				else
				{
					HideText();
				}
			}

			private void HandleProximity()
			{
				//IL_001a: 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)
				Transform head = Main.instance.head;
				if (!((Object)(object)head == (Object)null))
				{
					float num = Vector3.Distance(head.position, ((Component)this).transform.position);
					if (!isTextVisible && num < 2f)
					{
						isTextVisible = true;
						ShowText();
					}
					else if (isTextVisible && num > 2.2f)
					{
						isTextVisible = false;
						HideText();
					}
				}
			}

			private void ApplyThrowVelocity()
			{
				//IL_005c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0062: Unknown result type (might be due to invalid IL or missing references)
				//IL_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_0076: Unknown result type (might be due to invalid IL or missing references)
				//IL_007d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0082: Unknown result type (might be due to invalid IL or missing references)
				//IL_0092: 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_00a3: 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_0116: Unknown result type (might be due to invalid IL or missing references)
				//IL_011b: Unknown result type (might be due to invalid IL or missing references)
				//IL_00df: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
				//IL_004b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0050: Unknown result type (might be due to invalid IL or missing references)
				//IL_0142: Unknown result type (might be due to invalid IL or missing references)
				//IL_0156: Unknown result type (might be due to invalid IL or missing references)
				//IL_0168: Unknown result type (might be due to invalid IL or missing references)
				//IL_017c: Unknown result type (might be due to invalid IL or missing references)
				//IL_01cf: Unknown result type (might be due to invalid IL or missing references)
				//IL_01b9: Unknown result type (might be due to invalid IL or missing references)
				//IL_01d4: Unknown result type (might be due to invalid IL or missing references)
				//IL_01e2: Unknown result type (might be due to invalid IL or missing references)
				//IL_01e7: Unknown result type (might be due to invalid IL or missing references)
				//IL_01f4: Unknown result type (might be due to invalid IL or missing references)
				if (((Vector3)(ref velocity)).sqrMagnitude < 0.001f && ((Vector3)(ref angularVelocity)).sqrMagnitude < 0.001f)
				{
					if (!hasSavedAfterRelease)
					{
						SaveCrystals();
						hasSavedAfterRelease = true;
					}
					velocity = Vector3.zero;
					return;
				}
				basePosition += velocity * Time.deltaTime;
				velocity = Vector3.Lerp(velocity, Vector3.zero, 8f * Time.deltaTime);
				((Component)this).transform.position = basePosition;
				float num = ((Vector3)(ref angularVelocity)).magnitude * Time.deltaTime;
				if (num > 0f)
				{
					((Component)this).transform.rotation = Quaternion.AngleAxis(num * Mathf.Rad2Deg, ((Vector3)(ref angularVelocity)).normalized) * ((Component)this).transform.rotation;
				}
				angularVelocity = Vector3.Lerp(angularVelocity, Vector3.zero, 8f * Time.deltaTime);
				if (((Vector3)(ref angularVelocity)).sqrMagnitude < 0.0005f)
				{
					float num2 = Quaternion.Angle(((Component)this).transform.rotation, Quaternion.Euler(-90f, 0f, 0f));
					float num3 = Quaternion.Angle(((Component)this).transform.rotation, Quaternion.Euler(90f, 0f, 0f));
					if (num2 < 5f || num3 < 5f)
					{
						Quaternion val = ((num2 < num3) ? Quaternion.Euler(-90f, 0f, 0f) : Quaternion.Euler(90f, 0f, 0f));
						((Component)this).transform.rotation = Quaternion.Slerp(((Component)this).transform.rotation, val, 8f * Time.deltaTime);
					}
				}
			}

			private static Color DeriveEdge(Color baseColor)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0027: Unknown result type (might be due to invalid IL or missing references)
				//IL_002c: 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)
				float num = default(float);
				float num2 = default(float);
				float num3 = default(float);
				Color.RGBToHSV(baseColor, ref num, ref num2, ref num3);
				return Color.HSVToRGB(num, Mathf.Clamp01(num2 + 0.05f), Mathf.Clamp01(num3 + 0.35f));
			}

			private static Color DeriveShadow(Color baseColor)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0027: Unknown result type (might be due to invalid IL or missing references)
				//IL_002c: 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)
				float num = default(float);
				float num2 = default(float);
				float num3 = default(float);
				Color.RGBToHSV(baseColor, ref num, ref num2, ref num3);
				return Color.HSVToRGB(num, Mathf.Clamp01(num2 - 0.25f), Mathf.Clamp01(num3 - 0.4f));
			}
		}

		[Serializable]
		public struct CrystalState
		{
			public string ReplayPath;

			public string Title;

			public float x;

			public float y;

			public float z;

			public Color32 BaseColor;
		}

		public static GameObject crystalPrefab;

		public static GameObject crystalParent;

		public static List<Crystal> Crystals = new List<Crystal>();

		public static Crystal heldCrystal;

		public static bool isHeldByRight;

		public static VisualEffect crystalizeVFX;

		public static (string path, Color32 color) lastReplayColor = default((string, Color32));

		public static void HandleCrystals()
		{
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)heldCrystal != (Object)null && ((isHeldByRight && RightController.GetGrip() < 0.5f) || (!isHeldByRight && LeftController.GetGrip() < 0.5f)))
			{
				heldCrystal.Release();
				((Component)heldCrystal).transform.SetParent(crystalParent.transform, true);
				heldCrystal = null;
			}
			else
			{
				if (!((Object)(object)heldCrystal == (Object)null) || !Main.isSceneReady)
				{
					return;
				}
				if (RightController.GetGrip() > 0.5f)
				{
					Crystal crystal = FindClosestCrystal(Main.instance.rightHand.position, 0.1f);
					if ((Object)(object)crystal != (Object)null)
					{
						heldCrystal = crystal;
						isHeldByRight = true;
						crystal.Grab();
						((Component)crystal).transform.SetParent(((Component)Main.instance.rightHand).transform, true);
					}
				}
				else if (LeftController.GetGrip() > 0.5f)
				{
					Crystal crystal2 = FindClosestCrystal(Main.instance.leftHand.position, 0.1f);
					if ((Object)(object)crystal2 != (Object)null)
					{
						heldCrystal = crystal2;
						isHeldByRight = false;
						crystal2.Grab();
						((Component)crystal2).transform.SetParent(((Component)Main.instance.leftHand).transform, true);
					}
				}
			}
		}

		public static void LoadCrystals(string scene = null)
		{
			if (string.IsNullOrEmpty(scene))
			{
				scene = Main.currentScene;
			}
			string path = Path.Combine(MelonEnvironment.UserDataDirectory, "ReplayMod", "Settings", "replayCrystals.json");
			if (!File.Exists(path))
			{
				return;
			}
			string text = File.ReadAllText(path);
			Dictionary<string, CrystalState[]> dictionary = JsonConvert.DeserializeObject<Dictionary<string, CrystalState[]>>(text);
			if (dictionary != null && dictionary.TryGetValue(scene, out var value))
			{
				Crystals = new List<Crystal>();
				CrystalState[] array = value;
				foreach (CrystalState state in array)
				{
					CreateCrystal().RestoreState(state);
				}
			}
		}

		public static void SaveCrystals(string scene = null)
		{
			if (string.IsNullOrEmpty(scene))
			{
				scene = Main.currentScene;
			}
			string path = Path.Combine(MelonEnvironment.UserDataDirectory, "ReplayMod", "Settings", "replayCrystals.json");
			Dictionary<string, CrystalState[]> dictionary = new Dictionary<string, CrystalState[]>();
			if (File.Exists(path))
			{
				string text = File.ReadAllText(path);
				dictionary = JsonConvert.DeserializeObject<Dictionary<string, CrystalState[]>>(text) ?? new Dictionary<string, CrystalState[]>();
			}
			if (Crystals == null)
			{
				return;
			}
			List<CrystalState> list = new List<CrystalState>();
			foreach (Crystal crystal in Crystals)
			{
				if ((Object)(object)crystal != (Object)null)
				{
					list.Add(crystal.CaptureState());
				}
			}
			dictionary[scene] = list.ToArray();
			string contents = JsonConvert.SerializeObject((object)dictionary, (Formatting)1);
			File.WriteAllText(path, contents);
		}

		public static Crystal FindClosestCrystal(Vector3 handPos, float maxDistance)
		{
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			Crystal result = null;
			float num = maxDistance * maxDistance;
			foreach (Crystal crystal in Crystals)
			{
				if (!((Object)(object)((crystal != null) ? ((Component)crystal).transform : null) == (Object)null))
				{
					Vector3 val = ((Component)crystal).transform.position - handPos;
					float sqrMagnitude = ((Vector3)(ref val)).sqrMagnitude;
					if (sqrMagnitude < num)
					{
						num = sqrMagnitude;
						result = crystal;
					}
				}
			}
			return result;
		}

		public static Crystal CreateCrystal(Vector3 position, ReplaySerializer.ReplayHeader header, string path, bool useAnimation = false, bool applyRandomColor = false)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Expected O, but got Unknown
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: Unknown result type (might be due to invalid IL or missing references)
			//IL_019e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a3: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)crystalParent == (Object)null)
			{
				crystalParent = new GameObject("Crystals");
			}
			Crystal crystal = Object.Instantiate<GameObject>(crystalPrefab, crystalParent.transform).AddComponent<Crystal>();
			string text = (Path.GetFileNameWithoutExtension(path).StartsWith("Replay") ? header.Title : Path.GetFileNameWithoutExtension(path));
			((Object)crystal).name = $"Crystal ({text}, {header.Date})";
			((Component)crystal).transform.position = position;
			crystal.Title = text;
			GameObject val = Create.NewText(text, 1f, Color.white, Vector3.zero, Quaternion.identity);
			((Object)val).name = "Replay Title";
			val.transform.SetParent(((Component)crystal).transform, false);
			val.transform.localScale = Vector3.zero;
			val.transform.localRotation = Quaternion.Euler(0f, 270f, 270f);
			crystal.titleText = val.GetComponent<TextMeshPro>();
			((Component)crystal.titleText).GetComponent<RectTransform>().SetSizeWithCurrentAnchors((Axis)0, 2f);
			((TMP_Text)crystal.titleText).horizontalAlignment = (HorizontalAlignmentOptions)2;
			((TMP_Text)crystal.titleText).ForceMeshUpdate(false, false);
			LookAtPlayer lookAtPlayer = val.AddComponent<LookAtPlayer>();
			lookAtPlayer.lockX = true;
			lookAtPlayer.lockZ = true;
			crystal.ReplayPath = ReplayFiles.explorer.CurrentReplayPath;
			if (applyRandomColor)
			{
				crystal.BaseColor = Utilities.RandomColor();
				crystal.ApplyVisuals();
			}
			((Component)crystal).gameObject.SetActive(true);
			Crystals.Add(crystal);
			if (useAnimation)
			{
				MelonCoroutines.Start(CrystalSpawnAnimation(crystal));
			}
			return crystal;
		}

		public static Crystal CreateCrystal()
		{
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: 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_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			if ((Object)(object)crystalParent == (Object)null)
			{
				crystalParent = new GameObject("Crystals");
			}
			Crystal crystal = Object.Instantiate<GameObject>(crystalPrefab, crystalParent.transform).AddComponent<Crystal>();
			crystal.hasLeftTable = true;
			((Component)crystal).gameObject.SetActive(true);
			GameObject val = Create.NewText("", 1f, Color.white, Vector3.zero, Quaternion.identity);
			((Object)val).name = "Replay Title";
			val.transform.SetParent(((Component)crystal).transform, false);
			val.transform.localScale = Vector3.zero;
			val.transform.localRotation = Quaternion.Euler(0f, 270f, 270f);
			crystal.titleText = val.GetComponent<TextMeshPro>();
			((Component)crystal.titleText).GetComponent<RectTransform>().SetSizeWithCurrentAnchors((Axis)0, 2f);
			((TMP_Text)crystal.titleText).horizontalAlignment = (HorizontalAlignmentOptions)2;
			((TMP_Text)crystal.titleText).ForceMeshUpdate(false, false);
			LookAtPlayer lookAtPlayer = val.AddComponent<LookAtPlayer>();
			lookAtPlayer.lockX = true;
			lookAtPlayer.lockZ = true;
			Crystals.Add(crystal);
			return crystal;
		}

		public static IEnumerator ReadCrystal(Crystal crystal)
		{
			crystal.isAnimation = true;
			lastReplayColor = (crystal.ReplayPath, crystal.BaseColor);
			Singleton<AudioManager>.instance.Play(ReplayCache.SFX["Call_GearMarket_ButtonUnpress"], ((Component)crystal).transform.position, false);
			yield return Utilities.LerpValue((Func<Vector3>)(() => ((Component)crystal).transform.position), (Action<Vector3>)delegate(Vector3 v)
			{
				//IL_000b: Unknown result type (might be due to invalid IL or missing references)
				((Component)crystal).transform.position = v;
			}, (Func<Vector3, Vector3, float, Vector3>)Vector3.Lerp, ((Component)Main.instance.replayTable).transform.position + new Vector3(0f, 0.3045f, 0f), 1f, (Func<float, float>)Utilities.EaseInOut, (Action)null, 0f, (Func<bool>)null);
			yield return (object)new WaitForSeconds(1f);
			Singleton<AudioManager>.instance.Play(ReplayCache.SFX["Call_Phone_ScreenDown"], ((Component)crystal).transform.position, false);
			yield return Utilities.LerpValue((Func<Color32>)(() => crystal.BaseColor), (Action<Color32>)delegate(Color32 v)
			{
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				crystal.BaseColor = v;
				crystal.ApplyVisuals();
			}, (Func<Color32, Color32, float, Color32>)Color32.Lerp, new Color32((byte)50, (byte)50, (byte)50, byte.MaxValue), 1f, (Func<float, float>)Utilities.EaseInOut, (Action)null, 0f, (Func<bool>)null);
			yield return (object)new WaitForSeconds(0.5f);
			Singleton<AudioManager>.instance.Play(ReplayCache.SFX["Call_ToolTip_Close"], ((Component)crystal).transform.position, false);
			MelonCoroutines.Start(Utilities.LerpValue((Func<Vector3>)(() => ((Component)crystal).transform.position), (Action<Vector3>)delegate(Vector3 v)
			{
				//IL_000b: Unknown result type (might be due to invalid IL or missing references)
				((Component)crystal).transform.position = v;
			}, (Func<Vector3, Vector3, float, Vector3>)Vector3.Lerp, ((Component)Main.instance.replayTable).transform.position, 0.5f, (Func<float, float>)Utilities.EaseInOut, (Action)null, 0f, (Func<bool>)null));
			yield return Utilities.LerpValue((Func<Vector3>)(() => ((Component)crystal).transform.localScale), (Action<Vector3>)delegate(Vector3 v)
			{
				//IL_000b: Unknown result type (might be due to invalid IL or missing references)
				((Component)crystal).transform.localScale = v;
			}, (Func<Vector3, Vector3, float, Vector3>)Vector3.Lerp, Vector3.zero, 0.5f, (Func<float, float>)Utilities.EaseInOut, (Action)delegate
			{
				//IL_0063: Unknown result type (might be due to invalid IL or missing references)
				int num = ReplayFiles.explorer.currentReplayEntries.FindIndex((ReplayExplorer.Entry e) => e.FullPath == crystal.ReplayPath);
				if (num != -1)
				{
					ReplayFiles.SelectReplay(num);
				}
				else
				{
					Singleton<AudioManager>.instance.Play(ReplayCache.SFX["Call_Measurement_Failure"], ((Component)crystal).transform.position, false);
				}
				Crystals.Remove(crystal);
				Object.Destroy((Object)(object)((Component)crystal).gameObject);
				SaveCrystals();
			}, 0f, (Func<bool>)null);
		}

		public static IEnumerator CrystalBreakAnimation(string replayPath, Crystal crystal = null, float dist = 0.005f)
		{
			Singleton<AudioManager>.instance.Play(ReplayCache.SFX["Call_GearMarket_ButtonUnpress"], ((Component)Main.instance.replayTable).transform.position, false);
			((Component)crystalizeVFX).transform.localPosition = new Vector3(0f, 0f, 0.3903f);
			bool isNewCrystal = false;
			if ((Object)(object)crystal == (Object)null)
			{
				isNewCrystal = true;
				crystal = CreateCrystal();
				((Component)crystal).transform.position = ((Component)Main.instance.replayTable).transform.position;
				((Component)crystal).transform.localScale = Vector3.zero;
				((Component)crystal).transform.localRotation = Quaternion.Euler(-90f, 0f, 0f);
				crystal.BaseColor = Utilities.RandomColor();
				crystal.ApplyVisuals();
				MelonCoroutines.Start(Utilities.LerpValue((Func<Vector3>)(() => ((Component)crystal).transform.localScale), (Action<Vector3>)delegate(Vector3 v)
				{
					//IL_000b: Unknown result type (might be due to invalid IL or missing references)
					((Component)crystal).transform.localScale = v;
				}, (Func<Vector3, Vector3, float, Vector3>)Vector3.Lerp, Vector3.one * 50f, 1f, (Func<float, float>)Utilities.EaseInOut, (Action)null, 0f, (Func<bool>)null));
			}
			crystal.isAnimation = true;
			if (isNewCrystal)
			{
				MelonCoroutines.Start(Utilities.LerpValue((Func<Vector3>)(() => ((Component)crystal).transform.position), (Action<Vector3>)delegate(Vector3 v)
				{
					//IL_000b: Unknown result type (might be due to invalid IL or missing references)
					((Component)crystal).transform.position = v;
				}, (Func<Vector3, Vector3, float, Vector3>)Vector3.Lerp, ((Component)Main.instance.replayTable).transform.position + new Vector3(0f, 0.4045f, 0f), 1.5f, (Func<float, float>)Utilities.EaseInOut, (Action)null, 0f, (Func<bool>)null));
			}
			else
			{
				yield return Utilities.LerpValue((Func<Vector3>)(() => ((Component)crystal).transform.position), (Action<Vector3>)delegate(Vector3 v)
				{
					//IL_000b: Unknown result type (might be due to invalid IL or missing references)
					((Component)crystal).transform.position = v;
				}, (Func<Vector3, Vector3, float, Vector3>)Vector3.Lerp, ((Component)Main.instance.replayTable).transform.position + new Vector3(0f, 0.4045f, 0f), 1.5f, (Func<float, float>)Utilities.EaseInOut, (Action)null, 0f, (Func<bool>)null);
			}
			yield return (object)new WaitForSeconds(0.2f);
			MelonCoroutines.Start(SpinEaseInOut(((Component)crystal).transform, 360f, 2.4f, Vector3.forward));
			yield return (object)new WaitForSeconds(1f);
			Singleton<AudioManager>.instance.Play(ReplayCache.SFX["Call_FistBumpBonus"], ((Component)crystal).transform.position, false);
			Singleton<AudioManager>.instance.Play(ReplayCache.SFX["Call_Slab_Dismiss"], ((Component)crystal).transform.position, false);
			Singleton<AudioManager>.instance.Play(ReplayCache.SFX["Call_Shiftstone_Use"], ((Component)crystal).transform.position, false);
			((Component)((Component)Main.instance.replayTable).transform.GetChild(7)).GetComponent<VisualEffect>().Play();
			Renderer mainRenderer = default(Renderer);
			if (((Component)crystal).TryGetComponent<Renderer>(ref mainRenderer))
			{
				mainRenderer.enabled = false;
			}
			foreach (Transform shard2 in ((Component)crystal).GetComponentsInChildren<Transform>(true))
			{
				if (!((Object)(object)shard2 == (Object)(object)((Component)crystal).transform))
				{
					((Component)shard2).gameObject.SetActive(true);
					Vector3 localPosition = shard2.localPosition;
					MelonCoroutines.Start(Utilities.LerpValue(targetValue: ((Vector3)(ref localPosition)).normalized * dist, getter: (Func<Vector3>)(() => shard2.localPosition), setter: (Action<Vector3>)delegate(Vector3 v)
					{
						//IL_0006: Unknown result type (might be due to invalid IL or missing references)
						shard2.localPosition = v;
					}, lerpFunc: (Func<Vector3, Vector3, float, Vector3>)Vector3.Lerp, duration: 1f, easing: (Func<float, float>)Utilities.EaseOut, done: (Action)null, delay: 0f, isValid: (Func<bool>)null));
				}
			}
			yield return (object)new WaitForSeconds(0.948f);
			foreach (Transform shard in ((Component)crystal).GetComponentsInChildren<Transform>(true))
			{
				if (!((Object)(object)shard == (Object)(object)((Component)crystal).transform))
				{
					MelonCoroutines.Start(Utilities.LerpValue((Func<Vector3>)(() => shard.localScale), (Action<Vector3>)delegate(Vector3 v)
					{
						//IL_0006: Unknown result type (might be due to invalid IL or missing references)
						shard.localScale = v;
					}, (Func<Vector3, Vector3, float, Vector3>)Vector3.Lerp, Vector3.zero, 0.5f, (Func<float, float>)Utilities.EaseIn, (Action)delegate
					{
						//IL_001f: Unknown result type (might be due to invalid IL or missing references)
						Singleton<AudioManager>.instance.Play(ReplayCache.SFX["Call_DressingRoom_PartPanelTick_BackwardLocked"], ((Component)shard).transform.position, false);
					}, Random.value, (Func<bool>)(() => (Object)(object)shard != (Object)null)));
				}
			}
			yield return (object)new WaitForSeconds(1f);
			Crystals.Remove(crystal);
			Object.Destroy((Object)(object)crystal);
			SaveCrystals();
			File.Delete(replayPath);
			ReplayAPI.ReplayDeletedInternal(replayPath);
			ReplayFiles.ReloadReplays();
			Main.instance.crystalBreakCoroutine = null;
		}

		public static IEnumerator SpinEaseInOut(Transform target, float maxSpeed, float duration, Vector3 axis)
		{
			//IL_001c: 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)
			float elapsed = 0f;
			while (elapsed < duration)
			{
				float t = elapsed / duration;
				float eased = 6f * t * (1f - t);
				float spinSpeed = maxSpeed * eased;
				target.Rotate(axis, spinSpeed * Time.deltaTime, (Space)1);
				elapsed += Time.deltaTime;
				yield return null;
			}
		}

		public static IEnumerator CrystalSpawnAnimation(Crystal crystal)
		{
			crystal.isAnimation = true;
			((Component)crystal).transform.localScale = Vector3.zero;
			((Component)crystal).transform.position = ((Component)Main.instance.replayTable).transform.position;
			((Component)crystalizeVFX).transform.localPosition = new Vector3(0f, 0f, 0.3045f);
			crystal.BaseColor = new Color32((byte)50, (byte)50, (byte)50, byte.MaxValue);
			crystal.ApplyVisuals();
			Singleton<AudioManager>.instance.Play(ReplayCache.SFX["Call_MoveSelector_Unlock"], ((Component)crystal).transform.position, false);
			MelonCoroutines.Start(Utilities.LerpValue((Func<Vector3>)(() => ((Component)crystal).transform.position), (Action<Vector3>)delegate(Vector3 v)
			{
				//IL_000b: Unknown result type (might be due to invalid IL or missing references)
				((Component)crystal).transform.position = v;
			}, (Func<Vector3, Vector3, float, Vector3>)Vector3.Lerp, ((Component)Main.instance.replayTable).transform.position + new Vector3(0f, 0.3045f, 0f), 1.5f, (Func<float, float>)Utilities.EaseInOut, (Action)null, 0f, (Func<bool>)null));
			yield return Utilities.LerpValue((Func<Vector3>)(() => ((Component)crystal).transform.localScale), (Action<Vector3>)delegate(Vector3 v)
			{
				//IL_000b: Unknown result type (might be due to invalid IL or missing references)
				((Component)crystal).transform.localScale = v;
			}, (Func<Vector3, Vector3, float, Vector3>)Vector3.Lerp, Vector3.one * 50f, 1.5f, (Func<float, float>)Utilities.EaseInOut, (Action)null, 0f, (Func<bool>)null);
			yield return (object)new WaitForSeconds(1f);
			Singleton<AudioManager>.instance.Play(ReplayCache.SFX["Call_Shiftstone_Use"], ((Component)crystal).transform.position, false);
			crystalizeVFX.Play();
			MelonCoroutines.Start(Utilities.LerpValue((Func<Color32>)(() => crystal.BaseColor), (Action<Color32>)delegate(Color32 v)
			{
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				crystal.BaseColor = v;
				crystal.ApplyVisuals();
			}, (Func<Color32, Color32, float, Color32>)Color32.Lerp, (!string.IsNullOrEmpty(lastReplayColor.path) && crystal.ReplayPath == lastReplayColor.path) ? lastReplayColor.color : Utilities.RandomColor(), 0.05f, (Func<float, float>)Utilities.EaseInOut, (Action)null, 0f, (Func<bool>)null));
			yield return Utilities.LerpValue((Func<Quaternion>)(() => ((Component)crystal).transform.localRotation), (Action<Quaternion>)delegate(Quaternion v)
			{
				//IL_000b: Unknown result type (might be due to invalid IL or missing references)
				((Component)crystal).transform.localRotation = v;
			}, (Func<Quaternion, Quaternion, float, Quaternion>)Quaternion.Slerp, Quaternion.Euler(290f, 0f, 0f), 0.05f, (Func<float, float>)null, (Action)null, 0f, (Func<bool>)null);
			yield return Utilities.LerpValue((Func<Quaternion>)(() => ((Component)crystal).transform.localRotation), (Action<Quaternion>)delegate(Quaternion v)
			{
				//IL_000b: Unknown result type (might be due to invalid IL or missing references)
				((Component)crystal).transform.localRotation = v;
			}, (Func<Quaternion, Quaternion, float, Quaternion>)Quaternion.Slerp, Quaternion.Euler(270f, 0f, 0f), 0.7f, (Func<float, float>)Utilities.EaseInOut, (Action)null, 0f, (Func<bool>)null);
			crystal.isAnimation = false;
		}
	}
	public class ReplayFormatting
	{
		public static string GetReplayName(ReplayInfo replayInfo, bool isClip = false)
		{
			string friendlySceneName = Utilities.GetFriendlySceneName(replayInfo.Header.Scene);
			string customMap = replayInfo.Header.CustomMap;
			Player localPlayer = Singleton<PlayerManager>.instance.localPlayer;
			string value = Utilities.CleanName(localPlayer.Data.GeneralData.PublicUsername);
			string text = replayInfo.Header.Players.FirstOrDefault((PlayerInfo p) => p.MasterId != localPlayer.Data.GeneralData.PlayFabMasterId)?.Name;
			string value2 = ((!string.IsNullOrEmpty(text)) ? Utilities.CleanName(text) : "Unknown");
			string value3 = (isClip ? "Clip_" : "");
			DateTime.TryParse(replayInfo.Header.Date, out var result);
			string value4 = result.ToString("yyyy-MM-dd_hh-mm-ss");
			string text2 = $"Replay_{value3}{value}-vs-{value2}_on_{friendlySceneName}_{value4}.replay";
			if (!string.IsNullOrEmpty(customMap))
			{
				return $"Replay_{value3}{value}-vs-{value2}_on_{customMap}_{value4}.replay";
			}
			if (1 == 0)
			{
			}
			string result2;
			switch (friendlySceneName)
			{
			case "Ring":
			case "Pit":
				result2 = text2;
				break;
			case "Park":
				result2 = $"Replay_{value3}{friendlySceneName}_{replayInfo.Header.Players.Length}P_{value}_{value4}.replay";
				break;
			default:
				result2 = $"Replay_{value3}{friendlySceneName}_{value}_{value4}.replay";
				break;
			}
			if (1 == 0)
			{
			}
			return result2;
		}

		public static string GetReplayDisplayName(string path, ReplaySerializer.ReplayHeader header, string alternativeName = null, bool showTitle = true)
		{
			string text = alternativeName ?? Path.GetFileNameWithoutExtension(path);
			if (header == null)
			{
				return text;
			}
			string pattern = ((text.StartsWith("Replay", StringComparison.OrdinalIgnoreCase) && showTitle) ? header.Title : text);
			return FormatReplayString(pattern, header);
		}

		public static string FormatReplayString(string pattern, ReplaySerializer.ReplayHeader header)
		{
			string mapName = GetMapName(null, header);
			DateTime dateTime = (string.IsNullOrEmpty(header.Date) ? DateTime.MinValue : DateTime.Parse(header.Date, CultureInfo.InvariantCulture));
			TimeSpan timeSpan = TimeSpan.FromSeconds(header.Duration);
			string text = ((timeSpan.TotalHours >= 1.0) ? $"{(int)timeSpan.TotalHours}:{timeSpan.Minutes:D2}:{timeSpan.Seconds:D2}" : $"{(int)timeSpan.TotalMinutes}:{timeSpan.Seconds:D2}");
			Dictionary<string, object> obj = new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase)
			{
				["Host"] = "<#FFF>" + (header.Players?.FirstOrDefault((PlayerInfo p) => p?.WasHost ?? false)?.Name ?? "Unknown") + "<#FFF>",
				["Client"] = "<#FFF>" + (header.Players?.FirstOrDefault((PlayerInfo p) => p != null && !p.WasHost)?.Name ?? "Unknown") + "<#FFF>"
			};
			PlayerInfo[] players = header.Players;
			obj["LocalPlayer"] = "<#FFF>" + (((players == null) ? null : players[0]?.Name) ?? "Unknown") + "<#FFF>";
			obj["Scene"] = mapName;
			obj["Map"] = mapName;
			obj["DateTime"] = ((dateTime == DateTime.MinValue) ? "Unknown Date" : ((object)dateTime));
			DefaultInterpolatedStringHandler defaultInterpolatedStringHandler = new DefaultInterpolatedStringHandler(7, 2);
			PlayerInfo[] players2 = header.Players;
			defaultInterpolatedStringHandler.AppendFormatted((players2 != null) ? players2.Length : 0);
			defaultInterpolatedStringHandler.AppendLiteral(" Player");
			PlayerInfo[] players3 = header.Players;
			defaultInterpolatedStringHandler.AppendFormatted((((players3 != null) ? players3.Length : 0) == 1) ? "" : "s");
			obj["PlayerCount"] = defaultInterpolatedStringHandler.ToStringAndClear();
			obj["Version"] = header.Version ?? "Unknown Version";
			string obj2 = header.Structures?.Length.ToString() ?? "0";
			StructureInfo[] structures = header.Structures;
			obj["StructureCount"] = obj2 + " Structure" + ((((structures != null) ? structures.Length : 0) == 1) ? "" : "s");
			obj["MarkerCount"] = header.MarkerCount;
			obj["AveragePing"] = header.AvgPing;
			obj["MinimumPing"] = header.MinPing;
			obj["MaximumPing"] = header.MaxPing;
			obj["Title"] = ((!string.IsNullOrEmpty(header.Title)) ? header.Title : "Unknown Title");
			obj["Duration"] = ((header.Duration > 0f) ? text : "Unknown");
			obj["FPS"] = header.TargetFPS;
			Dictionary<string, object> values = obj;
			int num = 0;
			while (true)
			{
				int num2 = num;
				PlayerInfo[] players4 = header.Players;
				if (num2 >= ((players4 != null) ? players4.Length : 0))
				{
					break;
				}
				values[$"Player{num + 1}"] = GetPlayer(num);
				num++;
			}
			Regex regex = new Regex("\\{(\\w+)(?::([^}]+))?\\}");
			return regex.Replace(pattern, delegate(Match match)
			{
				string value = match.Groups[1].Value;
				string text2 = (match.Groups[2].Success ? match.Groups[2].Value : null);
				if (value.Equals("PlayerList", StringComparison.OrdinalIgnoreCase))
				{
					int maxNames = 3;
					if (!string.IsNullOrEmpty(text2) && int.TryParse(text2, out var result))
					{
						maxNames = result;
					}
					if (header.Players != null)
					{
						return ReplayFiles.BuildPlayerLine(header.Players, maxNames);
					}
				}
				object value2;
				return values.TryGetValue(value, out value2) ? ((value2 is DateTime dateTime2 && text2 != null) ? dateTime2.ToString(text2) : value2.ToString()) : match.Value;
			});
			string GetPlayer(int index)
			{
				return (header?.Players != null && index >= 0 && index < header.Players.Length && header.Players[index] != null) ? ("<#FFF>" + header.Players[index].Name + "<#FFF>") : "";
			}
		}

		public static string GetMapName(string path = null, ReplaySerializer.ReplayHeader header = null)
		{
			if (string.IsNullOrEmpty(path) && header == null)
			{
				return null;
			}
			if (header == null)
			{
				header = ReplayArchive.GetManifest(path);
			}
			if (!string.IsNullOrEmpty(header.CustomMap))
			{
				if (header.CustomMap.StartsWith("1|"))
				{
					return "Unknown Custom Map";
				}
				if (header.Scene == "FlatLandSingle")
				{
					return "FlatLand";
				}
				return header.CustomMap;
			}
			return Utilities.GetFriendlySceneName(header.Scene);
		}
	}
	public static class ReplayPlaybackControls
	{
		public static bool playbackControlsOpen;

		public static GameObject playbackControls;

		public static GameObject timeline;

		public static TextMeshPro totalDuration;

		public static TextMeshPro currentDuration;

		public static TextMeshPro playbackTitle;

		public static TextMeshPro playbackSpeedText;

		public static MeshRenderer playButtonSprite;

		public static Texture2D pauseSprite;

		public static Texture2D playSprite;

		public static DestroyOnPunch destroyOnPunch;

		public static GameObject markerPrefab;

		public static float smoothing = 7f;

		public static void Update()
		{
			//IL_004c: 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_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			Transform head = Main.instance.head;
			if (!((Object)(object)head == (Object)null) && !((Object)(object)playbackControls == (Object)null) && Main.instance.PlaybackControlsFollow.Value)
			{
				float armSpan = Main.LocalPlayer.Data.PlayerMeasurement.ArmSpan;
				float num = Vector3.Distance(playbackControls.transform.position, head.position);
				if (!(num < armSpan))
				{
					(Vector3 position, Quaternion rotation) targetSlabTransform = GetTargetSlabTransform(head);
					Vector3 item = targetSlabTransform.position;
					Quaternion item2 = targetSlabTransform.rotation;
					float num2 = Mathf.InverseLerp(armSpan, armSpan * 1.5f, num);
					float num3 = (1f - Mathf.Exp((0f - smoothing) * Time.deltaTime)) * num2;
					playbackControls.transform.position = Vector3.Lerp(playbackControls.transform.position, item, num3);
					playbackControls.transform.rotation = Quaternion.Slerp(playbackControls.transform.rotation, item2, num3);
				}
			}
		}

		public static (Vector3 position, Quaternion rotation) GetTargetSlabTransform(Transform head)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			Vector3 forward = head.forward;
			forward.y = 0f;
			Vector3 val = head.position + forward * 0.6f + Vector3.down * 0.1f;
			Vector3 val2 = head.position - val;
			val2.y = 0f;
			Quaternion item = Quaternion.LookRotation(val2);
			return (val, item);
		}

		public static void Open()
		{
			//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_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)Main.instance.head == (Object)null))
			{
				if (playbackControlsOpen)
				{
					playbackControls.SetActive(false);
				}
				playbackControlsOpen = true;
				var (position, rotation) = GetTargetSlabTransform(Main.instance.head);
				if (Main.LocalPlayer.Controller.GetSubsystem<PlayerMovement>().IsGrounded())
				{
					playbackControls.transform.position = position;
					playbackControls.transform.rotation = rotation;
					playbackControls.SetActive(true);
					((Component)playbackControls.transform.GetChild(0)).gameObject.SetActive(true);
					((Component)playbackControls.transform.GetChild(1)).gameObject.SetActive(true);
					Singleton<AudioManager>.instance.Play(ReplayCache.SFX["Call_Slab_Construct"], Main.instance.head.position, false);
				}
			}
		}

		public static void Close()
		{
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			if (playbackControlsOpen)
			{
				playbackControlsOpen = false;
				playbackControls.SetActive(false);
				((Component)playbackControls.transform.GetChild(0)).gameObject.SetActive(false);
				((Component)playbackCo