using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security.Cryptography;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using MelonLoader;
using MelonLoader.Utils;
using Microsoft.CodeAnalysis;
using NLayer;
using TramRadio;
using UnityEngine;
using UnityEngine.Networking;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: MelonInfo(typeof(Mod), "TramRadio", "1.0.0", "jasonSTTH", null)]
[assembly: MelonGame("ReLUGames", "MIMESIS")]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("TramRadio")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("TramRadio")]
[assembly: AssemblyTitle("TramRadio")]
[assembly: AssemblyVersion("1.0.0.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

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

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace TramRadio
{
	internal static class GameBridge
	{
		private static readonly Dictionary<string, Type> Types = new Dictionary<string, Type>();

		internal static object? Hub => Member(TypeNamed("Hub"), "s");

		internal static Component? Main
		{
			get
			{
				object? obj = Member(Member(Hub, "pdata"), "main");
				return (Component?)((obj is Component) ? obj : null);
			}
		}

		internal static Type? TypeNamed(string name)
		{
			if (Types.TryGetValue(name, out Type value))
			{
				return value;
			}
			Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
			for (int i = 0; i < assemblies.Length; i++)
			{
				Type type = assemblies[i].GetType(name, throwOnError: false);
				if (type != null)
				{
					Types[name] = type;
					return type;
				}
			}
			return null;
		}

		internal static object? Member(object? obj, string name)
		{
			if (obj == null)
			{
				return null;
			}
			Type type = (obj as Type) ?? obj.GetType();
			object obj2 = ((obj is Type) ? null : obj);
			while (type != null)
			{
				FieldInfo field = type.GetField(name, BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
				if (field != null)
				{
					return field.GetValue(obj2);
				}
				PropertyInfo property = type.GetProperty(name, BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
				if (property != null && property.GetIndexParameters().Length == 0)
				{
					return property.GetValue(obj2, null);
				}
				type = type.BaseType;
			}
			return null;
		}

		internal static Transform? FindConsole()
		{
			Component main = Main;
			if ((Object)(object)main != (Object)null && IsPlayScene(main))
			{
				object? obj = Member(main, "tramConsole");
				Component val = (Component)((obj is Component) ? obj : null);
				if ((Object)(object)val != (Object)null && val.gameObject.activeInHierarchy)
				{
					return val.transform;
				}
			}
			Type type = TypeNamed("GameMainBase");
			if (type == null || !typeof(Object).IsAssignableFrom(type))
			{
				return null;
			}
			Object[] array = Object.FindObjectsByType(type, (FindObjectsSortMode)0);
			foreach (Object obj2 in array)
			{
				Component val2 = (Component)(object)((obj2 is Component) ? obj2 : null);
				if (val2 != null && IsPlayScene(val2))
				{
					object? obj3 = Member(val2, "tramConsole");
					Component val3 = (Component)((obj3 is Component) ? obj3 : null);
					if ((Object)(object)val3 != (Object)null && val3.gameObject.activeInHierarchy)
					{
						return val3.transform;
					}
				}
			}
			return null;
		}

		internal static bool? LocalIndoor(ulong steamId)
		{
			if ((Object)(object)Main == (Object)null)
			{
				return null;
			}
			if (((object)Main).GetType().Name != "GamePlayScene")
			{
				return false;
			}
			object obj = Member(Member(Hub, "vworld"), "_sessionManager");
			bool? result = Read(Member(obj, "_hostSessionContext"));
			if (result.HasValue)
			{
				return result;
			}
			object obj2 = Member(obj, "m_Contexts");
			if ((Member(obj2, "Values") ?? obj2) is IEnumerable enumerable)
			{
				foreach (object item in enumerable)
				{
					bool? result2 = Read(Member(item, "Value") ?? item);
					if (result2.HasValue)
					{
						return result2;
					}
				}
			}
			return null;
			bool? Read(object? context)
			{
				object obj3 = Member(context, "SteamID");
				if (obj3 == null || steamId == 0L || Convert.ToUInt64(obj3) != steamId)
				{
					return null;
				}
				return Member(Member(context, "_vPlayer"), "IsIndoor") as bool?;
			}
		}

		private static bool IsPlayScene(Component c)
		{
			string name = ((object)c).GetType().Name;
			if (!(name == "GamePlayScene") && !(name == "InTramWaitingScene"))
			{
				return name == "MaintenanceScene";
			}
			return true;
		}
	}
	internal sealed class LobbyBridge
	{
		internal const string Key = "artem.tramradio.v1";

		internal ulong LobbyId;

		internal ulong OwnerId;

		internal ulong SelfId;

		internal bool Available;

		private object? lobby;

		private MethodInfo? getData;

		private MethodInfo? setData;

		private MethodInfo? getOwner;

		private MethodInfo? getSelf;

		private MethodInfo? getTime;

		private MethodInfo? deleteData;

		private uint lastSecond;

		private float secondSeen;

		private double clock;

		internal bool InLobby => LobbyId != 0;

		internal bool IsOwner
		{
			get
			{
				if (InLobby && OwnerId != 0L)
				{
					return OwnerId == SelfId;
				}
				return false;
			}
		}

		internal double Now => clock;

		private static MethodInfo? Method(string type, string name, int count)
		{
			Type type2 = GameBridge.TypeNamed(type);
			if (type2 == null)
			{
				return null;
			}
			MethodInfo[] methods = type2.GetMethods(BindingFlags.Static | BindingFlags.Public);
			foreach (MethodInfo methodInfo in methods)
			{
				if (methodInfo.Name == name && methodInfo.GetParameters().Length == count)
				{
					return methodInfo;
				}
			}
			return null;
		}

		internal void Refresh()
		{
			if (getData == null)
			{
				getData = Method("Steamworks.SteamMatchmaking", "GetLobbyData", 2);
				setData = Method("Steamworks.SteamMatchmaking", "SetLobbyData", 3);
				getOwner = Method("Steamworks.SteamMatchmaking", "GetLobbyOwner", 1);
				deleteData = Method("Steamworks.SteamMatchmaking", "DeleteLobbyData", 2);
				getSelf = Method("Steamworks.SteamUser", "GetSteamID", 0);
				getTime = Method("Steamworks.SteamUtils", "GetServerRealTime", 0);
			}
			Available = getData != null && setData != null && getOwner != null && getSelf != null && getTime != null;
			object obj = GameBridge.Member(GameBridge.Hub, "steamInviteDispatcher");
			lobby = GameBridge.Member(obj, "joinedLobbyID");
			LobbyId = Id(lobby);
			OwnerId = 0uL;
			SelfId = (Available ? Id(getSelf.Invoke(null, null)) : 0);
			if (Available && InLobby)
			{
				OwnerId = Id(getOwner.Invoke(null, new object[1] { lobby }));
				SelfId = Id(getSelf.Invoke(null, null));
				uint num = Convert.ToUInt32(getTime.Invoke(null, null));
				if (num != lastSecond)
				{
					lastSecond = num;
					secondSeen = Time.realtimeSinceStartup;
				}
				clock = (double)num + Math.Min(0.999, Math.Max(0f, Time.realtimeSinceStartup - secondSeen));
			}
			else
			{
				clock = Time.realtimeSinceStartup;
			}
		}

		private static ulong Id(object? id)
		{
			object obj = GameBridge.Member(id, "m_SteamID");
			if (obj != null)
			{
				return Convert.ToUInt64(obj);
			}
			return 0uL;
		}

		internal string Read()
		{
			if (!InLobby || !Available)
			{
				return "";
			}
			return (getData.Invoke(null, new object[2] { lobby, "artem.tramradio.v1" }) as string) ?? "";
		}

		internal bool Publish(RadioState state)
		{
			if (IsOwner && Available)
			{
				return (bool)setData.Invoke(null, new object[3]
				{
					lobby,
					"artem.tramradio.v1",
					state.Encode()
				});
			}
			return false;
		}

		internal void Clear()
		{
			if (IsOwner && deleteData != null)
			{
				deleteData.Invoke(null, new object[2] { lobby, "artem.tramradio.v1" });
			}
		}
	}
	internal static class Keys
	{
		private static bool legacy = true;

		internal unsafe static bool Down(KeyCode key)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Invalid comparison between Unknown and I4
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Invalid comparison between Unknown and I4
			if (legacy)
			{
				try
				{
					return Input.GetKeyDown(key);
				}
				catch (InvalidOperationException)
				{
					legacy = false;
				}
			}
			object obj = GameBridge.TypeNamed("UnityEngine.InputSystem.Keyboard")?.GetProperty("current", BindingFlags.Static | BindingFlags.Public)?.GetValue(null, null);
			if (obj == null)
			{
				return false;
			}
			string name = ((object)(*(KeyCode*)(&key))/*cast due to .constrained prefix*/).ToString().ToLowerInvariant() + "Key";
			if ((int)key == 45)
			{
				name = "minusKey";
			}
			if ((int)key == 61)
			{
				name = "equalsKey";
			}
			object obj2 = GameBridge.Member(GameBridge.Member(obj, name), "wasPressedThisFrame");
			bool flag = default(bool);
			int num;
			if (obj2 is bool)
			{
				flag = (bool)obj2;
				num = 1;
			}
			else
			{
				num = 0;
			}
			return (byte)((uint)num & (flag ? 1u : 0u)) != 0;
		}
	}
	public sealed class Mod : MelonMod
	{
		private readonly Settings settings = new Settings();

		private readonly LobbyBridge lobby = new LobbyBridge();

		private readonly RadioModel model = new RadioModel();

		private RadioState state = new RadioState();

		private List<Track> tracks = new List<Track>();

		private readonly HashSet<string> failed = new HashSet<string>(StringComparer.Ordinal);

		private Task<ScanResult>? scan;

		private string musicPath = "";

		private string legacyMusicPath = "";

		private string configPath = "";

		private string status = "Starting...";

		private string loadedHash = "";

		private string loadingHash = "";

		private string missingHash = "";

		private string lastReceived = "";

		private UnityWebRequest? request;

		private Task<PcmAudio>? mp3Task;

		private CancellationTokenSource? mp3Cancel;

		private UnityWebRequestAsyncOperation? operation;

		private AudioClip? clip;

		private Transform? anchor;

		private AudioListener? listener;

		private float nextScanAnchor;

		private float nextNetwork;

		private float nextPublish;

		private float nextSeek;

		private float requestStarted;

		private float nextError;

		private ulong previousLobby;

		private ulong previousOwner;

		private bool initialized;

		private bool quit;

		private bool localOnly;

		private bool wasPlaying;

		private bool startedClip;

		private int index = -1;

		private bool? indoors;

		private bool warnedIndoor;

		private bool pendingHostStart;

		private bool CanControl
		{
			get
			{
				if (lobby.InLobby)
				{
					if (lobby.Available)
					{
						return lobby.IsOwner;
					}
					return false;
				}
				return localOnly;
			}
		}

		public override void OnInitializeMelon()
		{
			try
			{
				string fullName = Directory.GetParent(Application.dataPath).FullName;
				string location = ((MelonBase)this).MelonAssembly.Location;
				if (string.IsNullOrWhiteSpace(location))
				{
					location = typeof(Mod).Assembly.Location;
				}
				if (string.IsNullOrWhiteSpace(location))
				{
					throw new IOException("Cannot locate TramRadio.dll. Import the ZIP with r2modman.");
				}
				musicPath = Path.GetDirectoryName(Path.GetFullPath(location));
				legacyMusicPath = Path.Combine(fullName, "Music");
				configPath = Path.Combine(MelonEnvironment.UserDataDirectory, "TramRadio", "config.ini");
				settings.Read(configPath);
				NewState();
				Scan();
				initialized = true;
				((MelonBase)this).LoggerInstance.Msg("TramRadio 1.0.0 | Music beside DLL: " + musicPath);
				((MelonBase)this).LoggerInstance.Msg("Optional Music subfolder; legacy fallback: " + legacyMusicPath);
				((MelonBase)this).LoggerInstance.Msg("F6 play/pause, F7 next, F8 previous, F9 rescan, F10 HUD, -/= personal volume. Host controls near tram.");
			}
			catch (Exception ex)
			{
				((MelonBase)this).LoggerInstance.Error("Initialization failed: " + ex);
			}
		}

		private void NewState()
		{
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			state = new RadioState
			{
				Owner = lobby.OwnerId,
				Stamp = lobby.Now,
				X = settings.X,
				Y = settings.Y,
				Z = settings.Z,
				Yaw = settings.Yaw
			};
			if ((Object)(object)anchor != (Object)null && CanControl && settings.AutoBench && Placement.TryBench(anchor, out Vector3 local, out float yaw, out string _))
			{
				state.X = local.x;
				state.Y = local.y;
				state.Z = local.z;
				state.Yaw = yaw;
			}
		}

		private void Scan()
		{
			if (scan == null)
			{
				int max = settings.MaxFileMB;
				string folder = musicPath;
				string legacy = legacyMusicPath;
				scan = Task.Run(() => MusicLibrary.ScanPackage(folder, legacy, max));
				status = "Scanning Music...";
			}
		}

		private void CompleteScan()
		{
			if (scan == null || !scan.IsCompleted)
			{
				return;
			}
			Task<ScanResult> task = scan;
			scan = null;
			if (task.IsFaulted)
			{
				Message("Cannot read Music: " + task.Exception.GetBaseException().Message);
				return;
			}
			tracks = task.Result.Tracks;
			foreach (string warning in task.Result.Warnings)
			{
				((MelonBase)this).LoggerInstance.Warning(warning);
			}
			failed.Clear();
			missingHash = "";
			index = tracks.FindIndex((Track t) => t.Hash == state.Hash);
			status = tracks.Count + " track(s). F6 to play.";
			((MelonBase)this).LoggerInstance.Msg(status);
			if (CanControl && state.Hash != "" && index < 0)
			{
				state.Hash = "";
				state.Title = "";
				state.Playing = false;
				state.Position = 0.0;
				state.Revision++;
				ReleaseClip();
				PublishSoon();
			}
		}

		public override void OnUpdate()
		{
			if (!initialized || quit)
			{
				return;
			}
			try
			{
				Tick();
			}
			catch (Exception ex)
			{
				if (Time.realtimeSinceStartup >= nextError)
				{
					nextError = Time.realtimeSinceStartup + 10f;
					((MelonBase)this).LoggerInstance.Error(ex.ToString());
					status = "Error: see MelonLoader/Latest.log";
				}
			}
		}

		private void Tick()
		{
			//IL_02f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0308: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Unknown result type (might be due to invalid IL or missing references)
			//IL_014f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0160: Unknown result type (might be due to invalid IL or missing references)
			float realtimeSinceStartup = Time.realtimeSinceStartup;
			CompleteScan();
			if (realtimeSinceStartup >= nextNetwork)
			{
				nextNetwork = realtimeSinceStartup + 0.25f;
				UpdateNetwork();
				indoors = GameBridge.LocalIndoor(lobby.SelfId);
				if (!indoors.HasValue && (Object)(object)GameBridge.Main != (Object)null && !warnedIndoor)
				{
					warnedIndoor = true;
					((MelonBase)this).LoggerInstance.Warning("Indoor state unavailable: local audio muted until player state is ready.");
				}
			}
			if (realtimeSinceStartup >= nextScanAnchor)
			{
				nextScanAnchor = realtimeSinceStartup + 1f;
				Transform val = GameBridge.FindConsole();
				if ((Object)(object)val != (Object)(object)anchor || ((Object)(object)val != (Object)null && ((Object)(object)model.Root == (Object)null || (Object)(object)model.Source == (Object)null)))
				{
					model.Dispose();
					anchor = val;
					startedClip = false;
					wasPlaying = false;
					if ((Object)(object)anchor != (Object)null)
					{
						if (CanControl && settings.AutoBench)
						{
							if (Placement.TryBench(anchor, out Vector3 local, out float yaw, out string name))
							{
								state.X = local.x;
								state.Y = local.y;
								state.Z = local.z;
								state.Yaw = yaw;
								state.Revision++;
								PublishSoon();
								((MelonBase)this).LoggerInstance.Msg("Bench placement: " + name);
							}
							else
							{
								((MelonBase)this).LoggerInstance.Warning("Bench mesh not found; using console offset. F4 can place the radio manually.");
							}
						}
						model.Create(anchor);
						model.Place(state);
						if ((Object)(object)clip != (Object)null && loadedHash == state.Hash)
						{
							model.Source.clip = clip;
						}
						((MelonBase)this).LoggerInstance.Msg("Radio attached to: " + Hierarchy(anchor));
					}
				}
				if ((Object)(object)listener == (Object)null || !((Behaviour)listener).isActiveAndEnabled)
				{
					listener = ((IEnumerable<AudioListener>)Object.FindObjectsByType<AudioListener>((FindObjectsSortMode)0)).FirstOrDefault((Func<AudioListener, bool>)((AudioListener x) => ((Behaviour)x).isActiveAndEnabled));
				}
			}
			HandleKeys();
			PollDecode();
			if ((Object)(object)anchor != (Object)null && (Object)(object)model.Source != (Object)null)
			{
				model.Place(state);
				EnsureTrack();
				PlayTick();
				float distance = (((Object)(object)listener != (Object)null) ? Vector3.Distance(((Component)listener).transform.position, model.Root.transform.position) : 0f);
				model.UpdateAcoustics(listener, indoors, settings.Volume * RadioState.DistanceGain(distance, settings.NearDistance, settings.MaxDistance));
				model.Light(model.Source.isPlaying);
			}
			else if ((Object)(object)model.Source != (Object)null)
			{
				model.Source.Stop();
			}
			if (lobby.IsOwner && realtimeSinceStartup >= nextPublish)
			{
				nextPublish = realtimeSinceStartup + 2f;
				if (!lobby.Publish(state))
				{
					status = "Steam sync write failed; check connection";
				}
			}
		}

		private void UpdateNetwork()
		{
			try
			{
				lobby.Refresh();
			}
			catch (Exception ex)
			{
				if (Time.realtimeSinceStartup >= nextError)
				{
					nextError = Time.realtimeSinceStartup + 15f;
					((MelonBase)this).LoggerInstance.Warning("Steam bridge: " + ex.GetBaseException().Message);
				}
				lobby.Available = false;
				status = "Steam unavailable; playback paused";
				state.Playing = false;
				if ((Object)(object)model.Source != (Object)null)
				{
					model.Source.Pause();
				}
				return;
			}
			localOnly = !lobby.InLobby;
			if (previousLobby != lobby.LobbyId || previousOwner != lobby.OwnerId)
			{
				previousLobby = lobby.LobbyId;
				previousOwner = lobby.OwnerId;
				ReleaseClip();
				NewState();
				index = -1;
				lastReceived = "";
				missingHash = "";
				failed.Clear();
				PublishSoon();
				status = (lobby.IsOwner ? "Host ready. F6 near tram." : (lobby.InLobby ? "Waiting for host radio..." : "Local mode (no Steam lobby)"));
			}
			if (!lobby.InLobby || lobby.IsOwner)
			{
				return;
			}
			string text = lobby.Read();
			if (text == "")
			{
				if (lastReceived != "")
				{
					ReleaseClip();
					NewState();
					lastReceived = "";
				}
				status = "Waiting for host with TramRadio";
			}
			else
			{
				if (text == lastReceived)
				{
					return;
				}
				if (!RadioState.TryDecode(text, lobby.OwnerId, out RadioState value))
				{
					status = "Host radio data incompatible";
				}
				else if (!(state.Token == value.Token) || value.Revision >= state.Revision)
				{
					bool num = state.Token != value.Token;
					bool flag = state.Hash != value.Hash;
					if (num || flag)
					{
						ReleaseClip();
						missingHash = "";
					}
					state = value;
					lastReceived = text;
					if (num || flag)
					{
						status = state.Title;
					}
				}
			}
		}

		private void HandleKeys()
		{
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			if (Keys.Down((KeyCode)291))
			{
				settings.ShowHud = !settings.ShowHud;
				SaveSettings();
			}
			if (Keys.Down((KeyCode)290))
			{
				Scan();
			}
			if (Keys.Down((KeyCode)45))
			{
				settings.Volume = Mathf.Max(0f, settings.Volume - 0.05f);
				SaveSettings();
			}
			if (Keys.Down((KeyCode)61))
			{
				settings.Volume = Mathf.Min(1f, settings.Volume + 0.05f);
				SaveSettings();
			}
			bool num = Keys.Down((KeyCode)287);
			bool flag = Keys.Down((KeyCode)288);
			bool flag2 = Keys.Down((KeyCode)289);
			bool flag3 = Keys.Down((KeyCode)285);
			if (!num && !flag && !flag2 && !flag3)
			{
				return;
			}
			if ((Object)(object)anchor == (Object)null || (Object)(object)model.Root == (Object)null)
			{
				Message("Tram console not found yet. Enter a playable tram scene.");
				return;
			}
			if (!CanControl)
			{
				Message("Only the Steam lobby owner controls playback.");
				return;
			}
			if ((Object)(object)listener == (Object)null || Vector3.Distance(((Component)listener).transform.position, anchor.position) > settings.ControlDistance)
			{
				Message("Come closer to the tram console (" + settings.ControlDistance + " m).");
				return;
			}
			if (flag3)
			{
				PlaceInFront();
				return;
			}
			if (scan != null)
			{
				Message("Music is still being scanned.");
				return;
			}
			if (tracks.Count == 0)
			{
				Message("Add MP3 beside TramRadio.dll inside the ZIP, then reimport it with the game closed.");
				return;
			}
			if (flag || flag2)
			{
				Select((!flag2) ? 1 : (-1));
				return;
			}
			if (state.Hash == "" || failed.Contains(state.Hash))
			{
				Select(1);
				return;
			}
			if (loadedHash != state.Hash)
			{
				pendingHostStart = !pendingHostStart;
				status = (pendingHostStart ? ("Will play after loading: " + state.Title) : ("Loading paused: " + state.Title));
				return;
			}
			if (state.Playing && (Object)(object)model.Source != (Object)null && (Object)(object)model.Source.clip != (Object)null)
			{
				state.Position = model.Source.time;
				state.Stamp = lobby.Now;
			}
			state.SetPlaying(!state.Playing, lobby.Now);
			if (state.Playing && (Object)(object)clip != (Object)null && state.Position >= (double)clip.length - 0.05)
			{
				state.Position = 0.0;
			}
			status = (state.Playing ? state.Title : ("Paused: " + state.Title));
			PublishSoon();
		}

		private void Select(int delta)
		{
			if (tracks.Count == 0)
			{
				return;
			}
			for (int i = 0; i < tracks.Count; i++)
			{
				index = MusicLibrary.NextIndex(index, delta, tracks.Count);
				if (!failed.Contains(tracks[index].Hash))
				{
					Track track = tracks[index];
					ReleaseClip();
					state.Hash = track.Hash;
					state.Title = track.Title;
					state.Position = 0.0;
					state.Stamp = lobby.Now;
					state.Playing = false;
					state.Revision++;
					pendingHostStart = true;
					missingHash = "";
					status = "Loading: " + track.Title;
					PublishSoon();
					return;
				}
			}
			state.Playing = false;
			pendingHostStart = false;
			state.Revision++;
			Message("No playable tracks. Fix files and press F9.");
			PublishSoon();
		}

		private void EnsureTrack()
		{
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0218: Unknown result type (might be due to invalid IL or missing references)
			if (state.Hash == "")
			{
				if ((Object)(object)clip != (Object)null || request != null)
				{
					ReleaseClip();
				}
			}
			else
			{
				if (loadedHash == state.Hash || loadingHash == state.Hash || failed.Contains(state.Hash) || missingHash == state.Hash)
				{
					return;
				}
				Track track = tracks.FirstOrDefault((Track t) => t.Hash == state.Hash);
				if (track != null)
				{
					try
					{
						string text = Path.GetExtension(track.Path).ToLowerInvariant();
						AudioType val = (AudioType)((text == ".wav") ? 20 : ((text == ".ogg") ? 14 : 13));
						if (text == ".mp3")
						{
							mp3Cancel = new CancellationTokenSource();
							CancellationToken token = mp3Cancel.Token;
							loadingHash = state.Hash;
							mp3Task = Task.Run(() => Mp3Decoder.Decode(track.Path, token), token);
							mp3Task.ContinueWith(delegate(Task<PcmAudio> t)
							{
								_ = t.Exception;
							}, TaskContinuationOptions.OnlyOnFaulted);
						}
						else
						{
							request = UnityWebRequestMultimedia.GetAudioClip(new Uri(Path.GetFullPath(track.Path)).AbsoluteUri, val);
							request.timeout = 60;
							((DownloadHandlerAudioClip)request.downloadHandler).streamAudio = false;
							loadingHash = state.Hash;
							requestStarted = Time.realtimeSinceStartup;
							operation = request.SendWebRequest();
						}
						return;
					}
					catch (Exception ex)
					{
						DecodeFailed(ex.Message);
						return;
					}
				}
				if (scan == null)
				{
					missingHash = state.Hash;
					Message("Missing matching file: " + state.Title + ". Import the same ZIP as the host (game closed).");
				}
			}
		}

		private void PollDecode()
		{
			//IL_01e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e6: Invalid comparison between Unknown and I4
			if (mp3Task != null)
			{
				if (!mp3Task.IsCompleted)
				{
					return;
				}
				Task<PcmAudio> task = mp3Task;
				mp3Task = null;
				mp3Cancel?.Dispose();
				mp3Cancel = null;
				if (!task.IsFaulted && !task.IsCanceled)
				{
					try
					{
						PcmAudio result = task.Result;
						clip = AudioClip.Create(state.Title, result.Samples.Length, 1, result.Rate, false);
						if (!clip.SetData(result.Samples, 0))
						{
							throw new IOException("Unity rejected PCM samples");
						}
						loadedHash = loadingHash;
						loadingHash = "";
						if ((Object)(object)model.Source != (Object)null)
						{
							model.Source.clip = clip;
						}
						if (CanControl && pendingHostStart)
						{
							state.Position = 0.0;
							state.Stamp = lobby.Now;
							state.Playing = true;
							state.Revision++;
							pendingHostStart = false;
							PublishSoon();
						}
						startedClip = false;
						wasPlaying = false;
						status = state.Title;
						return;
					}
					catch (Exception ex)
					{
						DecodeFailed(ex.Message);
						return;
					}
				}
				DecodeFailed(task.Exception?.GetBaseException().Message ?? "Cancelled");
			}
			else
			{
				if (request == null)
				{
					return;
				}
				if (Time.realtimeSinceStartup - requestStarted > 65f)
				{
					DecodeFailed("Decode timeout");
				}
				else
				{
					if (operation == null || !((AsyncOperation)operation).isDone)
					{
						return;
					}
					try
					{
						if ((int)request.result != 1)
						{
							DecodeFailed(request.error);
							return;
						}
						AudioClip content = DownloadHandlerAudioClip.GetContent(request);
						if ((Object)(object)content == (Object)null || content.length < 0.1f)
						{
							DecodeFailed("Empty audio clip");
							return;
						}
						if (content.length > 1800f || (long)content.samples * (long)content.channels * 4 > 536870912)
						{
							Object.Destroy((Object)(object)content);
							DecodeFailed("Track exceeds 30 minutes or 512 MB decoded");
							return;
						}
						clip = content;
						loadedHash = loadingHash;
						((Object)clip).name = state.Title;
						request.Dispose();
						request = null;
						operation = null;
						loadingHash = "";
						if ((Object)(object)model.Source != (Object)null)
						{
							model.Source.clip = clip;
						}
						if (CanControl && pendingHostStart)
						{
							state.Position = 0.0;
							state.Stamp = lobby.Now;
							state.Playing = true;
							state.Revision++;
							pendingHostStart = false;
							PublishSoon();
						}
						startedClip = false;
						wasPlaying = false;
						status = state.Title;
					}
					catch (Exception ex2)
					{
						DecodeFailed(ex2.Message);
					}
				}
			}
		}

		private void DecodeFailed(string reason)
		{
			string item = ((loadingHash.Length != 0) ? loadingHash : state.Hash);
			failed.Add(item);
			ReleaseClip();
			Message("Cannot decode " + state.Title + ": " + reason);
			if (CanControl)
			{
				Select(1);
			}
		}

		private void PlayTick()
		{
			AudioSource source = model.Source;
			if ((Object)(object)source == (Object)null || (Object)(object)clip == (Object)null || loadedHash != state.Hash)
			{
				return;
			}
			if ((Object)(object)source.clip != (Object)(object)clip)
			{
				source.clip = clip;
				startedClip = false;
			}
			double num = state.Expected(lobby.Now);
			if (CanControl && startedClip && wasPlaying && state.Playing)
			{
				if (!AudioListener.pause && !source.isPlaying)
				{
					Select(1);
					return;
				}
				num = source.time;
			}
			if (state.Playing && num >= (double)clip.length)
			{
				if (CanControl)
				{
					Select(1);
					return;
				}
				source.Stop();
				wasPlaying = false;
			}
			else if (!state.Playing)
			{
				if (source.isPlaying)
				{
					source.Pause();
				}
				wasPlaying = false;
			}
			else if (!startedClip || !wasPlaying)
			{
				source.time = (float)Math.Min(num, Math.Max(0.0, (double)clip.length - 0.05));
				source.Play();
				startedClip = true;
				wasPlaying = true;
				nextSeek = Time.realtimeSinceStartup + 3f;
			}
			else
			{
				if (!(Time.realtimeSinceStartup >= nextSeek))
				{
					return;
				}
				nextSeek = Time.realtimeSinceStartup + 3f;
				if (CanControl)
				{
					if (!AudioListener.pause && !source.isPlaying)
					{
						Select(1);
						return;
					}
					state.Position = source.time;
					state.Stamp = lobby.Now;
					state.Revision++;
					PublishSoon();
				}
				else if (!AudioListener.pause && Math.Abs((double)source.time - num) > 1.5)
				{
					source.time = (float)Math.Min(num, (double)clip.length - 0.05);
					if (!source.isPlaying)
					{
						source.Play();
					}
				}
			}
		}

		private void PlaceInFront()
		{
			//IL_0035: 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_004a: 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)
			//IL_0054: 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_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: 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_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: 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_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			Camera main = Camera.main;
			if ((Object)(object)main == (Object)null || (Object)(object)anchor == (Object)null)
			{
				Message("Active camera not found");
				return;
			}
			Vector3 val = anchor.InverseTransformPoint(((Component)main).transform.position + ((Component)main).transform.forward * 0.8f - Vector3.up * 0.25f);
			if (!(Mathf.Max(new float[3]
			{
				Mathf.Abs(val.x),
				Mathf.Abs(val.y),
				Mathf.Abs(val.z)
			}) > 10f))
			{
				Vector3 val2 = anchor.InverseTransformDirection(((Component)main).transform.forward);
				state.X = (settings.X = val.x);
				state.Y = (settings.Y = val.y);
				state.Z = (settings.Z = val.z);
				state.Yaw = (settings.Yaw = Mathf.Atan2(val2.x, val2.z) * 57.29578f);
				settings.AutoBench = false;
				state.Revision++;
				SaveSettings();
				PublishSoon();
				Message("Radio position saved (relative to tram console)");
			}
		}

		private void PublishSoon()
		{
			nextPublish = 0f;
		}

		private void SaveSettings()
		{
			try
			{
				settings.Save(configPath);
			}
			catch (Exception ex)
			{
				((MelonBase)this).LoggerInstance.Warning("Settings not saved: " + ex.Message);
			}
		}

		private void Message(string text)
		{
			status = text;
			((MelonBase)this).LoggerInstance.Msg(text);
		}

		private static string Hierarchy(Transform t)
		{
			string text = ((Object)t).name;
			while ((Object)(object)t.parent != (Object)null)
			{
				t = t.parent;
				text = ((Object)t).name + "/" + text;
			}
			return text;
		}

		private void ReleaseClip()
		{
			pendingHostStart = false;
			mp3Cancel?.Cancel();
			mp3Cancel?.Dispose();
			mp3Cancel = null;
			mp3Task = null;
			if (request != null)
			{
				request.Abort();
				request.Dispose();
				request = null;
			}
			operation = null;
			loadingHash = "";
			if ((Object)(object)model.Source != (Object)null)
			{
				model.Source.Stop();
				model.Source.clip = null;
			}
			if ((Object)(object)clip != (Object)null)
			{
				Object.Destroy((Object)(object)clip);
			}
			clip = null;
			loadedHash = "";
			startedClip = (wasPlaying = false);
		}

		public override void OnGUI()
		{
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Expected O, but got Unknown
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_015a: Unknown result type (might be due to invalid IL or missing references)
			//IL_017e: Unknown result type (might be due to invalid IL or missing references)
			if (initialized && settings.ShowHud && (!((Object)(object)anchor == (Object)null) || lobby.InLobby))
			{
				string text = ((!lobby.InLobby) ? "LOCAL" : (lobby.IsOwner ? "HOST" : "SYNC"));
				string text2 = (state.Playing ? "PLAY" : "PAUSE") + " | " + text + " | " + Math.Round(settings.Volume * 100f) + "%";
				GUI.Box(new Rect(14f, 14f, 490f, 133f), "TRAM RADIO  /  " + text2);
				GUIStyle val = new GUIStyle(GUI.skin.label)
				{
					wordWrap = true,
					richText = false
				};
				GUI.Label(new Rect(26f, 42f, 463f, 46f), ((Object)(object)anchor == (Object)null) ? "Waiting for tram console. Enter a playable tram scene. See Latest.log if this persists." : status, val);
				GUI.Label(new Rect(26f, 89f, 463f, 24f), "F6 Play/Pause   F7 Next   F8 Prev   F9 Scan", val);
				GUI.Label(new Rect(26f, 113f, 463f, 24f), "F10 Hide   -/= Volume   F4 Place radio (host near tram)", val);
			}
		}

		public override void OnDeinitializeMelon()
		{
			quit = true;
			try
			{
				lobby.Clear();
			}
			catch
			{
			}
			ReleaseClip();
			model.Dispose();
		}
	}
	internal sealed class PcmAudio
	{
		internal float[] Samples = Array.Empty<float>();

		internal int Rate;
	}
	internal static class Mp3Decoder
	{
		internal static PcmAudio Decode(string path, CancellationToken cancellation)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Expected O, but got Unknown
			using FileStream fileStream = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.Read);
			MpegFile val = new MpegFile((Stream)fileStream);
			try
			{
				if (val.Channels < 1 || val.Channels > 2 || val.SampleRate <= 0)
				{
					throw new IOException("Invalid MP3 format");
				}
				List<float> list = new List<float>();
				float[] array = new float[8192];
				int num;
				while ((num = val.ReadSamples(array, 0, array.Length)) > 0)
				{
					cancellation.ThrowIfCancellationRequested();
					if (list.Count + num / val.Channels > 67108864 || (double)list.Count / (double)val.SampleRate > 1800.0)
					{
						throw new IOException("MP3 exceeds 30 minutes or 256 MiB mono PCM");
					}
					for (int i = 0; i + val.Channels <= num; i += val.Channels)
					{
						float num2 = ((val.Channels == 1) ? array[i] : ((array[i] + array[i + 1]) * 0.5f));
						list.Add((float.IsNaN(num2) || float.IsInfinity(num2)) ? 0f : Math.Max(-1f, Math.Min(1f, num2)));
					}
				}
				if (list.Count < val.SampleRate / 10)
				{
					throw new IOException("MP3 has no playable samples");
				}
				return new PcmAudio
				{
					Samples = list.ToArray(),
					Rate = val.SampleRate
				};
			}
			finally
			{
				((IDisposable)val)?.Dispose();
			}
		}
	}
	internal sealed class Track
	{
		internal string Path = "";

		internal string Hash = "";

		internal string Title => System.IO.Path.GetFileNameWithoutExtension(Path);
	}
	internal sealed class ScanResult
	{
		internal readonly List<Track> Tracks = new List<Track>();

		internal readonly List<string> Warnings = new List<string>();
	}
	internal static class MusicLibrary
	{
		internal static ScanResult ScanPackage(string modDirectory, string legacyDirectory, int maxMegabytes)
		{
			ScanResult scanResult = new ScanResult();
			HashSet<string> hashSet = new HashSet<string>(StringComparer.Ordinal);
			string[] array = new string[2]
			{
				modDirectory,
				Path.Combine(modDirectory, "Music")
			};
			foreach (string text in array)
			{
				if (!Directory.Exists(text))
				{
					continue;
				}
				try
				{
					ScanResult scanResult2 = Scan(text, maxMegabytes);
					scanResult.Warnings.AddRange(scanResult2.Warnings);
					foreach (Track track in scanResult2.Tracks)
					{
						if (hashSet.Add(track.Hash))
						{
							scanResult.Tracks.Add(track);
						}
					}
				}
				catch (Exception ex) when (ex is IOException || ex is UnauthorizedAccessException)
				{
					scanResult.Warnings.Add("Cannot scan " + text + ": " + ex.Message);
				}
			}
			if (scanResult.Tracks.Count == 0 && Directory.Exists(legacyDirectory))
			{
				try
				{
					ScanResult scanResult3 = Scan(legacyDirectory, maxMegabytes);
					scanResult.Tracks.AddRange(scanResult3.Tracks);
					scanResult.Warnings.AddRange(scanResult3.Warnings);
				}
				catch (Exception ex2) when (ex2 is IOException || ex2 is UnauthorizedAccessException)
				{
					scanResult.Warnings.Add("Cannot scan legacy Music: " + ex2.Message);
				}
			}
			scanResult.Tracks.Sort((Track a, Track b) => StringComparer.OrdinalIgnoreCase.Compare(a.Title, b.Title));
			return scanResult;
		}

		internal static ScanResult Scan(string directory, int maxMegabytes)
		{
			ScanResult scanResult = new ScanResult();
			HashSet<string> hashSet = new HashSet<string>(StringComparer.Ordinal);
			Directory.CreateDirectory(directory);
			foreach (string item in Directory.GetFiles(directory).OrderBy<string, string>((string p) => p, StringComparer.OrdinalIgnoreCase))
			{
				string text = Path.GetExtension(item).ToLowerInvariant();
				if (text != ".mp3" && text != ".ogg" && text != ".wav")
				{
					continue;
				}
				try
				{
					FileInfo fileInfo = new FileInfo(item);
					if (fileInfo.Length == 0L || fileInfo.Length > (long)maxMegabytes * 1024L * 1024)
					{
						scanResult.Warnings.Add("Skipped empty/oversized file: " + fileInfo.Name);
						continue;
					}
					using FileStream inputStream = new FileStream(item, FileMode.Open, FileAccess.Read, FileShare.Read);
					using SHA256 sHA = SHA256.Create();
					string text2 = BitConverter.ToString(sHA.ComputeHash(inputStream)).Replace("-", "").ToLowerInvariant();
					if (hashSet.Add(text2))
					{
						scanResult.Tracks.Add(new Track
						{
							Path = item,
							Hash = text2
						});
					}
				}
				catch (Exception ex) when (ex is IOException || ex is UnauthorizedAccessException)
				{
					scanResult.Warnings.Add(Path.GetFileName(item) + ": " + ex.Message);
				}
			}
			return scanResult;
		}

		internal static int NextIndex(int current, int delta, int count)
		{
			if (count > 0)
			{
				if (current >= 0)
				{
					return ((current + delta) % count + count) % count;
				}
				if (delta >= 0)
				{
					return 0;
				}
				return count - 1;
			}
			return -1;
		}
	}
	internal static class Placement
	{
		internal static bool TryBench(Transform console, out Vector3 local, out float yaw, out string name)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: 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)
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			//IL_0145: Unknown result type (might be due to invalid IL or missing references)
			//IL_0162: Unknown result type (might be due to invalid IL or missing references)
			//IL_016e: Unknown result type (might be due to invalid IL or missing references)
			//IL_017a: Unknown result type (might be due to invalid IL or missing references)
			//IL_019a: Unknown result type (might be due to invalid IL or missing references)
			//IL_019f: Unknown result type (might be due to invalid IL or missing references)
			//IL_030b: Unknown result type (might be due to invalid IL or missing references)
			//IL_030d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0317: Unknown result type (might be due to invalid IL or missing references)
			//IL_031c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0321: Unknown result type (might be due to invalid IL or missing references)
			//IL_0326: Unknown result type (might be due to invalid IL or missing references)
			//IL_0330: Unknown result type (might be due to invalid IL or missing references)
			//IL_033f: Unknown result type (might be due to invalid IL or missing references)
			//IL_034e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_022d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0242: Unknown result type (might be due to invalid IL or missing references)
			//IL_0244: Unknown result type (might be due to invalid IL or missing references)
			//IL_024b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0217: Unknown result type (might be due to invalid IL or missing references)
			//IL_0386: Unknown result type (might be due to invalid IL or missing references)
			//IL_038b: Unknown result type (might be due to invalid IL or missing references)
			//IL_038d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0392: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_03be: Unknown result type (might be due to invalid IL or missing references)
			//IL_0271: Unknown result type (might be due to invalid IL or missing references)
			//IL_0276: Unknown result type (might be due to invalid IL or missing references)
			//IL_027a: Unknown result type (might be due to invalid IL or missing references)
			//IL_028d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0299: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e9: Unknown result type (might be due to invalid IL or missing references)
			local = Vector3.zero;
			yaw = 0f;
			name = "";
			float num = float.MaxValue;
			Renderer[] array = Object.FindObjectsByType<Renderer>((FindObjectsSortMode)0);
			Vector3 point = default(Vector3);
			foreach (Renderer val in array)
			{
				if (!val.enabled || !((Component)val).gameObject.activeInHierarchy)
				{
					continue;
				}
				string text = ((Object)val).name.ToLowerInvariant();
				if ((Object)(object)((Component)val).transform.parent != (Object)null)
				{
					text = text + " " + ((Object)((Component)val).transform.parent).name.ToLowerInvariant();
				}
				if (!text.Contains("bench") && !text.Contains("seat") && !text.Contains("cushion"))
				{
					continue;
				}
				Bounds bounds = val.bounds;
				float num2 = Vector3.Distance(console.position, ((Bounds)(ref bounds)).center);
				if (num2 > 10f || ((Bounds)(ref bounds)).size.x > 8f || ((Bounds)(ref bounds)).size.z > 8f || Math.Max(((Bounds)(ref bounds)).size.x, ((Bounds)(ref bounds)).size.z) < 0.7f || Math.Min(((Bounds)(ref bounds)).size.x, ((Bounds)(ref bounds)).size.z) < 0.22f)
				{
					continue;
				}
				((Vector3)(ref point))..ctor(((Bounds)(ref bounds)).center.x, ((Bounds)(ref bounds)).max.y, ((Bounds)(ref bounds)).center.z);
				float num3 = float.MaxValue;
				for (int j = 0; j < 5; j++)
				{
					Vector3 center = ((Bounds)(ref bounds)).center;
					if (j == 1)
					{
						center.x += ((Bounds)(ref bounds)).extents.x * 0.45f;
					}
					if (j == 2)
					{
						center.x -= ((Bounds)(ref bounds)).extents.x * 0.45f;
					}
					if (j == 3)
					{
						center.z += ((Bounds)(ref bounds)).extents.z * 0.45f;
					}
					if (j == 4)
					{
						center.z -= ((Bounds)(ref bounds)).extents.z * 0.45f;
					}
					center.y = ((Bounds)(ref bounds)).max.y + 0.15f;
					RaycastHit[] array2 = Physics.RaycastAll(center, Vector3.down, ((Bounds)(ref bounds)).size.y + 0.3f, -5, (QueryTriggerInteraction)1);
					for (int k = 0; k < array2.Length; k++)
					{
						RaycastHit val2 = array2[k];
						if (!(((RaycastHit)(ref val2)).normal.y < 0.8f) && !(((RaycastHit)(ref val2)).point.y < ((Bounds)(ref bounds)).min.y + 0.05f))
						{
							Bounds bounds2 = ((RaycastHit)(ref val2)).collider.bounds;
							if (((Bounds)(ref bounds2)).Intersects(bounds) && ((RaycastHit)(ref val2)).point.y < num3)
							{
								num3 = ((RaycastHit)(ref val2)).point.y;
								point = ((RaycastHit)(ref val2)).point;
							}
						}
					}
				}
				Vector3 val3 = console.InverseTransformPoint(point + Vector3.up * 0.17f);
				if (!(Mathf.Max(new float[3]
				{
					Mathf.Abs(val3.x),
					Mathf.Abs(val3.y),
					Mathf.Abs(val3.z)
				}) > 10f))
				{
					float num4 = num2 + (float)(text.Contains("cushion") ? (-2) : 0);
					if (!(num4 >= num))
					{
						Vector3 val4 = console.position - point;
						val4.y = 0f;
						val4 = console.InverseTransformDirection(val4);
						num = num4;
						local = val3;
						yaw = Mathf.Atan2(0f - val4.x, 0f - val4.z) * 57.29578f;
						name = ((Object)val).name;
					}
				}
			}
			return num < float.MaxValue;
		}
	}
	internal sealed class RadioState
	{
		internal string Token = Guid.NewGuid().ToString("N");

		internal long Revision;

		internal ulong Owner;

		internal string Hash = "";

		internal string Title = "";

		internal bool Playing;

		internal double Position;

		internal double Stamp;

		internal float X = 0.65f;

		internal float Y = 0.3f;

		internal float Z = 0.1f;

		internal float Yaw;

		internal double Expected(double now)
		{
			return Math.Max(0.0, Position + (Playing ? Math.Max(0.0, now - Stamp) : 0.0));
		}

		internal void SetPlaying(bool value, double now)
		{
			Position = Expected(now);
			Stamp = now;
			Playing = value;
			Revision++;
		}

		internal string Encode()
		{
			string s = ((Title.Length > 180) ? Title.Substring(0, 180) : Title);
			return string.Join("|", "1", Owner.ToString(CultureInfo.InvariantCulture), Token, Revision.ToString(CultureInfo.InvariantCulture), Hash, Playing ? "1" : "0", F(Position), F(Stamp), Convert.ToBase64String(Encoding.UTF8.GetBytes(s)), F(X), F(Y), F(Z), F(Yaw));
		}

		private static string F(double value)
		{
			return value.ToString("R", CultureInfo.InvariantCulture);
		}

		internal static bool TryDecode(string raw, ulong owner, out RadioState? value)
		{
			value = null;
			if (string.IsNullOrEmpty(raw) || raw.Length > 2048)
			{
				return false;
			}
			string[] array = raw.Split('|');
			if (array.Length != 13 || array[0] != "1" || !ulong.TryParse(array[1], out var result) || result != owner || result == 0L || !Guid.TryParseExact(array[2], "N", out var _) || !long.TryParse(array[3], out var result3) || result3 < 0 || (array[4].Length != 0 && !IsHash(array[4])) || (array[5] != "0" && array[5] != "1"))
			{
				return false;
			}
			double[] array2 = new double[6];
			int[] array3 = new int[6] { 6, 7, 9, 10, 11, 12 };
			for (int i = 0; i < array3.Length; i++)
			{
				if (!double.TryParse(array[array3[i]], NumberStyles.Float, CultureInfo.InvariantCulture, out array2[i]) || double.IsNaN(array2[i]) || double.IsInfinity(array2[i]))
				{
					return false;
				}
			}
			if (array2[0] < 0.0 || array2[0] > 86400.0 || array2[1] < 0.0 || array2[1] > 4294967295.0 || Math.Abs(array2[2]) > 10.0 || Math.Abs(array2[3]) > 10.0 || Math.Abs(array2[4]) > 10.0 || Math.Abs(array2[5]) > 360.0)
			{
				return false;
			}
			string text;
			try
			{
				text = Encoding.UTF8.GetString(Convert.FromBase64String(array[8]));
			}
			catch (FormatException)
			{
				return false;
			}
			if (text.Length > 180 || (array[5] == "1" && array[4].Length == 0))
			{
				return false;
			}
			value = new RadioState
			{
				Owner = result,
				Token = array[2],
				Revision = result3,
				Hash = array[4],
				Playing = (array[5] == "1"),
				Position = array2[0],
				Stamp = array2[1],
				Title = text,
				X = (float)array2[2],
				Y = (float)array2[3],
				Z = (float)array2[4],
				Yaw = (float)array2[5]
			};
			return true;
		}

		private static bool IsHash(string s)
		{
			if (s.Length != 64)
			{
				return false;
			}
			foreach (char c in s)
			{
				if ((c < '0' || c > '9') && (c < 'a' || c > 'f'))
				{
					return false;
				}
			}
			return true;
		}

		internal static float DistanceGain(float distance, float near, float far)
		{
			if (distance <= near)
			{
				return 1f;
			}
			if (distance >= far)
			{
				return 0f;
			}
			float num = (distance - near) / (far - near);
			return (1f - num) * (1f - num);
		}
	}
	internal sealed class RadioModel : IDisposable
	{
		internal GameObject? Root;

		internal AudioSource? Source;

		private readonly List<Material> materials = new List<Material>();

		private Material? screen;

		private float gain;

		internal void UpdateAcoustics(AudioListener? listener, bool? indoor, float baseVolume)
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)Root == (Object)null) && !((Object)(object)Source == (Object)null))
			{
				((Component)Source).transform.localPosition = Vector3.zero;
				if ((Object)(object)listener == (Object)null || indoor != false)
				{
					gain = 0f;
					Source.volume = 0f;
				}
				else
				{
					gain = Mathf.Lerp(gain, baseVolume, 1f - Mathf.Exp((0f - Time.unscaledDeltaTime) * 5f));
					Source.volume = gain;
				}
			}
		}

		internal void Create(Transform anchor)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Expected O, but got Unknown
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: 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_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: 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)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			//IL_0155: Unknown result type (might be due to invalid IL or missing references)
			//IL_0169: Unknown result type (might be due to invalid IL or missing references)
			//IL_018f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0219: Unknown result type (might be due to invalid IL or missing references)
			//IL_023d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0251: Unknown result type (might be due to invalid IL or missing references)
			//IL_0281: Unknown result type (might be due to invalid IL or missing references)
			//IL_0295: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_02df: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0302: Expected O, but got Unknown
			Dispose();
			Root = new GameObject("TramRadio_Magnetola");
			Root.transform.SetParent(anchor, false);
			Vector3 lossyScale = anchor.lossyScale;
			Root.transform.localScale = new Vector3(SafeInverse(lossyScale.x), SafeInverse(lossyScale.y), SafeInverse(lossyScale.z));
			Material material = Mat(new Color(0.09f, 0.105f, 0.12f));
			Material material2 = Mat(new Color(0.3f, 0.33f, 0.35f));
			Material material3 = Mat(new Color(0.025f, 0.03f, 0.035f));
			screen = Mat(new Color(0.05f, 0.35f, 0.23f));
			Part("Body", (PrimitiveType)3, Vector3.zero, new Vector3(0.72f, 0.32f, 0.21f), material);
			Part("TopHandle", (PrimitiveType)3, new Vector3(0f, 0.245f, 0f), new Vector3(0.37f, 0.035f, 0.045f), material2);
			for (int i = -1; i <= 1; i += 2)
			{
				Part("HandleSupport", (PrimitiveType)3, new Vector3((float)i * 0.17f, 0.2f, 0f), new Vector3(0.035f, 0.085f, 0.045f), material2);
				Part("SpeakerRim", (PrimitiveType)2, new Vector3((float)i * 0.235f, 0f, -0.111f), new Vector3(0.235f, 0.012f, 0.235f), material2).transform.localRotation = Quaternion.Euler(90f, 0f, 0f);
				Part("Speaker", (PrimitiveType)2, new Vector3((float)i * 0.235f, 0f, -0.127f), new Vector3(0.19f, 0.01f, 0.19f), material3).transform.localRotation = Quaternion.Euler(90f, 0f, 0f);
				Part("SpeakerCap", (PrimitiveType)0, new Vector3((float)i * 0.235f, 0f, -0.141f), new Vector3(0.07f, 0.07f, 0.025f), material2);
			}
			Part("Display", (PrimitiveType)3, new Vector3(0f, 0.065f, -0.113f), new Vector3(0.15f, 0.06f, 0.012f), screen);
			for (int j = 0; j < 4; j++)
			{
				Part("Button", (PrimitiveType)3, new Vector3(-0.06f + 0.04f * (float)j, -0.04f, -0.12f), new Vector3(0.026f, 0.035f, 0.025f), material2);
			}
			GameObject val = new GameObject("TramRadio_Emitter");
			val.transform.SetParent(Root.transform, false);
			Source = val.AddComponent<AudioSource>();
			gain = 0f;
			Source.playOnAwake = false;
			Source.loop = false;
			Source.spatialBlend = 1f;
			Source.spread = 0f;
			Source.dopplerLevel = 0f;
			Source.priority = 0;
			Source.minDistance = 1f;
			Source.maxDistance = 1000000f;
			Source.rolloffMode = (AudioRolloffMode)2;
			Source.SetCustomCurve((AudioSourceCurveType)0, AnimationCurve.Linear(0f, 1f, 1f, 1f));
			Source.reverbZoneMix = 0f;
			Source.bypassReverbZones = true;
			Source.ignoreListenerPause = false;
			Source.ignoreListenerVolume = false;
		}

		private static float SafeInverse(float s)
		{
			if (!(Math.Abs(s) < 0.0001f))
			{
				return 1f / Math.Abs(s);
			}
			return 1f;
		}

		internal void Place(RadioState state)
		{
			//IL_002c: 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)
			if (!((Object)(object)Root == (Object)null))
			{
				Root.transform.localPosition = new Vector3(state.X, state.Y, state.Z);
				Root.transform.localRotation = Quaternion.Euler(0f, state.Yaw, 0f);
			}
		}

		internal void Light(bool playing)
		{
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: 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)
			if (!((Object)(object)screen == (Object)null))
			{
				Color val = (playing ? new Color(0.08f, 0.8f, 0.45f) : new Color(0.08f, 0.2f, 0.15f));
				if (screen.HasProperty("_BaseColor"))
				{
					screen.SetColor("_BaseColor", val);
				}
				if (screen.HasProperty("_Color"))
				{
					screen.SetColor("_Color", val);
				}
			}
		}

		private Material Mat(Color color)
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Expected O, but got Unknown
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Expected O, but got Unknown
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			Shader val = Shader.Find("Universal Render Pipeline/Lit") ?? Shader.Find("Standard") ?? Shader.Find("Unlit/Color");
			Material val2;
			if ((Object)(object)val != (Object)null)
			{
				val2 = new Material(val);
			}
			else
			{
				Renderer componentInChildren = ((Component)Root.transform.parent).GetComponentInChildren<Renderer>();
				if ((Object)(object)componentInChildren == (Object)null || (Object)(object)componentInChildren.sharedMaterial == (Object)null)
				{
					throw new InvalidOperationException("No usable shader for radio model");
				}
				val2 = new Material(componentInChildren.sharedMaterial);
			}
			if (val2.HasProperty("_BaseColor"))
			{
				val2.SetColor("_BaseColor", color);
			}
			if (val2.HasProperty("_Color"))
			{
				val2.SetColor("_Color", color);
			}
			if (val2.HasProperty("_BaseMap"))
			{
				val2.SetTexture("_BaseMap", (Texture)null);
			}
			if (val2.HasProperty("_MainTex"))
			{
				val2.SetTexture("_MainTex", (Texture)null);
			}
			materials.Add(val2);
			return val2;
		}

		private GameObject Part(string name, PrimitiveType primitive, Vector3 p, Vector3 size, Material material)
		{
			//IL_0000: 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_0036: Unknown result type (might be due to invalid IL or missing references)
			GameObject obj = GameObject.CreatePrimitive(primitive);
			((Object)obj).name = name;
			obj.transform.SetParent(Root.transform, false);
			obj.transform.localPosition = p;
			obj.transform.localScale = size;
			Collider component = obj.GetComponent<Collider>();
			if ((Object)(object)component != (Object)null)
			{
				component.enabled = false;
				Object.Destroy((Object)(object)component);
			}
			obj.GetComponent<Renderer>().sharedMaterial = material;
			return obj;
		}

		public void Dispose()
		{
			if ((Object)(object)Source != (Object)null)
			{
				Source.Stop();
				Source.clip = null;
			}
			if ((Object)(object)Root != (Object)null)
			{
				Object.Destroy((Object)(object)Root);
			}
			foreach (Material material in materials)
			{
				if ((Object)(object)material != (Object)null)
				{
					Object.Destroy((Object)(object)material);
				}
			}
			materials.Clear();
			Root = null;
			Source = null;
			screen = null;
		}
	}
	internal sealed class Settings
	{
		internal float Volume = 0.8f;

		internal float NearDistance = 6f;

		internal float MaxDistance = 100f;

		internal float ControlDistance = 5f;

		internal float X = 0.65f;

		internal float Y = 0.3f;

		internal float Z = 0.1f;

		internal float Yaw;

		internal int MaxFileMB = 128;

		internal bool ShowHud = true;

		internal bool AutoBench = true;

		internal void Read(string path)
		{
			if (!File.Exists(path))
			{
				Save(path);
				return;
			}
			Dictionary<string, string> dictionary = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
			string[] array = File.ReadAllLines(path);
			for (int i = 0; i < array.Length; i++)
			{
				string text = array[i].Trim();
				if (!text.StartsWith("#") && text.Length != 0)
				{
					int num = text.IndexOf('=');
					if (num > 0)
					{
						dictionary[text.Substring(0, num).Trim()] = text.Substring(num + 1).Trim();
					}
				}
			}
			Volume = ReadFloat(dictionary, "Volume", Volume, 0f, 1f);
			NearDistance = ReadFloat(dictionary, "NearDistance", NearDistance, 1f, 30f);
			MaxDistance = ReadFloat(dictionary, "MaxDistance", MaxDistance, NearDistance + 1f, 500f);
			if (dictionary.TryGetValue("AutoBench", out var value) && bool.TryParse(value, out var result))
			{
				AutoBench = result;
			}
			ControlDistance = ReadFloat(dictionary, "ControlDistance", ControlDistance, 2f, 20f);
			X = ReadFloat(dictionary, "X", X, -10f, 10f);
			Y = ReadFloat(dictionary, "Y", Y, -10f, 10f);
			Z = ReadFloat(dictionary, "Z", Z, -10f, 10f);
			Yaw = ReadFloat(dictionary, "Yaw", Yaw, -360f, 360f);
			MaxFileMB = (int)ReadFloat(dictionary, "MaxFileMB", MaxFileMB, 1f, 256f);
			if (dictionary.TryGetValue("ShowHud", out var value2) && bool.TryParse(value2, out var result2))
			{
				ShowHud = result2;
			}
		}

		private static float ReadFloat(Dictionary<string, string> d, string key, float fallback, float min, float max)
		{
			if (!d.TryGetValue(key, out string value) || !float.TryParse(value, NumberStyles.Float, CultureInfo.InvariantCulture, out var result) || float.IsNaN(result) || float.IsInfinity(result))
			{
				return fallback;
			}
			return Math.Max(min, Math.Min(max, result));
		}

		internal void Save(string path)
		{
			Directory.CreateDirectory(Path.GetDirectoryName(path));
			string[] contents = new string[13]
			{
				"# TramRadio 1.0.0. Edit while the game is closed. Decimal separator: dot.",
				"# Volume is personal; placement is shared by the lobby owner.",
				"AutoBench=" + AutoBench,
				"Volume=" + F(Volume),
				"NearDistance=" + F(NearDistance),
				"MaxDistance=" + F(MaxDistance),
				"ControlDistance=" + F(ControlDistance),
				"MaxFileMB=" + MaxFileMB,
				"ShowHud=" + ShowHud,
				"X=" + F(X),
				"Y=" + F(Y),
				"Z=" + F(Z),
				"Yaw=" + F(Yaw)
			};
			File.WriteAllLines(path, contents);
		}

		private static string F(float f)
		{
			return f.ToString("R", CultureInfo.InvariantCulture);
		}
	}
}