using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Json;
using System.Runtime.Versioning;
using System.Security;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using System.Xml;
using BepInEx;
using BepInEx.Configuration;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using NLayer;
using SailwindRadio.Acoustics;
using SailwindRadio.Library;
using SailwindRadio.Models;
using SailwindRadio.Persistence;
using SailwindRadio.Physical;
using SailwindRadio.Playback;
using SailwindRadio.Shops;
using SailwindRadio.UI;
using UnityEngine;
using UnityEngine.Networking;
using UnityEngine.Rendering;
using UnityEngine.SceneManagement;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.0", FrameworkDisplayName = ".NET Standard 2.0")]
[assembly: AssemblyCompany("SailwindRadio")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.1.0")]
[assembly: AssemblyInformationalVersion("1.0.1")]
[assembly: AssemblyProduct("SailwindRadio")]
[assembly: AssemblyTitle("SailwindRadio")]
[assembly: AssemblyVersion("1.0.1.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class IsReadOnlyAttribute : Attribute
	{
	}
	[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 SailwindRadio
{
	public sealed class RadioBassFilter : MonoBehaviour
	{
		private sealed class BassFilter
		{
			internal readonly int SampleRate;

			private readonly double[] b0 = new double[2];

			private readonly double[] b1 = new double[2];

			private readonly double[] b2 = new double[2];

			private readonly double[] a1 = new double[2];

			private readonly double[] a2 = new double[2];

			private readonly double[] z1 = new double[16];

			private readonly double[] z2 = new double[16];

			internal BassFilter(int sampleRate)
			{
				SampleRate = sampleRate;
				double num = Math.PI * 280.0 / (double)sampleRate;
				double num2 = Math.Cos(num);
				double num3 = Math.Sin(num);
				for (int i = 0; i < 2; i++)
				{
					double num4 = ((i == 0) ? 0.541196100146197 : 1.30656296487638);
					double num5 = num3 / (2.0 * num4);
					double num6 = 1.0 + num5;
					b0[i] = (1.0 - num2) / (2.0 * num6);
					b1[i] = (1.0 - num2) / num6;
					b2[i] = b0[i];
					a1[i] = -2.0 * num2 / num6;
					a2[i] = (1.0 - num5) / num6;
				}
			}

			internal float Apply(float sample, int channel)
			{
				if (channel >= 8)
				{
					return 0f;
				}
				double num = (RadioSpeakerOutput.Finite(sample) ? sample : 0f);
				for (int i = 0; i < 2; i++)
				{
					int num2 = i * 8 + channel;
					double num3 = b0[i] * num + z1[num2];
					z1[num2] = b1[i] * num - a1[i] * num3 + z2[num2];
					z2[num2] = b2[i] * num - a2[i] * num3;
					num = num3;
				}
				return (float)(num * 2.0);
			}
		}

		private volatile BassFilter bass;

		internal void SetProfile(int sampleRate, bool woofer)
		{
			BassFilter bassFilter = bass;
			if (!woofer)
			{
				bass = null;
				return;
			}
			if (sampleRate < 8000 || sampleRate > 192000)
			{
				sampleRate = 48000;
			}
			if (bassFilter == null || bassFilter.SampleRate != sampleRate)
			{
				bass = new BassFilter(sampleRate);
			}
		}

		private void OnAudioFilterRead(float[] data, int channels)
		{
			Process(data, channels);
		}

		internal void Process(float[] data, int channels)
		{
			BassFilter bassFilter = bass;
			if (channels <= 0 || bassFilter == null)
			{
				return;
			}
			for (int i = 0; i < data.Length; i += channels)
			{
				for (int j = 0; j < channels && i + j < data.Length; j++)
				{
					float num = bassFilter.Apply(data[i + j], j);
					data[i + j] = (RadioSpeakerOutput.Finite(num) ? Math.Max(-1f, Math.Min(1f, num)) : 0f);
				}
			}
		}
	}
	public sealed class RadioPlayback : IDisposable
	{
		internal sealed class DecodedMp3
		{
			internal readonly List<float[]> Blocks = new List<float[]>();

			internal int Channels;

			internal int SampleRate;

			internal int SampleCount;
		}

		internal sealed class Mp3LoadResult
		{
			internal DecodedMp3 Decoded;

			internal StreamedMp3 Stream;
		}

		internal sealed class CancellableFileStream : Stream
		{
			private readonly FileStream input;

			private readonly CancellationToken token;

			public override bool CanRead => true;

			public override bool CanSeek => true;

			public override bool CanWrite => false;

			public override long Length => input.Length;

			public override long Position
			{
				get
				{
					return input.Position;
				}
				set
				{
					CancellationToken cancellationToken = token;
					cancellationToken.ThrowIfCancellationRequested();
					input.Position = value;
				}
			}

			internal CancellableFileStream(string path, CancellationToken token)
			{
				this.token = token;
				input = File.Open(path, FileMode.Open, FileAccess.Read, FileShare.Read);
			}

			public override int Read(byte[] buffer, int offset, int count)
			{
				CancellationToken cancellationToken = token;
				cancellationToken.ThrowIfCancellationRequested();
				return input.Read(buffer, offset, count);
			}

			public override long Seek(long offset, SeekOrigin origin)
			{
				CancellationToken cancellationToken = token;
				cancellationToken.ThrowIfCancellationRequested();
				return input.Seek(offset, origin);
			}

			public override void Flush()
			{
			}

			public override void SetLength(long value)
			{
				throw new NotSupportedException();
			}

			public override void Write(byte[] buffer, int offset, int count)
			{
				throw new NotSupportedException();
			}

			protected override void Dispose(bool disposing)
			{
				if (disposing)
				{
					input.Dispose();
				}
				base.Dispose(disposing);
			}
		}

		private const double ScheduleLeadSeconds = 0.05;

		private const double LoadTimeoutSeconds = 60.0;

		private readonly RadioState state;

		private readonly Action<string> warning;

		private readonly MonoBehaviour host;

		private RadioAudioLifetime lifetime;

		private GameObject emitter;

		private AudioSource source;

		private RadioSpeakerOutput builtIn;

		private readonly Dictionary<int, RadioSpeakerOutput> endpoints = new Dictionary<int, RadioSpeakerOutput>();

		private readonly List<int> lostEndpoints = new List<int>();

		private Vector3 listenerPosition;

		private bool listenerKnown;

		private AudioClip clip;

		private UnityWebRequest request;

		private Task<Mp3LoadResult> mp3Task;

		private CancellationTokenSource mp3Cancellation;

		private StreamedMp3 streamedMp3;

		private string requestedPath;

		private string failure;

		private bool disposed;

		private bool running;

		private bool voicesPaused;

		private bool recoveryWarned;

		private double nextHealthCheck;

		private bool wasPowered;

		private volatile bool resetRequested;

		private double scheduledDsp;

		private double lastDsp;

		private int scheduledSample;

		private double loadStartedAt;

		private double streamWaitingSince = -1.0;

		internal const int MaximumMp3Samples = 67108864;

		internal const long MaximumMp3FileBytes = 134217728L;

		internal const long MaximumStreamedMp3FileBytes = 1073741824L;

		private static readonly SemaphoreSlim Mp3DecodeSlot = new SemaphoreSlim(1, 1);

		private string preloadPath;

		private bool preloadStarted;

		private bool preloadFailed;

		private AudioClip preloadClip;

		private UnityWebRequest preloadRequest;

		private Task<Mp3LoadResult> preloadTask;

		private CancellationTokenSource preloadCancellation;

		private double preloadStartedAt;

		public string Status { get; private set; }

		public string TrackLabel { get; private set; }

		public bool RepeatTrack { get; set; } = true;

		public bool TrackEnded { get; private set; }

		public bool LoadFailed => failure != null;

		public string FailedPath { get; private set; }

		public RadioPlayback(MonoBehaviour coroutineHost, RadioState state, Action<string> warning)
		{
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Expected O, but got Unknown
			if ((Object)(object)coroutineHost == (Object)null)
			{
				throw new ArgumentNullException("coroutineHost");
			}
			if (state == null)
			{
				throw new ArgumentNullException("state");
			}
			this.state = state;
			host = coroutineHost;
			this.warning = warning ?? ((Action<string>)delegate
			{
			});
			builtIn = new RadioSpeakerOutput("Sailwind Radio audio", RadioSpeakerProfile.BuiltIn, this.warning);
			emitter = builtIn.Emitter;
			source = builtIn.Source;
			lifetime = emitter.AddComponent<RadioAudioLifetime>();
			lifetime.Host = coroutineHost;
			lifetime.Playback = this;
			AudioSettings.OnAudioConfigurationChanged += new AudioConfigurationChangeHandler(OnAudioConfigurationChanged);
			Status = "Off";
			TrackLabel = "No track";
			lastDsp = AudioSettings.dspTime;
		}

		public void SetTrack(string path)
		{
			if (!disposed)
			{
				path = path ?? "";
				if (!string.Equals(state.TrackPath, path, StringComparison.Ordinal))
				{
					state.PositionSeconds = 0.0;
				}
				state.TrackPath = path;
				ReleaseTrack();
				failure = null;
				FailedPath = null;
				TrackEnded = false;
				requestedPath = null;
				if (!AdoptPreload(path))
				{
					ReleasePreload();
				}
			}
		}

		public void SetCarried(bool carried)
		{
			if (!disposed)
			{
				builtIn.Carried = carried;
			}
		}

		public void BeginEndpoints()
		{
			if (disposed)
			{
				return;
			}
			foreach (RadioSpeakerOutput value in endpoints.Values)
			{
				value.Seen = false;
			}
		}

		public void SetEndpoint(int id, Vector3 position, bool carried, int kind, float localVolume, float bass, float obstruction)
		{
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			if (disposed)
			{
				return;
			}
			RadioSpeakerProfile radioSpeakerProfile = RadioSpeakerProfile.ForKind(kind);
			if (radioSpeakerProfile != null)
			{
				if (!endpoints.TryGetValue(id, out var value) || (Object)(object)value.Emitter == (Object)null || (Object)(object)value.Source == (Object)null || value.Profile != radioSpeakerProfile)
				{
					value?.Dispose();
					value = new RadioSpeakerOutput("Sailwind Radio speaker " + id, radioSpeakerProfile, warning);
					endpoints[id] = value;
				}
				value.Profile = radioSpeakerProfile;
				value.Position = position;
				value.Carried = carried;
				value.LocalVolume = localVolume;
				value.Bass = bass;
				value.Obstruction = obstruction;
				value.Seen = true;
			}
		}

		public void EndEndpoints()
		{
			if (disposed)
			{
				return;
			}
			lostEndpoints.Clear();
			foreach (KeyValuePair<int, RadioSpeakerOutput> endpoint in endpoints)
			{
				if (!endpoint.Value.Seen)
				{
					lostEndpoints.Add(endpoint.Key);
				}
			}
			foreach (int lostEndpoint in lostEndpoints)
			{
				endpoints[lostEndpoint].Dispose();
				endpoints.Remove(lostEndpoint);
			}
		}

		public void SetAcoustics(Vector3 listenerPosition, bool listenerKnown, float obstruction)
		{
			//IL_000a: 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)
			//IL_0014: 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_002e: Unknown result type (might be due to invalid IL or missing references)
			if (!disposed)
			{
				this.listenerPosition = listenerPosition;
				this.listenerKnown = listenerKnown && IsFinite(listenerPosition.x) && IsFinite(listenerPosition.y) && IsFinite(listenerPosition.z);
				builtIn.Obstruction = obstruction;
			}
		}

		public void Tick(Vector3 worldPosition, bool suspended)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: 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_02e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02eb: Invalid comparison between Unknown and I4
			//IL_02c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cf: Invalid comparison between Unknown and I4
			//IL_0427: Unknown result type (might be due to invalid IL or missing references)
			//IL_042d: Invalid comparison between Unknown and I4
			//IL_04b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_04b8: Invalid comparison between Unknown and I4
			if (disposed)
			{
				return;
			}
			if ((Object)(object)host == (Object)null)
			{
				Dispose();
				return;
			}
			EnsureOwnedOutput();
			builtIn.Position = worldPosition;
			builtIn.LocalVolume = state.LocalVolume;
			state.Volume = (float.IsNaN(state.Volume) ? 0.5f : Mathf.Clamp01(state.Volume));
			builtIn.Update(state.Volume, listenerPosition, listenerKnown);
			source.loop = RepeatTrack;
			foreach (RadioSpeakerOutput value in endpoints.Values)
			{
				value.Update(state.Volume, listenerPosition, listenerKnown);
				if ((Object)(object)value.Source != (Object)null)
				{
					value.Source.loop = RepeatTrack;
				}
			}
			double dspTime = AudioSettings.dspTime;
			if (resetRequested || dspTime < lastDsp)
			{
				StopOutputs();
				resetRequested = false;
			}
			lastDsp = dspTime;
			PollPreload();
			if (!string.Equals(requestedPath, state.TrackPath ?? "", StringComparison.Ordinal))
			{
				ReleaseTrack();
				requestedPath = state.TrackPath ?? "";
				failure = null;
				FailedPath = null;
				TrackEnded = false;
				TrackLabel = SafeLabel(requestedPath);
				if (!AdoptPreload(requestedPath))
				{
					ReleasePreload();
					if (state.Powered)
					{
						BeginLoad();
					}
				}
			}
			else if (state.Powered && !wasPowered && (Object)(object)clip == (Object)null && request == null && mp3Task == null)
			{
				failure = null;
				FailedPath = null;
				BeginLoad();
			}
			wasPowered = state.Powered;
			CompleteLoad();
			CompleteMp3Load();
			if (streamedMp3 != null)
			{
				if (streamedMp3.Fault != null)
				{
					Fail("Unable to decode music", streamedMp3.Fault.Message);
				}
				else
				{
					int num = SafeSavedFrame();
					streamedMp3.Request(running ? SampleAt(dspTime) : num);
				}
			}
			if (request != null || mp3Task != null || ((Object)(object)clip != (Object)null && (int)clip.loadState != 2))
			{
				if ((Object)(object)clip != (Object)null && (int)clip.loadState == 3)
				{
					Fail("Unable to decode music", "The decoder failed to load audio data");
				}
				else if ((double)Time.realtimeSinceStartup - loadStartedAt >= 60.0)
				{
					Fail("Unable to load music", "Audio loading timed out after 60 seconds");
				}
			}
			FinishIfEnded();
			bool flag = state.Powered && !state.Paused && !suspended && !AudioListener.pause && !TrackEnded;
			int num2 = SafeSavedFrame();
			bool flag2 = streamedMp3 == null || streamedMp3.Ready(running ? SampleAt(dspTime) : num2);
			if (streamedMp3 != null && flag && !flag2)
			{
				if (streamWaitingSince < 0.0)
				{
					streamWaitingSince = Time.realtimeSinceStartup;
				}
				else if ((double)Time.realtimeSinceStartup - streamWaitingSince >= 60.0)
				{
					Fail("Unable to decode music", "Streamed MP3 buffer did not recover");
					flag = false;
				}
			}
			else
			{
				streamWaitingSince = -1.0;
			}
			if (!flag && running)
			{
				CapturePosition();
				PauseOutputs();
			}
			if (flag && (Object)(object)clip != (Object)null && (int)clip.loadState == 2 && !running && flag2)
			{
				StartAtSavedPosition();
			}
			if (running)
			{
				CapturePosition();
			}
			if (running)
			{
				JoinEndpoints();
			}
			if (running)
			{
				CheckOutputHealth();
			}
			Status = ((!state.Powered) ? "Off" : ((failure != null) ? failure : ((request != null || mp3Task != null || ((Object)(object)clip != (Object)null && (int)clip.loadState != 2) || (streamedMp3 != null && !running && !flag2)) ? "Loading" : (((Object)(object)clip == (Object)null) ? "No track" : (TrackEnded ? "Ended" : (state.Paused ? "Paused" : ((suspended || AudioListener.pause) ? "Suspended" : "Playing")))))));
		}

		public void CapturePosition()
		{
			if (!disposed && running && !((Object)(object)clip == (Object)null) && !resetRequested && !(AudioSettings.dspTime < lastDsp) && !FinishIfEnded())
			{
				state.PositionSeconds = (double)SampleAt(AudioSettings.dspTime) / (double)clip.frequency;
			}
		}

		private int SafeSavedFrame()
		{
			if ((Object)(object)clip == (Object)null || clip.samples <= 0 || clip.frequency <= 0)
			{
				return 0;
			}
			double positionSeconds = state.PositionSeconds;
			if (double.IsNaN(positionSeconds) || double.IsInfinity(positionSeconds) || positionSeconds < 0.0)
			{
				return 0;
			}
			return (int)Math.Min(clip.samples - 1, Math.Floor(positionSeconds * (double)clip.frequency));
		}

		private int SampleAt(double dsp)
		{
			long num = scheduledSample + (long)Math.Round(Math.Max(0.0, dsp - scheduledDsp) * (double)clip.frequency);
			if (!RepeatTrack)
			{
				return (int)Math.Min(clip.samples, num);
			}
			return (int)(num % clip.samples);
		}

		internal static float DistanceGain(float distance)
		{
			return RadioSpeakerOutput.DistanceGain(distance, RadioSpeakerProfile.BuiltIn.Radius);
		}

		private static bool IsFinite(float value)
		{
			return RadioSpeakerOutput.Finite(value);
		}

		private void BeginLoad()
		{
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Invalid comparison between Unknown and I4
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Invalid comparison between Unknown and I4
			//IL_0175: Unknown result type (might be due to invalid IL or missing references)
			//IL_018b: Unknown result type (might be due to invalid IL or missing references)
			if (string.IsNullOrWhiteSpace(requestedPath))
			{
				return;
			}
			try
			{
				if (!Path.IsPathRooted(requestedPath))
				{
					throw new IOException("Choose an absolute local music file path");
				}
				string fullPath = Path.GetFullPath(requestedPath);
				Uri uri = new Uri(fullPath);
				if (!uri.IsFile || uri.IsUnc)
				{
					throw new IOException("Choose a local music file");
				}
				AudioType val = (AudioType)(Path.GetExtension(fullPath).ToLowerInvariant() switch
				{
					".mp3" => 13, 
					".ogg" => 14, 
					".wav" => 20, 
					_ => throw new IOException("Choose an MP3, OGG or WAV file"), 
				});
				if (!File.Exists(fullPath))
				{
					throw new IOException("Music file is missing or inaccessible");
				}
				if (new FileInfo(fullPath).Length > (((int)val == 13) ? 1073741824 : 134217728))
				{
					throw new IOException("Audio file exceeds the size limit");
				}
				loadStartedAt = Time.realtimeSinceStartup;
				if ((int)val == 13)
				{
					mp3Cancellation = new CancellationTokenSource();
					mp3Cancellation.CancelAfter(60000);
					CancellationToken token = mp3Cancellation.Token;
					double saved = state.PositionSeconds;
					mp3Task = Task.Run(() => PrepareMp3(fullPath, saved, token), token);
				}
				else
				{
					request = UnityWebRequestMultimedia.GetAudioClip(uri.AbsoluteUri, val);
					((DownloadHandlerAudioClip)request.downloadHandler).streamAudio = false;
					request.SendWebRequest();
				}
			}
			catch (Exception ex)
			{
				Fail("Unable to load music", ex.Message);
			}
		}

		private void CompleteLoad()
		{
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Invalid comparison between Unknown and I4
			if (request == null || !request.isDone)
			{
				return;
			}
			try
			{
				if (request.isNetworkError || request.isHttpError)
				{
					throw new IOException(request.error ?? "Audio request failed");
				}
				clip = DownloadHandlerAudioClip.GetContent(request);
				if ((Object)(object)clip == (Object)null || (int)clip.loadState == 3 || clip.samples <= 0 || clip.frequency <= 0 || (long)clip.samples * (long)clip.channels > 67108864)
				{
					throw new IOException("The file could not be decoded as audio");
				}
				source.clip = clip;
				request.Dispose();
				request = null;
			}
			catch (Exception ex)
			{
				Fail("Unable to decode music", ex.Message);
			}
		}

		private void CompleteMp3Load()
		{
			if (mp3Task == null || !mp3Task.IsCompleted)
			{
				return;
			}
			try
			{
				if (mp3Task.IsCanceled)
				{
					throw new IOException("MP3 decoding timed out");
				}
				if (mp3Task.IsFaulted)
				{
					throw new IOException("MP3 decoding failed: " + mp3Task.Exception.GetBaseException().Message);
				}
				Mp3LoadResult result = mp3Task.Result;
				mp3Task = null;
				mp3Cancellation.Dispose();
				mp3Cancellation = null;
				if (result.Stream != null)
				{
					streamedMp3 = result.Stream;
					StreamedMp3.Reader reader = streamedMp3.CreateReader();
					clip = streamedMp3.CreateClip(reader);
					if ((Object)(object)clip == (Object)null)
					{
						throw new IOException("Unable to create streamed audio clip");
					}
					builtIn.StreamClip = clip;
					source.clip = clip;
					ReleasePreload();
					return;
				}
				DecodedMp3 decoded = result.Decoded;
				clip = AudioClip.Create("Sailwind Radio MP3", decoded.SampleCount / decoded.Channels, decoded.Channels, decoded.SampleRate, false);
				if ((Object)(object)clip == (Object)null)
				{
					throw new IOException("Unable to allocate the decoded audio clip");
				}
				int num = 0;
				foreach (float[] block in decoded.Blocks)
				{
					if (!clip.SetData(block, num))
					{
						throw new IOException("Unable to upload decoded audio");
					}
					num += block.Length / decoded.Channels;
				}
				source.clip = clip;
			}
			catch (Exception ex)
			{
				Fail("Unable to decode music", ex.Message);
			}
		}

		internal static Mp3LoadResult PrepareMp3(string path, double initialSeconds, CancellationToken token, int maximumSamples = 67108864)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Expected O, but got Unknown
			token.ThrowIfCancellationRequested();
			using (CancellableFileStream cancellableFileStream = new CancellableFileStream(path, token))
			{
				if (cancellableFileStream.Length > 1073741824)
				{
					throw new IOException("MP3 exceeds the streamed file size limit");
				}
				MpegFile val = new MpegFile((Stream)cancellableFileStream);
				try
				{
					int channels = val.Channels;
					if (channels < 1 || channels > 2 || val.SampleRate < 8000 || val.SampleRate > 96000)
					{
						throw new IOException("Unsupported MP3 channel count or sample rate");
					}
					if (((val.Length < 0) ? (-1) : (val.Length / 4)) > maximumSamples || cancellableFileStream.Length > 134217728)
					{
						if (val.Length % (channels * 4) != 0L)
						{
							throw new IOException("Invalid MP3 sample length");
						}
						if (double.IsNaN(initialSeconds) || double.IsInfinity(initialSeconds) || initialSeconds < 0.0)
						{
							initialSeconds = 0.0;
						}
						int initialFrame = (int)Math.Min(2147483646.0, initialSeconds * (double)val.SampleRate);
						return new Mp3LoadResult
						{
							Stream = StreamedMp3.Open(path, initialFrame, token)
						};
					}
				}
				finally
				{
					((IDisposable)val)?.Dispose();
				}
			}
			return new Mp3LoadResult
			{
				Decoded = DecodeMp3(path, token, maximumSamples, 134217728L)
			};
		}

		internal static bool IsLongMp3(string path, CancellationToken token)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Expected O, but got Unknown
			token.ThrowIfCancellationRequested();
			using CancellableFileStream cancellableFileStream = new CancellableFileStream(path, token);
			if (cancellableFileStream.Length > 134217728)
			{
				return true;
			}
			MpegFile val = new MpegFile((Stream)cancellableFileStream);
			try
			{
				return val.Length > 268435456;
			}
			finally
			{
				((IDisposable)val)?.Dispose();
			}
		}

		internal static DecodedMp3 DecodeMp3(string path, CancellationToken token, int maximumSamples = 67108864, long maximumFileBytes = 134217728L)
		{
			Mp3DecodeSlot.Wait(token);
			try
			{
				return DecodeMp3Core(path, token, maximumSamples, maximumFileBytes);
			}
			finally
			{
				Mp3DecodeSlot.Release();
			}
		}

		private static DecodedMp3 DecodeMp3Core(string path, CancellationToken token, int maximumSamples, long maximumFileBytes)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Expected O, but got Unknown
			token.ThrowIfCancellationRequested();
			using CancellableFileStream cancellableFileStream = new CancellableFileStream(path, token);
			if (cancellableFileStream.Length > maximumFileBytes)
			{
				throw new IOException("MP3 exceeds the 128 MiB file size limit");
			}
			MpegFile val = new MpegFile((Stream)cancellableFileStream);
			try
			{
				DecodedMp3 decodedMp = new DecodedMp3
				{
					Channels = val.Channels,
					SampleRate = val.SampleRate
				};
				if (decodedMp.Channels < 1 || decodedMp.Channels > 2 || decodedMp.SampleRate < 8000 || decodedMp.SampleRate > 96000)
				{
					throw new IOException("Unsupported MP3 channel count or sample rate");
				}
				while (true)
				{
					token.ThrowIfCancellationRequested();
					float[] array = new float[16384];
					int num = val.ReadSamples(array, 0, array.Length);
					if (num == 0)
					{
						break;
					}
					if (num < 0 || num % decodedMp.Channels != 0)
					{
						throw new IOException("MP3 decoder returned incomplete sample frames");
					}
					if (num > maximumSamples - decodedMp.SampleCount)
					{
						throw new IOException("MP3 exceeds the 256 MiB decoded audio limit");
					}
					if (num != array.Length)
					{
						Array.Resize(ref array, num);
					}
					for (int i = 0; i < array.Length; i++)
					{
						array[i] = (float.IsNaN(array[i]) ? 0f : Math.Max(-1f, Math.Min(1f, array[i])));
					}
					decodedMp.Blocks.Add(array);
					decodedMp.SampleCount += num;
				}
				token.ThrowIfCancellationRequested();
				if (decodedMp.SampleCount == 0)
				{
					throw new IOException("The MP3 contains no decodable audio");
				}
				return decodedMp;
			}
			finally
			{
				((IDisposable)val)?.Dispose();
			}
		}

		private void StartAtSavedPosition()
		{
			double num = state.PositionSeconds;
			if (double.IsNaN(num) || double.IsInfinity(num) || num < 0.0)
			{
				num = 0.0;
			}
			double num2 = (double)clip.samples / (double)clip.frequency;
			if (!RepeatTrack && num >= num2)
			{
				state.PositionSeconds = num2;
				TrackEnded = true;
				return;
			}
			scheduledSample = (int)Math.Min(clip.samples - 1, Math.Floor(num % num2 * (double)clip.frequency));
			double dspTime = AudioSettings.dspTime;
			scheduledDsp = dspTime + (voicesPaused ? 0.0 : 0.05);
			if (voicesPaused)
			{
				ResumeOutput(builtIn, dspTime);
				foreach (RadioSpeakerOutput value in endpoints.Values)
				{
					ResumeOutput(value, dspTime);
				}
			}
			else
			{
				ScheduleEndpoint(builtIn, scheduledDsp, scheduledSample);
				foreach (RadioSpeakerOutput value2 in endpoints.Values)
				{
					ScheduleEndpoint(value2, scheduledDsp, scheduledSample);
				}
			}
			running = true;
			voicesPaused = false;
			nextHealthCheck = dspTime + 0.5;
		}

		private void ResumeOutput(RadioSpeakerOutput output, double now)
		{
			if (output.Paused && (Object)(object)output.Source != (Object)null && (Object)(object)output.Source.clip == (Object)(object)(((Object)(object)output.StreamClip != (Object)null) ? output.StreamClip : clip))
			{
				output.Resume(scheduledSample, now);
			}
			else
			{
				ScheduleEndpoint(output, now + 0.05, SampleAt(now + 0.05));
			}
		}

		private double EndDspTime()
		{
			if (!((Object)(object)clip == (Object)null))
			{
				return scheduledDsp + (double)(clip.samples - scheduledSample) / (double)clip.frequency;
			}
			return double.PositiveInfinity;
		}

		private bool FinishIfEnded()
		{
			if (!running || RepeatTrack || (Object)(object)clip == (Object)null || AudioSettings.dspTime < EndDspTime())
			{
				return false;
			}
			state.PositionSeconds = (double)clip.samples / (double)clip.frequency;
			TrackEnded = true;
			StopOutputs();
			return true;
		}

		private void JoinEndpoints()
		{
			double dspTime = AudioSettings.dspTime;
			bool waitingForStart = dspTime < scheduledDsp;
			JoinOutput(builtIn, dspTime, waitingForStart);
			foreach (RadioSpeakerOutput value in endpoints.Values)
			{
				JoinOutput(value, dspTime, waitingForStart);
			}
		}

		private void JoinOutput(RadioSpeakerOutput output, double now, bool waitingForStart)
		{
			if (!output.Running && !((Object)(object)output.Source == (Object)null))
			{
				double num = (waitingForStart ? scheduledDsp : (now + 0.05));
				if (RepeatTrack || !(num >= EndDspTime()))
				{
					ScheduleEndpoint(output, num, SampleAt(num));
				}
			}
		}

		private void ScheduleEndpoint(RadioSpeakerOutput endpoint, double start, int sample)
		{
			if (!((Object)(object)endpoint.Source == (Object)null) && !((Object)(object)clip == (Object)null) && sample >= 0 && sample < clip.samples && (RepeatTrack || !(start >= EndDspTime())))
			{
				if (streamedMp3 != null && (Object)(object)endpoint.StreamClip == (Object)null)
				{
					endpoint.StreamClip = streamedMp3.CreateClip(streamedMp3.CreateReader());
				}
				endpoint.Source.clip = (((Object)(object)endpoint.StreamClip != (Object)null) ? endpoint.StreamClip : clip);
				endpoint.Source.loop = RepeatTrack;
				endpoint.Source.timeSamples = sample;
				endpoint.Source.PlayScheduled(start);
				endpoint.Running = true;
				endpoint.Paused = false;
				endpoint.SettlesAt = start + 0.3;
				endpoint.StartsAt = start;
			}
		}

		private void PauseOutputs()
		{
			if (AudioSettings.dspTime < scheduledDsp)
			{
				StopOutputs();
				return;
			}
			running = false;
			voicesPaused = true;
			PauseOutput(builtIn);
			foreach (RadioSpeakerOutput value in endpoints.Values)
			{
				PauseOutput(value);
			}
		}

		private static void PauseOutput(RadioSpeakerOutput output)
		{
			if (AudioSettings.dspTime < output.StartsAt)
			{
				output.Stop();
			}
			else
			{
				output.Pause();
			}
		}

		private void StopOutputs(bool clearClip = false)
		{
			running = false;
			voicesPaused = false;
			if (builtIn != null)
			{
				builtIn.Stop(clearClip);
			}
			foreach (RadioSpeakerOutput value in endpoints.Values)
			{
				value.Stop(clearClip);
			}
		}

		private void EnsureOwnedOutput()
		{
			if ((Object)(object)emitter == (Object)null || (Object)(object)source == (Object)null)
			{
				RadioSpeakerOutput radioSpeakerOutput = builtIn;
				if ((Object)(object)lifetime != (Object)null)
				{
					lifetime.Playback = null;
				}
				builtIn = new RadioSpeakerOutput("Sailwind Radio audio", RadioSpeakerProfile.BuiltIn, warning);
				builtIn.Carried = radioSpeakerOutput.Carried;
				builtIn.Obstruction = radioSpeakerOutput.Obstruction;
				if ((Object)(object)radioSpeakerOutput.StreamClip == (Object)(object)clip)
				{
					radioSpeakerOutput.StreamClip = null;
				}
				radioSpeakerOutput.Dispose();
				emitter = builtIn.Emitter;
				source = builtIn.Source;
				lifetime = emitter.AddComponent<RadioAudioLifetime>();
				lifetime.Host = host;
				lifetime.Playback = this;
				WarnRecovery();
			}
			EnableOwnedOutput(builtIn);
			foreach (RadioSpeakerOutput value in endpoints.Values)
			{
				EnableOwnedOutput(value);
			}
		}

		private void EnableOwnedOutput(RadioSpeakerOutput output)
		{
			if (!((Object)(object)output.Emitter == (Object)null) && !((Object)(object)output.Source == (Object)null))
			{
				if (!output.Emitter.activeSelf)
				{
					output.Emitter.SetActive(true);
					WarnRecovery();
				}
				if (!((Behaviour)output.Source).enabled)
				{
					((Behaviour)output.Source).enabled = true;
					WarnRecovery();
				}
			}
		}

		private void WarnRecovery()
		{
			if (!recoveryWarned)
			{
				recoveryWarned = true;
				warning("Recovered an unavailable radio audio output");
			}
		}

		private void CheckOutputHealth()
		{
			double dspTime = AudioSettings.dspTime;
			if (dspTime < nextHealthCheck)
			{
				return;
			}
			nextHealthCheck = dspTime + 0.25;
			RepairOutput(builtIn, dspTime);
			foreach (RadioSpeakerOutput value in endpoints.Values)
			{
				RepairOutput(value, dspTime);
			}
		}

		private void RepairOutput(RadioSpeakerOutput output, double now)
		{
			if (!output.Running || (Object)(object)output.Source == (Object)null || now < output.SettlesAt)
			{
				return;
			}
			if (output.Source.isVirtual || output.Source.volume <= 0f)
			{
				output.DriftObservations = 0;
				return;
			}
			int num = SampleAt(now);
			int num2 = Math.Abs(output.Source.timeSamples - num);
			if (RepeatTrack)
			{
				num2 = Math.Min(num2, clip.samples - num2);
			}
			int num3 = default(int);
			int num4 = default(int);
			AudioSettings.GetDSPBufferSize(ref num3, ref num4);
			double num5 = Math.Max(0.05, 2.0 * (double)num3 / (double)Math.Max(8000, AudioSettings.outputSampleRate) + 0.01);
			if (output.Source.isPlaying)
			{
				if ((double)num2 <= (double)clip.frequency * num5)
				{
					output.DriftObservations = 0;
					return;
				}
				if (++output.DriftObservations < 2)
				{
					return;
				}
			}
			output.DriftObservations = 0;
			if (output.Source.isPlaying)
			{
				output.Pause();
				output.Resume(num, now);
			}
			else
			{
				ScheduleEndpoint(output, now + 0.05, SampleAt(now + 0.05));
			}
		}

		private void Fail(string message, string detail)
		{
			ReleaseTrack();
			failure = message;
			FailedPath = requestedPath;
			warning(message + ": " + detail);
		}

		private static string SafeLabel(string path)
		{
			if (string.IsNullOrWhiteSpace(path))
			{
				return "No track";
			}
			try
			{
				return Path.GetFileNameWithoutExtension(path);
			}
			catch
			{
				return "Music file";
			}
		}

		private void ReleaseTrack()
		{
			try
			{
				StopOutputs(clearClip: true);
			}
			finally
			{
				ReleaseTrackResources();
			}
		}

		private void ReleaseTrackResources()
		{
			if (mp3Cancellation != null)
			{
				Task<Mp3LoadResult> task = mp3Task;
				CancellationTokenSource cancellation = mp3Cancellation;
				mp3Task = null;
				mp3Cancellation = null;
				cancellation.Cancel();
				if (task == null)
				{
					cancellation.Dispose();
				}
				else
				{
					task.ContinueWith(delegate(Task<Mp3LoadResult> completed)
					{
						if (completed.IsFaulted)
						{
							_ = completed.Exception;
						}
						if (completed.Status == TaskStatus.RanToCompletion && completed.Result.Stream != null)
						{
							completed.Result.Stream.Dispose();
						}
						cancellation.Dispose();
					}, TaskScheduler.Default);
				}
			}
			try
			{
				DiscardRequest(ref request, clip);
			}
			finally
			{
				foreach (RadioSpeakerOutput value in endpoints.Values)
				{
					value.ReleaseStreamClip();
				}
				if (builtIn != null)
				{
					if ((Object)(object)builtIn.StreamClip == (Object)(object)clip)
					{
						builtIn.StreamClip = null;
					}
					else
					{
						builtIn.ReleaseStreamClip();
					}
				}
				if ((Object)(object)clip != (Object)null)
				{
					Object.Destroy((Object)(object)clip);
				}
				clip = null;
				if (streamedMp3 != null)
				{
					streamedMp3.Dispose();
					streamedMp3 = null;
				}
				streamWaitingSince = -1.0;
			}
		}

		private void OnAudioConfigurationChanged(bool deviceWasChanged)
		{
			resetRequested = true;
		}

		public void Dispose()
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Expected O, but got Unknown
			if (disposed)
			{
				return;
			}
			try
			{
				CapturePosition();
			}
			finally
			{
				disposed = true;
				AudioSettings.OnAudioConfigurationChanged -= new AudioConfigurationChangeHandler(OnAudioConfigurationChanged);
				try
				{
					try
					{
						ReleaseTrack();
					}
					finally
					{
						ReleasePreload();
					}
				}
				finally
				{
					foreach (RadioSpeakerOutput value in endpoints.Values)
					{
						value.Dispose();
					}
					endpoints.Clear();
					if (builtIn != null)
					{
						builtIn.Dispose();
					}
					builtIn = null;
					emitter = null;
					source = null;
				}
			}
		}

		public void PreloadTrack(string path)
		{
			if (!disposed)
			{
				path = path ?? "";
				if (string.Equals(path, state.TrackPath, StringComparison.OrdinalIgnoreCase))
				{
					path = "";
				}
				if (!string.Equals(path, preloadPath ?? "", StringComparison.OrdinalIgnoreCase))
				{
					ReleasePreload();
					preloadPath = path;
				}
			}
		}

		private void PollPreload()
		{
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Invalid comparison between Unknown and I4
			//IL_0351: Unknown result type (might be due to invalid IL or missing references)
			//IL_0357: Invalid comparison between Unknown and I4
			//IL_0378: Unknown result type (might be due to invalid IL or missing references)
			//IL_037e: Invalid comparison between Unknown and I4
			//IL_017d: Unknown result type (might be due to invalid IL or missing references)
			//IL_017e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0193: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a9: Unknown result type (might be due to invalid IL or missing references)
			if (string.IsNullOrEmpty(preloadPath) || preloadFailed)
			{
				return;
			}
			try
			{
				if (!preloadStarted)
				{
					if (!state.Powered || (Object)(object)clip == (Object)null || (int)clip.loadState != 2 || streamedMp3 != null)
					{
						return;
					}
					if (!Path.IsPathRooted(preloadPath))
					{
						throw new IOException("Expected an absolute local path");
					}
					string fullPath = Path.GetFullPath(preloadPath);
					Uri uri = new Uri(fullPath);
					if (!uri.IsFile || uri.IsUnc || !File.Exists(fullPath))
					{
						throw new IOException("Upcoming track unavailable");
					}
					if (new FileInfo(fullPath).Length > 134217728)
					{
						throw new IOException("Upcoming file exceeds the size limit");
					}
					string text = Path.GetExtension(fullPath).ToLowerInvariant();
					preloadStartedAt = Time.realtimeSinceStartup;
					preloadStarted = true;
					int num;
					AudioType val;
					switch (text)
					{
					case ".mp3":
					{
						preloadCancellation = new CancellationTokenSource();
						preloadCancellation.CancelAfter(60000);
						CancellationToken token = preloadCancellation.Token;
						preloadTask = Task.Run(delegate
						{
							if (IsLongMp3(fullPath, token))
							{
								throw new IOException("Long MP3 starts streaming only when selected");
							}
							return new Mp3LoadResult
							{
								Decoded = DecodeMp3(fullPath, token, 67108864, 134217728L)
							};
						}, token);
						break;
					}
					default:
						num = 0;
						goto IL_017d;
					case ".wav":
						num = 20;
						goto IL_017d;
					case ".ogg":
						{
							num = 14;
							goto IL_017d;
						}
						IL_017d:
						val = (AudioType)num;
						if ((int)val == 0)
						{
							throw new IOException("Unsupported upcoming format");
						}
						preloadRequest = UnityWebRequestMultimedia.GetAudioClip(uri.AbsoluteUri, val);
						((DownloadHandlerAudioClip)preloadRequest.downloadHandler).streamAudio = false;
						preloadRequest.SendWebRequest();
						break;
					}
				}
				if (preloadRequest != null && preloadRequest.isDone)
				{
					if (preloadRequest.isNetworkError || preloadRequest.isHttpError)
					{
						throw new IOException("Upcoming decode failed");
					}
					preloadClip = DownloadHandlerAudioClip.GetContent(preloadRequest);
					preloadRequest.Dispose();
					preloadRequest = null;
					ValidatePreloadClip();
				}
				if (preloadTask != null && preloadTask.IsCompleted)
				{
					if (preloadTask.IsCanceled || preloadTask.IsFaulted)
					{
						throw new IOException("Upcoming MP3 decode failed");
					}
					DecodedMp3 decoded = preloadTask.Result.Decoded;
					preloadTask = null;
					preloadCancellation.Dispose();
					preloadCancellation = null;
					preloadClip = AudioClip.Create("Sailwind Radio next MP3", decoded.SampleCount / decoded.Channels, decoded.Channels, decoded.SampleRate, false);
					if ((Object)(object)preloadClip == (Object)null)
					{
						throw new IOException("Upcoming clip allocation failed");
					}
					int num2 = 0;
					foreach (float[] block in decoded.Blocks)
					{
						if (!preloadClip.SetData(block, num2))
						{
							throw new IOException("Upcoming clip upload failed");
						}
						num2 += block.Length / decoded.Channels;
					}
					ValidatePreloadClip();
				}
				if ((Object)(object)preloadClip != (Object)null && (int)preloadClip.loadState == 3)
				{
					throw new IOException("Upcoming audio data failed");
				}
				if (((Object)(object)preloadClip == (Object)null || (int)preloadClip.loadState != 2) && (double)Time.realtimeSinceStartup - preloadStartedAt >= 60.0)
				{
					throw new IOException("Upcoming load timed out");
				}
			}
			catch
			{
				string text2 = preloadPath;
				ReleasePreload();
				preloadPath = text2;
				preloadFailed = true;
			}
		}

		private void ValidatePreloadClip()
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Invalid comparison between Unknown and I4
			if ((Object)(object)preloadClip == (Object)null || preloadClip.samples <= 0 || preloadClip.frequency <= 0 || (int)preloadClip.loadState == 3 || (long)preloadClip.samples * (long)preloadClip.channels > 67108864)
			{
				throw new IOException("Upcoming audio exceeds the decoded limit or is invalid");
			}
		}

		private bool AdoptPreload(string path)
		{
			if (!preloadStarted || preloadFailed || !string.Equals(path, preloadPath, StringComparison.OrdinalIgnoreCase))
			{
				return false;
			}
			requestedPath = path;
			TrackLabel = SafeLabel(path);
			clip = preloadClip;
			request = preloadRequest;
			mp3Task = preloadTask;
			mp3Cancellation = preloadCancellation;
			loadStartedAt = preloadStartedAt;
			if ((Object)(object)source != (Object)null)
			{
				source.clip = clip;
			}
			preloadClip = null;
			preloadRequest = null;
			preloadTask = null;
			preloadCancellation = null;
			preloadPath = null;
			preloadStarted = (preloadFailed = false);
			return true;
		}

		private void ReleasePreload()
		{
			if (preloadCancellation != null)
			{
				Task<Mp3LoadResult> task = preloadTask;
				CancellationTokenSource cancellation = preloadCancellation;
				cancellation.Cancel();
				if (task == null)
				{
					cancellation.Dispose();
				}
				else
				{
					task.ContinueWith(delegate(Task<Mp3LoadResult> completed)
					{
						if (completed.IsFaulted)
						{
							_ = completed.Exception;
						}
						cancellation.Dispose();
					}, TaskScheduler.Default);
				}
			}
			try
			{
				DiscardRequest(ref preloadRequest, preloadClip);
			}
			finally
			{
				if ((Object)(object)preloadClip != (Object)null)
				{
					Object.Destroy((Object)(object)preloadClip);
				}
				preloadPath = null;
				preloadClip = null;
				preloadTask = null;
				preloadCancellation = null;
				preloadStarted = (preloadFailed = false);
			}
		}

		private static void DiscardRequest(ref UnityWebRequest owned, AudioClip retained)
		{
			UnityWebRequest val = owned;
			owned = null;
			if (val == null)
			{
				return;
			}
			try
			{
				if (!val.isDone)
				{
					val.Abort();
				}
				else if (!val.isNetworkError && !val.isHttpError)
				{
					AudioClip content = DownloadHandlerAudioClip.GetContent(val);
					if ((Object)(object)content != (Object)null && (Object)(object)content != (Object)(object)retained)
					{
						Object.Destroy((Object)(object)content);
					}
				}
			}
			catch
			{
			}
			finally
			{
				val.Dispose();
			}
		}
	}
	public sealed class RadioAudioLifetime : MonoBehaviour
	{
		internal MonoBehaviour Host;

		internal RadioPlayback Playback;

		private void Update()
		{
			if ((Object)(object)Host == (Object)null && Playback != null)
			{
				Playback.Dispose();
			}
		}

		private void OnDestroy()
		{
			if ((Object)(object)Host == (Object)null && Playback != null)
			{
				Playback.Dispose();
			}
		}
	}
	internal sealed class RadioSpeakerProfile
	{
		internal readonly float Gain;

		internal readonly float Radius;

		internal readonly float HighPass;

		internal readonly float LowPass;

		internal readonly bool IsWoofer;

		internal static readonly RadioSpeakerProfile BuiltIn = new RadioSpeakerProfile(0.25f, 12f, 900f, 5000f);

		internal static readonly RadioSpeakerProfile Small = new RadioSpeakerProfile(0.35f, 15f, 600f, 9000f);

		internal static readonly RadioSpeakerProfile Normal = new RadioSpeakerProfile(0.65f, 20f, 160f, 18000f);

		internal static readonly RadioSpeakerProfile TurboWoofer = new RadioSpeakerProfile(1f, 20f, 20f, 140f, woofer: true);

		private RadioSpeakerProfile(float gain, float radius, float highPass, float lowPass, bool woofer = false)
		{
			Gain = gain;
			Radius = radius;
			HighPass = highPass;
			LowPass = lowPass;
			IsWoofer = woofer;
		}

		internal static RadioSpeakerProfile ForKind(int kind)
		{
			return kind switch
			{
				3 => TurboWoofer, 
				2 => Normal, 
				1 => Small, 
				_ => null, 
			};
		}
	}
	internal sealed class RadioSpeakerOutput : IDisposable
	{
		internal readonly GameObject Emitter;

		internal readonly AudioSource Source;

		internal AudioClip StreamClip;

		internal RadioSpeakerProfile Profile;

		internal Vector3 Position;

		internal bool Carried;

		internal bool Seen;

		internal bool Running;

		internal bool Paused;

		internal double SettlesAt;

		internal double StartsAt;

		internal int DriftObservations;

		internal float LocalVolume = 1f;

		internal float Bass = 1f;

		internal float Obstruction;

		private AudioHighPassFilter highPass;

		private AudioLowPassFilter lowPass;

		private RadioBassFilter bassFilter;

		private float smoothedObstruction;

		private bool initialized;

		internal RadioSpeakerOutput(string name, RadioSpeakerProfile profile, Action<string> warning)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Expected O, but got Unknown
			Profile = profile;
			Emitter = new GameObject(name);
			Object.DontDestroyOnLoad((Object)(object)Emitter);
			Source = Emitter.AddComponent<AudioSource>();
			Source.playOnAwake = false;
			Source.loop = true;
			Source.spatialBlend = 1f;
			AnimationCurve val = AnimationCurve.Constant(0f, 1f, 1f);
			val.preWrapMode = (WrapMode)8;
			val.postWrapMode = (WrapMode)8;
			Source.SetCustomCurve((AudioSourceCurveType)0, val);
			Source.rolloffMode = (AudioRolloffMode)2;
			Source.minDistance = 1f;
			Source.maxDistance = profile.Radius;
			Source.volume = 0f;
			Source.pitch = 1f;
			Source.dopplerLevel = 0f;
			Source.ignoreListenerPause = false;
			Source.bypassReverbZones = true;
			try
			{
				highPass = Emitter.AddComponent<AudioHighPassFilter>();
				if ((Object)(object)highPass == (Object)null)
				{
					throw new InvalidOperationException("High-pass component unavailable");
				}
				highPass.cutoffFrequency = profile.HighPass;
				highPass.highpassResonanceQ = 1f;
			}
			catch (Exception ex)
			{
				if ((Object)(object)highPass != (Object)null)
				{
					Object.Destroy((Object)(object)highPass);
				}
				highPass = null;
				warning("Radio high-pass filter unavailable: " + ex.Message);
			}
			try
			{
				lowPass = Emitter.AddComponent<AudioLowPassFilter>();
				if ((Object)(object)lowPass == (Object)null)
				{
					throw new InvalidOperationException("Low-pass component unavailable");
				}
				lowPass.cutoffFrequency = profile.LowPass;
				lowPass.lowpassResonanceQ = 1f;
			}
			catch (Exception ex2)
			{
				if ((Object)(object)lowPass != (Object)null)
				{
					Object.Destroy((Object)(object)lowPass);
				}
				lowPass = null;
				warning("Radio low-pass filter unavailable: " + ex2.Message);
			}
			if (!profile.IsWoofer)
			{
				return;
			}
			try
			{
				bassFilter = Emitter.AddComponent<RadioBassFilter>();
				if ((Object)(object)bassFilter == (Object)null)
				{
					throw new InvalidOperationException("Bass component unavailable");
				}
			}
			catch (Exception ex3)
			{
				if ((Object)(object)bassFilter != (Object)null)
				{
					Object.Destroy((Object)(object)bassFilter);
				}
				bassFilter = null;
				warning("Radio bass filter unavailable: " + ex3.Message);
			}
		}

		internal void Update(float masterVolume, Vector3 listener, bool listenerKnown)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0178: Unknown result type (might be due to invalid IL or missing references)
			//IL_017d: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)Emitter == (Object)null) && !((Object)(object)Source == (Object)null))
			{
				Emitter.transform.position = Position;
				Source.spatialBlend = (Carried ? 0f : 1f);
				Source.maxDistance = Profile.Radius;
				float num = (Carried ? 0f : Clamp(Obstruction));
				if (!initialized)
				{
					smoothedObstruction = num;
					initialized = true;
				}
				float num2 = Time.unscaledDeltaTime;
				if (!Finite(num2) || num2 < 0f)
				{
					num2 = 0f;
				}
				smoothedObstruction += (num - smoothedObstruction) * (float)(1.0 - Math.Exp((double)(0f - num2) / 0.25));
				float num3 = (Carried ? 0f : smoothedObstruction);
				if ((Object)(object)highPass != (Object)null)
				{
					highPass.cutoffFrequency = Profile.HighPass;
				}
				float num4 = Math.Min(1500f, Profile.LowPass);
				if ((Object)(object)lowPass != (Object)null)
				{
					lowPass.cutoffFrequency = Profile.LowPass + (num4 - Profile.LowPass) * num3;
				}
				float num5 = ((!listenerKnown) ? 0f : (Carried ? 1f : DistanceGain(Vector3.Distance(Position, listener), Profile.Radius)));
				float num6 = (Profile.IsWoofer ? 1f : Clamp(LocalVolume));
				float num7 = (Profile.IsWoofer ? ((float)Math.Sqrt(Clamp(Bass))) : 1f);
				Source.volume = Profile.Gain * masterVolume * masterVolume * num6 * num6 * num7 * num5 * (1f - (Profile.IsWoofer ? 0.4f : 0.65f) * num3);
				if ((Object)(object)bassFilter != (Object)null)
				{
					bassFilter.SetProfile(AudioSettings.outputSampleRate, Profile.IsWoofer);
				}
			}
		}

		internal void Stop(bool clearClip = false)
		{
			Running = (Paused = false);
			if (!((Object)(object)Source == (Object)null))
			{
				Source.Stop();
				if (clearClip)
				{
					Source.clip = null;
				}
			}
		}

		internal void Pause()
		{
			if (Running && !((Object)(object)Source == (Object)null))
			{
				Source.Pause();
				Running = false;
				Paused = true;
			}
		}

		internal void Resume(int sample, double now)
		{
			if (!((Object)(object)Source == (Object)null))
			{
				Source.timeSamples = sample;
				Source.UnPause();
				Running = true;
				Paused = false;
				SettlesAt = now + 0.3;
				StartsAt = now;
			}
		}

		internal static float DistanceGain(float distance, float radius)
		{
			if (!Finite(distance))
			{
				return 0f;
			}
			float num = 1f - Mathf.Clamp01((distance - 1f) / (radius - 1f));
			return num * num;
		}

		internal static float Clamp(float value)
		{
			if (!float.IsNaN(value))
			{
				return Mathf.Clamp01(value);
			}
			return 0f;
		}

		internal static bool Finite(float value)
		{
			if (!float.IsNaN(value))
			{
				return !float.IsInfinity(value);
			}
			return false;
		}

		public void Dispose()
		{
			try
			{
				Stop(clearClip: true);
			}
			finally
			{
				ReleaseStreamClip();
				if ((Object)(object)Emitter != (Object)null)
				{
					Object.Destroy((Object)(object)Emitter);
				}
				highPass = null;
				lowPass = null;
				bassFilter = null;
			}
		}

		internal void ReleaseStreamClip()
		{
			if ((Object)(object)StreamClip != (Object)null)
			{
				Object.Destroy((Object)(object)StreamClip);
			}
			StreamClip = null;
		}
	}
	internal sealed class StreamedMp3 : IDisposable
	{
		private sealed class Chunk
		{
			internal int State;

			internal int Start;

			internal int Count;

			internal readonly float[] Samples;

			internal Chunk(int channels)
			{
				Samples = new float[4096 * channels];
			}
		}

		internal sealed class Reader
		{
			private readonly StreamedMp3 owner;

			private int cursor;

			private int generation;

			internal int Cursor => Volatile.Read(in cursor);

			internal int Generation => Volatile.Read(in generation);

			internal Reader(StreamedMp3 owner)
			{
				this.owner = owner;
			}

			internal void SetPosition(int position)
			{
				position = Math.Max(0, Math.Min(owner.Frames - 1, position));
				int num = Volatile.Read(in cursor);
				Interlocked.Increment(ref generation);
				Volatile.Write(ref cursor, position);
				if (position != num)
				{
					owner.Request(position);
				}
			}

			internal void Read(float[] data)
			{
				Array.Clear(data, 0, data.Length);
				if (!owner.disposed)
				{
					int observedGeneration = Volatile.Read(in generation);
					int num = Volatile.Read(in cursor);
					int num2 = data.Length / owner.Channels;
					owner.Copy(num, data, num2);
					int advanced = ((num > owner.Frames - num2) ? owner.Frames : (num + num2));
					CommitRead(observedGeneration, num, advanced);
				}
			}

			internal void CommitRead(int observedGeneration, int start, int advanced)
			{
				if (Volatile.Read(in generation) == observedGeneration)
				{
					Interlocked.CompareExchange(ref cursor, advanced, start);
				}
			}
		}

		private const int ChunkFrames = 4096;

		private const int WindowSeconds = 20;

		private const int AheadSeconds = 10;

		private const int SeekPrerollSeconds = 5;

		private MpegFile decoder;

		private Stream input;

		private readonly string path;

		private readonly CancellationTokenSource cancellation;

		private readonly Chunk[] chunks;

		private readonly Task worker;

		private long requestedFrame;

		private Exception fault;

		private volatile bool disposed;

		internal readonly int Channels;

		internal readonly int SampleRate;

		internal readonly int Frames;

		internal int BufferSamples => chunks.Length * 4096 * Channels;

		internal bool WorkerCompleted => worker.IsCompleted;

		internal Exception Fault => Volatile.Read(in fault);

		internal static StreamedMp3 Open(string path, int initialFrame, CancellationToken token)
		{
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Expected O, but got Unknown
			token.ThrowIfCancellationRequested();
			CancellationTokenSource cancellationTokenSource = CancellationTokenSource.CreateLinkedTokenSource(new CancellationToken[1] { token });
			RadioPlayback.CancellableFileStream cancellableFileStream = null;
			try
			{
				cancellableFileStream = new RadioPlayback.CancellableFileStream(path, cancellationTokenSource.Token);
				if (cancellableFileStream.Length > 1073741824)
				{
					throw new IOException("MP3 exceeds the streamed file size limit");
				}
				MpegFile val = new MpegFile((Stream)cancellableFileStream);
				try
				{
					int channels = val.Channels;
					int sampleRate = val.SampleRate;
					long length = val.Length;
					if (!val.CanSeek || channels < 1 || channels > 2 || sampleRate < 8000 || sampleRate > 96000 || length <= 0 || length % (channels * 4) != 0L)
					{
						throw new IOException("MP3 cannot be streamed with a known seekable duration");
					}
					long num = length / (channels * 4);
					if (num > int.MaxValue - (long)sampleRate * 2L)
					{
						throw new IOException("MP3 duration exceeds Unity's sample-position limit");
					}
					return new StreamedMp3(path, cancellableFileStream, val, cancellationTokenSource, channels, sampleRate, (int)num, initialFrame);
				}
				catch
				{
					val.Dispose();
					throw;
				}
			}
			catch
			{
				cancellableFileStream?.Dispose();
				cancellationTokenSource.Dispose();
				throw;
			}
		}

		private StreamedMp3(string path, Stream input, MpegFile decoder, CancellationTokenSource cancellation, int channels, int rate, int frames, int initialFrame)
		{
			this.path = path;
			this.input = input;
			this.decoder = decoder;
			this.cancellation = cancellation;
			Channels = channels;
			SampleRate = rate;
			Frames = frames;
			chunks = new Chunk[Math.Max(2, (20 * rate + 4096 - 1) / 4096)];
			for (int i = 0; i < chunks.Length; i++)
			{
				chunks[i] = new Chunk(channels);
			}
			requestedFrame = Math.Max(0, Math.Min(frames - 1, initialFrame));
			worker = Task.Run((Action)Run);
		}

		internal Reader CreateReader()
		{
			return new Reader(this);
		}

		internal AudioClip CreateClip(Reader reader)
		{
			//IL_0034: 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: Expected O, but got Unknown
			//IL_004a: Expected O, but got Unknown
			if (disposed)
			{
				throw new ObjectDisposedException("StreamedMp3");
			}
			return AudioClip.Create("Sailwind Radio streamed MP3", Frames, Channels, SampleRate, true, new PCMReaderCallback(reader.Read), new PCMSetPositionCallback(reader.SetPosition));
		}

		internal void Request(int frame)
		{
			Interlocked.Exchange(ref requestedFrame, Math.Max(0, Math.Min(Frames - 1, frame)));
		}

		internal bool Ready(int frame)
		{
			if (disposed)
			{
				return false;
			}
			frame = Math.Max(0, Math.Min(Frames - 1, frame));
			int num = (int)Math.Min(Frames, (long)frame + (long)Math.Max(1, SampleRate / 2));
			for (int num2 = frame; num2 < num; num2 = (num2 / 4096 + 1) * 4096)
			{
				Chunk chunk = chunks[num2 / 4096 % chunks.Length];
				if (Volatile.Read(in chunk.State) < 0 || num2 < chunk.Start || num2 >= chunk.Start + chunk.Count)
				{
					return false;
				}
			}
			return true;
		}

		private void Copy(int frame, float[] destination, int frames)
		{
			if (frame < 0 || frame >= Frames)
			{
				return;
			}
			int i = Math.Max(0, frame);
			int num3;
			for (int num = (int)Math.Min(Frames, (long)Math.Max(0, frame) + (long)frames); i < num; i += num3)
			{
				int num2 = i / 4096 % chunks.Length;
				Chunk chunk = chunks[num2];
				num3 = Math.Min(num - i, 4096 - i % 4096);
				int num4;
				do
				{
					num4 = Volatile.Read(in chunk.State);
				}
				while (num4 >= 0 && Interlocked.CompareExchange(ref chunk.State, num4 + 1, num4) != num4);
				if (num4 < 0)
				{
					continue;
				}
				try
				{
					if (i >= chunk.Start && i + num3 <= chunk.Start + chunk.Count)
					{
						Array.Copy(chunk.Samples, (i - chunk.Start) * Channels, destination, (i - frame) * Channels, num3 * Channels);
					}
				}
				finally
				{
					Interlocked.Decrement(ref chunk.State);
				}
			}
		}

		private void Run()
		{
			int num = -1;
			try
			{
				while (!cancellation.IsCancellationRequested)
				{
					int num2 = (int)Interlocked.Read(in requestedFrame);
					int num3 = (int)Math.Min(Frames, (long)num2 + (long)(10 * SampleRate));
					if (num < num2 - SampleRate * 2 || num > num3 || num < 0 || (num >= num3 && !Ready(num2)))
					{
						bool num4 = num >= 0;
						num = num2 / 4096 * 4096;
						if (num4)
						{
							Reopen();
						}
						int num5 = Math.Max(0, num - 5 * SampleRate);
						if (num5 > 0)
						{
							decoder.Position = (long)num5 * (long)Channels * 4;
						}
						long num6 = decoder.Position / (Channels * 4);
						if (num5 > 0)
						{
							num6 += ((SampleRate >= 32000) ? 1152 : 576);
						}
						if (num6 > num)
						{
							throw new IOException("MP3 decoder seek passed the requested sample");
						}
						float[] array = new float[4096 * Channels];
						int num8;
						for (; num6 < num; num6 += num8 / Channels)
						{
							cancellation.Token.ThrowIfCancellationRequested();
							int num7 = (int)Math.Min(num - num6, 4096L) * Channels;
							num8 = decoder.ReadSamples(array, 0, num7);
							if (num8 <= 0 || num8 % Channels != 0)
							{
								throw new IOException("MP3 decoder could not finish seek");
							}
						}
					}
					if (num >= num3 || num >= Frames)
					{
						cancellation.Token.WaitHandle.WaitOne(20);
						continue;
					}
					Chunk chunk = chunks[num / 4096 % chunks.Length];
					while (Interlocked.CompareExchange(ref chunk.State, -1, 0) != 0)
					{
						cancellation.Token.ThrowIfCancellationRequested();
						cancellation.Token.WaitHandle.WaitOne(1);
					}
					int num9 = Math.Min(4096, Frames - num) * Channels;
					int i = 0;
					try
					{
						int num10;
						for (; i < num9; i += num10)
						{
							cancellation.Token.ThrowIfCancellationRequested();
							num10 = decoder.ReadSamples(chunk.Samples, i, num9 - i);
							if (num10 <= 0)
							{
								break;
							}
						}
						if (i == 0)
						{
							throw new IOException("MP3 ended before its reported duration");
						}
						if (i % Channels != 0)
						{
							throw new IOException("MP3 decoder returned an incomplete frame");
						}
						for (int j = 0; j < i; j++)
						{
							if (float.IsNaN(chunk.Samples[j]) || float.IsInfinity(chunk.Samples[j]))
							{
								chunk.Samples[j] = 0f;
							}
							else
							{
								chunk.Samples[j] = Math.Max(-1f, Math.Min(1f, chunk.Samples[j]));
							}
						}
						chunk.Start = num;
						chunk.Count = i / Channels;
					}
					finally
					{
						Volatile.Write(ref chunk.State, 0);
					}
					num += i / Channels;
				}
			}
			catch (OperationCanceledException)
			{
			}
			catch (Exception value)
			{
				Volatile.Write(ref fault, value);
			}
			finally
			{
				decoder.Dispose();
				input.Dispose();
			}
		}

		private void Reopen()
		{
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Expected O, but got Unknown
			decoder.Dispose();
			input.Dispose();
			input = new RadioPlayback.CancellableFileStream(path, cancellation.Token);
			decoder = new MpegFile(input);
		}

		public void Dispose()
		{
			if (disposed)
			{
				return;
			}
			disposed = true;
			cancellation.Cancel();
			worker.ContinueWith(delegate(Task done)
			{
				if (done.IsFaulted)
				{
					_ = done.Exception;
				}
				cancellation.Dispose();
			}, TaskScheduler.Default);
		}
	}
	[BepInPlugin("local.sailwind.radio", "Sailwind Radio", "1.0.1")]
	[BepInProcess("Sailwind.exe")]
	public sealed class Plugin : BaseUnityPlugin
	{
		public const string Id = "local.sailwind.radio";

		public const string Version = "1.0.1";

		private static Plugin instance;

		private Harmony harmony;

		private RadioWorldService world;

		private RadioAcousticsService acoustics;

		private RadioShopService shops;

		private ConfigEntry<string> musicFolders;

		private ConfigEntry<bool> continueWhileSleeping;

		private LibraryScanner library;

		private RadioMenus menus;

		private bool libraryReady;

		private readonly Dictionary<RadioItemController, RadioPlayback> playback = new Dictionary<RadioItemController, RadioPlayback>();

		private readonly Dictionary<RadioItemController, RadioQueue> queues = new Dictionary<RadioItemController, RadioQueue>();

		private readonly HashSet<RadioItemController> seen = new HashSet<RadioItemController>();

		private readonly List<RadioItemController> removed = new List<RadioItemController>();

		private bool ready;

		private bool applicationPaused;

		private bool focused = true;

		private bool Suspended
		{
			get
			{
				if (GameState.playing && !GameState.currentlyLoading && GameState.loadingScenes <= 0 && (!GameState.sleeping || continueWhileSleeping.Value) && (!(Time.timeScale <= 0f) || (GameState.sleeping && continueWhileSleeping.Value)) && !AudioListener.pause && !applicationPaused)
				{
					if (!focused)
					{
						return !Application.runInBackground;
					}
					return false;
				}
				return true;
			}
		}

		private void Awake()
		{
			//IL_01ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b8: Expected O, but got Unknown
			instance = this;
			try
			{
				musicFolders = ((BaseUnityPlugin)this).Config.Bind<string>("Music", "MusicFolders", "", "Music folders separated by |. Each folder is one collection including all its subfolders. Example: D:\\Music | E:\\Sailing Music");
				continueWhileSleeping = ((BaseUnityPlugin)this).Config.Bind<bool>("Audio", "ContinueWhileSleeping", false, "Keep music playing while the player sleeps. Loading still suspends playback.");
				ConfigEntry<string> val = ((BaseUnityPlugin)this).Config.Bind<string>("Development", "SpawnRadio", "", "Retired developer spawn shortcut.");
				((BaseUnityPlugin)this).Config.Remove(((ConfigEntryBase)val).Definition);
				ConfigEntry<int> val2 = ((BaseUnityPlugin)this).Config.Bind<int>("Internal", "SpawnDefaultRevision", 0, "Retired spawn shortcut migration marker.");
				((BaseUnityPlugin)this).Config.Remove(((ConfigEntryBase)val2).Definition);
				ConfigEntry<string> val3 = ((BaseUnityPlugin)this).Config.Bind<string>("Music", "MusicFile", "", "Retired single-file music setting.");
				bool num = !string.IsNullOrWhiteSpace(val3.Value) && string.IsNullOrWhiteSpace(musicFolders.Value);
				((BaseUnityPlugin)this).Config.Remove(((ConfigEntryBase)val3).Definition);
				ConfigEntry<bool> val4 = ((BaseUnityPlugin)this).Config.Bind<bool>("Audio", "StormInterferenceEnabled", true, "Retired interference setting.");
				((BaseUnityPlugin)this).Config.Remove(((ConfigEntryBase)val4).Definition);
				ConfigEntry<float> val5 = ((BaseUnityPlugin)this).Config.Bind<float>("Audio", "StormInterferenceStrength", 0.35f, "Retired interference setting.");
				((BaseUnityPlugin)this).Config.Remove(((ConfigEntryBase)val5).Definition);
				ConfigEntry<bool> val6 = ((BaseUnityPlugin)this).Config.Bind<bool>("Audio", "ContinueWhilePaused", false, "Retired pause setting.");
				((BaseUnityPlugin)this).Config.Remove(((ConfigEntryBase)val6).Definition);
				((BaseUnityPlugin)this).Config.Save();
				if (num)
				{
					Warn("MusicFile has been retired. Set MusicFolders to a folder containing your music.");
				}
				harmony = new Harmony("local.sailwind.radio");
				acoustics = new RadioAcousticsService();
				library = new LibraryScanner();
				menus = new RadioMenus();
				world = new RadioWorldService(harmony, Warn);
				world.BeforeSave += CapturePositions;
				world.ActionRequested += HandleAction;
				shops = new RadioShopService(world, Warn);
				menus.CollectionsChanged += SelectCollections;
				library.RequestScan(musicFolders.Value);
				InstallSuspendBoundary(typeof(StartMenu), "GameToSettings");
				InstallSuspendBoundary(typeof(Sleep), "FallAsleep");
				ready = true;
				((BaseUnityPlugin)this).Logger.LogInfo((object)"Sailwind Radio 1.0.1 ready. Configure MusicFolders to load music.");
			}
			catch (Exception ex)
			{
				((BaseUnityPlugin)this).Logger.LogError((object)("Radio initialization failed: " + ex));
				Shutdown();
				((Behaviour)this).enabled = false;
			}
		}

		private void InstallSuspendBoundary(Type type, string name)
		{
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Expected O, but got Unknown
			//IL_0087: Expected O, but got Unknown
			MethodInfo methodInfo = AccessTools.DeclaredMethod(type, name, Type.EmptyTypes, (Type[])null);
			if (methodInfo == null)
			{
				Warn("Immediate radio pause hook unavailable for " + type.Name + "." + name + ". Game state pause checks remain active.");
			}
			else
			{
				harmony.Patch((MethodBase)methodInfo, new HarmonyMethod(typeof(Plugin), "ReleaseControlBoundary", (Type[])null), new HarmonyMethod(typeof(Plugin), "SuspendBoundary", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			}
		}

		private static void ReleaseControlBoundary()
		{
			if (Object.op_Implicit((Object)(object)instance) && instance.ready)
			{
				instance.ReleaseRadioControls();
			}
		}

		private static void SuspendBoundary()
		{
			if (Object.op_Implicit((Object)(object)instance) && instance.ready && instance.Suspended)
			{
				instance.SuspendNow();
			}
		}

		private void Update()
		{
			if (!ready)
			{
				return;
			}
			try
			{
				acoustics.Tick();
				world.Tick();
				TickShops();
				SynchronizePlayback();
				if (library.Poll())
				{
					libraryReady = true;
					foreach (string warning in library.Snapshot.Warnings)
					{
						Warn(warning);
					}
					foreach (KeyValuePair<RadioItemController, RadioQueue> queue in queues)
					{
						if (queue.Value.ApplySnapshot(library.Snapshot))
						{
							playback[queue.Key].SetTrack(queue.Key.State.TrackPath);
						}
					}
					if (Object.op_Implicit((Object)(object)menus.CollectionRadio))
					{
						ShowCollections(menus.CollectionRadio);
					}
				}
				menus.Tick();
				bool suspended = Suspended;
				PlaybackOrder.Tick(playback, world.ActiveRadioId, (KeyValuePair<RadioItemController, RadioPlayback> pair) => Object.op_Implicit((Object)(object)pair.Key) ? pair.Key.InstanceId : 0, TickPlayback, suspended);
			}
			catch (Exception ex)
			{
				((BaseUnityPlugin)this).Logger.LogError((object)("Radio stopped after a runtime error: " + ex));
				Shutdown();
				((Behaviour)this).enabled = false;
			}
		}

		private void SynchronizePlayback()
		{
			seen.Clear();
			IReadOnlyList<RadioItemController> items = world.Items;
			for (int i = 0; i < items.Count; i++)
			{
				RadioItemController item = items[i];
				if (!Object.op_Implicit((Object)(object)item) || item.State.Kind != 0)
				{
					continue;
				}
				seen.Add(item);
				if (!playback.ContainsKey(item))
				{
					RadioQueue radioQueue = new RadioQueue(item.State);
					if (libraryReady)
					{
						radioQueue.ApplySnapshot(library.Snapshot);
					}
					queues.Add(item, radioQueue);
					RadioPlayback engine = new RadioPlayback((MonoBehaviour)(object)this, item.State, Warn)
					{
						RepeatTrack = false
					};
					playback.Add(item, engine);
					item.CapturePosition = engine.CapturePosition;
					item.SuspendPlayback = delegate
					{
						//IL_000c: Unknown result type (might be due to invalid IL or missing references)
						engine.Tick(item.VisualAudioPosition, suspended: true);
					};
				}
			}
			removed.Clear();
			foreach (KeyValuePair<RadioItemController, RadioPlayback> item2 in playback)
			{
				if (!Object.op_Implicit((Object)(object)item2.Key) || !seen.Contains(item2.Key))
				{
					item2.Value.Dispose();
					if (Object.op_Implicit((Object)(object)item2.Key))
					{
						item2.Key.CapturePosition = null;
						item2.Key.SuspendPlayback = null;
					}
					removed.Add(item2.Key);
				}
			}
			foreach (RadioItemController item3 in removed)
			{
				playback.Remove(item3);
				queues.Remove(item3);
			}
		}

		private void TickShops()
		{
			if (shops == null)
			{
				return;
			}
			try
			{
				shops.Tick();
			}
			catch (Exception ex)
			{
				Warn("Radio shops stopped after an error: " + ex.Message);
				RadioShopService radioShopService = shops;
				shops = null;
				try
				{
					radioShopService.Dispose();
				}
				catch (Exception ex2)
				{
					Warn("Could not release radio shops: " + ex2.Message);
				}
			}
		}

		private void TickPlayback(KeyValuePair<RadioItemController, RadioPlayback> pair, bool suspended)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: 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_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_0224: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: Unknown result type (might be due to invalid IL or missing references)
			//IL_015d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0163: Unknown result type (might be due to invalid IL or missing references)
			//IL_0164: Unknown result type (might be due to invalid IL or missing references)
			//IL_0183: Unknown result type (might be due to invalid IL or missing references)
			//IL_0195: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0190: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e9: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)pair.Key))
			{
				return;
			}
			Vector3 visualAudioPosition = pair.Key.VisualAudioPosition;
			Vector3 val = pair.Key.SoundPosition;
			bool usesPlayerPosition = pair.Key.UsesPlayerPosition;
			if (usesPlayerPosition && acoustics.ListenerKnown)
			{
				val = acoustics.ListenerPosition;
			}
			float obstruction = (pair.Key.State.Powered ? acoustics.ObstructionAt(val, usesPlayerPosition) : 0f);
			pair.Value.SetAcoustics(acoustics.ListenerPosition, acoustics.ListenerKnown, obstruction);
			pair.Value.SetCarried(usesPlayerPosition);
			pair.Value.BeginEndpoints();
			if (pair.Key.InstanceId == world.ActiveRadioId && pair.Key.State.Powered)
			{
				DeviceVessel vessel = pair.Key.Vessel;
				foreach (RadioItemController item in world.Items)
				{
					if (Object.op_Implicit((Object)(object)item) && item.State.Kind != 0 && item.State.SpeakerEnabled)
					{
						DeviceVessel vessel2 = item.Vessel;
						bool usesPlayerPosition2 = item.UsesPlayerPosition;
						Vector3 visualAudioPosition2 = item.VisualAudioPosition;
						if (DeviceVessels.CanConnect(vessel, vessel2, visualAudioPosition, visualAudioPosition2))
						{
							Vector3 val2 = ((usesPlayerPosition2 && acoustics.ListenerKnown) ? acoustics.ListenerPosition : item.SoundPosition);
							pair.Value.SetEndpoint(item.InstanceId, val2, usesPlayerPosition2, item.State.Kind, (item.State.Kind == 3) ? 1f : item.State.Volume, item.State.Bass, acoustics.ObstructionAt(val2, usesPlayerPosition2));
						}
					}
				}
			}
			pair.Value.EndEndpoints();
			pair.Value.Tick(val, suspended);
			if (!suspended && pair.Key.State.Powered && !pair.Key.State.Paused)
			{
				RadioQueue radioQueue = queues[pair.Key];
				bool num;
				if (!pair.Value.LoadFailed)
				{
					if (!pair.Value.TrackEnded)
					{
						goto IL_02c8;
					}
					num = radioQueue.TrackEnded();
				}
				else
				{
					num = radioQueue.TrackFailed(pair.Value.FailedPath);
				}
				if (num)
				{
					pair.Value.SetTrack(pair.Key.State.TrackPath);
				}
			}
			goto IL_02c8;
			IL_02c8:
			pair.Value.PreloadTrack((pair.Key.InstanceId == world.ActiveRadioId && pair.Key.State.Powered) ? queues[pair.Key].PeekNext() : "");
			TrackInfo trackInfo = library.Snapshot.GetTrackInfo(pair.Key.State.TrackPath);
			pair.Key.SetTrackInfo(trackInfo.Title, trackInfo.Artist, trackInfo.Album);
		}

		private void HandleAction(RadioItemController item, RadioAction action)
		{
			if (!ready || !Object.op_Implicit((Object)(object)item) || item.State.Kind != 0)
			{
				return;
			}
			if (action == RadioAction.Power)
			{
				if (item.State.Powered)
				{
					library.RequestScan(musicFolders.Value);
				}
			}
			else
			{
				if (!playback.TryGetValue(item, out var value) || !queues.TryGetValue(item, out var value2))
				{
					return;
				}
				bool flag = false;
				switch (action)
				{
				case RadioAction.PlayPause:
					if (!item.State.Powered)
					{
						item.TogglePower();
						break;
					}
					value.CapturePosition();
					item.State.Paused = !item.State.Paused;
					if (item.State.Paused)
					{
						item.SuspendPlayback?.Invoke();
					}
					break;
				case RadioAction.Previous:
					flag = value2.Previous();
					break;
				case RadioAction.Next:
					flag = value2.Next();
					break;
				case RadioAction.Shuffle:
					flag = value2.SetShuffle(!item.State.Shuffle);
					break;
				case RadioAction.Collections:
					ShowCollections(item);
					break;
				}
				if (flag)
				{
					value.SetTrack(item.State.TrackPath);
				}
			}
		}

		private void ShowCollections(RadioItemController item)
		{
			if (!Object.op_Implicit((Object)(object)item))
			{
				return;
			}
			List<CollectionChoice> list = new List<CollectionChoice>();
			HashSet<string> hashSet = new HashSet<string>(item.State.SelectedCollections ?? Array.Empty<string>(), StringComparer.OrdinalIgnoreCase);
			foreach (MusicCollection collection in library.Snapshot.Collections)
			{
				list.Add(new CollectionChoice(collection.Id, collection.Label, hashSet.Contains(collection.Id)));
			}
			menus.ShowCollections(item, list);
		}

		private void SelectCollections(RadioItemController item, string[] selected)
		{
			if (Object.op_Implicit((Object)(object)item) && queues.TryGetValue(item, out var value) && value.SetCollections(library.Snapshot, selected))
			{
				playback[item].SetTrack(item.State.TrackPath);
			}
		}

		private void OnGUI()
		{
			if (ready)
			{
				menus?.Draw();
			}
		}

		private void CapturePositions()
		{
			foreach (RadioPlayback value in playback.Values)
			{
				try
				{
					value.CapturePosition();
				}
				catch (Exception ex)
				{
					Warn("Could not capture a radio position: " + ex.Message);
				}
			}
		}

		private void SuspendNow()
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			foreach (KeyValuePair<RadioItemController, RadioPlayback> item in playback)
			{
				if (Object.op_Implicit((Object)(object)item.Key))
				{
					try
					{
						item.Value.Tick(item.Key.VisualAudioPosition, suspended: true);
					}
					catch (Exception ex)
					{
						Warn("Could not suspend a radio: " + ex.Message);
					}
				}
			}
		}

		private void ReleaseRadioControls()
		{
			menus?.Close();
			foreach (RadioItemController item in world?.Items ?? Array.Empty<RadioItemController>())
			{
				if (Object.op_Implicit((Object)(object)item))
				{
					try
					{
						item.ReleaseControls();
					}
					catch (Exception ex)
					{
						Warn("Could not release radio controls: " + ex.Message);
					}
				}
			}
		}

		private void OnApplicationPause(bool pause)
		{
			applicationPaused = pause;
			if (pause)
			{
				ReleaseRadioControls();
			}
			if (pause && ready)
			{
				SuspendNow();
			}
		}

		private void OnApplicationFocus(bool focus)
		{
			focused = focus;
			acoustics?.Invalidate();
			if (!focus)
			{
				ReleaseRadioControls();
			}
			if (!focus && !Application.runInBackground && ready)
			{
				SuspendNow();
			}
		}

		private void Warn(string message)
		{
			((BaseUnityPlugin)this).Logger.LogWarning((object)message);
		}

		private void OnDisable()
		{
			Shutdown();
		}

		private void OnDestroy()
		{
			Shutdown();
		}

		private void Shutdown()
		{
			ready = false;
			ReleaseRadioControls();
			CapturePositions();
			foreach (KeyValuePair<RadioItemController, RadioPlayback> item in playback)
			{
				if (Object.op_Implicit((Object)(object)item.Key))
				{
					item.Key.CapturePosition = null;
					item.Key.SuspendPlayback = null;
				}
				try
				{
					item.Value.Dispose();
				}
				catch (Exception ex)
				{
					Warn("Could not release a radio player: " + ex.Message);
				}
			}
			playback.Clear();
			queues.Clear();
			library?.Dispose();
			library = null;
			menus?.Dispose();
			menus = null;
			try
			{
				shops?.Dispose();
			}
			catch (Exception ex2)
			{
				Warn("Could not release radio shops: " + ex2.Message);
			}
			shops = null;
			try
			{
				world?.Dispose();
			}
			catch (Exception ex3)
			{
				Warn("Could not release radio item hooks: " + ex3.Message);
			}
			world = null;
			acoustics?.Dispose();
			acoustics = null;
			try
			{
				Harmony obj = harmony;
				if (obj != null)
				{
					obj.UnpatchSelf();
				}
			}
			catch (Exception ex4)
			{
				Warn("Could not remove radio hooks: " + ex4.Message);
			}
			harmony = null;
			if ((Object)(object)instance == (Object)(object)this)
			{
				instance = null;
			}
		}
	}
	[Serializable]
	public sealed class RadioState
	{
		public int Kind;

		public float Bass = 0.5f;

		public float LocalVolume = 1f;

		public bool SpeakerEnabled = true;

		public bool Shuffle;

		public bool CollectionsInitialized;

		public string[] SelectedCollections = Array.Empty<string>();

		public string TrackPath = "";

		public double PositionSeconds;

		public bool Powered;

		public bool Paused;

		public float Volume = 0.5f;
	}
}
namespace SailwindRadio.UI
{
	internal sealed class MenuInputLease
	{
		private Object character;

		private Object controller;

		private Object crosshair;

		private bool crosshairActive;

		private bool mouseLook;

		private bool cursorVisible;

		private CursorLockMode cursorLock;

		internal bool Owned { get; private set; }

		internal static bool GameplayAvailable
		{
			get
			{
				if (GameState.playing && !GameState.currentlyLoading && GameState.loadingScenes == 0 && !GameState.justStarted && !GameState.sleeping && !Object.op_Implicit((Object)(object)GameState.inBed) && !BoatCamera.on)
				{
					return Time.timeScale > 0f;
				}
				return false;
			}
		}

		internal bool Acquire()
		{
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			if (Owned)
			{
				return true;
			}
			if (!GameplayAvailable || !Application.isFocused || GameState.inCursorMenu || !Object.op_Implicit((Object)(object)Refs.charController) || !Object.op_Implicit((Object)(object)Refs.ovrController) || !Object.op_Implicit((Object)(object)Refs.mouseCrosshair) || !((Collider)Refs.charController).enabled || !((Behaviour)Refs.ovrController).enabled)
			{
				return false;
			}
			character = (Object)(object)Refs.charController;
			controller = (Object)(object)Refs.ovrController;
			crosshair = (Object)(object)Refs.mouseCrosshair;
			crosshairActive = Refs.mouseCrosshair.activeSelf;
			mouseLook = MouseLook.MouseLookIsEnabled();
			cursorVisible = Cursor.visible;
			cursorLock = Cursor.lockState;
			Owned = true;
			MouseLook.ToggleMouseLook(false);
			MouseLook.ToggleMouseLookAndCursor(false);
			((Collider)Refs.charController).enabled = false;
			((Behaviour)Refs.ovrController).enabled = false;
			Refs.mouseCrosshair.SetActive(false);
			return true;
		}

		internal void Release()
		{
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			if (!Owned)
			{
				return;
			}
			Owned = false;
			if (!GameState.currentlyLoading && GameState.playing && !GameState.sleeping && !Object.op_Implicit((Object)(object)GameState.inBed))
			{
				if (Object.op_Implicit((Object)(object)Refs.charController) && (Object)(object)Refs.charController == character)
				{
					((Collider)Refs.charController).enabled = true;
				}
				if (Object.op_Implicit((Object)(object)Refs.ovrController) && (Object)(object)Refs.ovrController == controller)
				{
					((Behaviour)Refs.ovrController).enabled = true;
				}
				if ((Object)(object)Refs.charController == character && (Object)(object)Refs.ovrController == controller)
				{
					MouseLook.ToggleMouseLook(mouseLook);
					MouseLook.ToggleMouseLookAndCursor(true);
					Cursor.visible = cursorVisible;
					Cursor.lockState = cursorLock;
					if (!BoatCamera.on && Object.op_Implicit((Object)(object)Refs.mouseCrosshair) && (Object)(object)Refs.mouseCrosshair == crosshair)
					{
						Refs.mouseCrosshair.SetActive(crosshairActive);
					}
				}
			}
			character = (controller = (crosshair = null));
		}
	}
	public sealed class CollectionChoice
	{
		public readonly string Id;

		public readonly string Label;

		public readonly bool Selected;

		public CollectionChoice(string id, string label, bool selected)
		{
			Id = id;
			Label = label;
			Selected = selected;
		}
	}
	public sealed class RadioMenus : IDisposable
	{
		private readonly MenuInputLease lease = new MenuInputLease();

		private readonly List<CollectionChoice> choices = new List<CollectionChoice>();

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

		private Vector2 scroll;

		private bool disposed;

		public bool IsOpen => lease.Owned;

		public RadioItemController CollectionRadio { get; private set; }

		public event Action<RadioItemController, string[]> CollectionsChanged;

		public void ShowCollections(RadioItemController radio, IReadOnlyList<CollectionChoice> available)
		{
			//IL_005d: 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)
			if (disposed || !Object.op_Implicit((Object)(object)radio) || radio.State.Kind != 0)
			{
				return;
			}
			if (!IsOpen || !((Object)(object)CollectionRadio == (Object)(object)radio))
			{
				Close();
				radio.ReleaseControls();
				if (!lease.Acquire())
				{
					return;
				}
				selected.Clear();
				scroll = Vector2.zero;
			}
			CollectionRadio = radio;
			choices.Clear();
			if (available == null)
			{
				return;
			}
			foreach (CollectionChoice item in available)
			{
				if (item != null && !string.IsNullOrEmpty(item.Id))
				{
					choices.Add(item);
					if (!selected.ContainsKey(item.Id))
					{
						selected.Add(item.Id, item.Selected);
					}
				}
			}
		}

		public void Tick()
		{
			if (IsOpen)
			{
				if (!MenuInputLease.GameplayAvailable || !Application.isFocused || !GameState.inCursorMenu || Input.GetKeyDown((KeyCode)27))
				{
					Close();
				}
				else if (Object.op_Implicit((Object)(object)CollectionRadio) && (!CollectionRadio.IsPlacedForControls || !CollectionRadio.WithinMenuReach))
				{
					Close();
				}
				else if (!Object.op_Implicit((Object)(object)CollectionRadio))
				{
					Close();
				}
			}
		}

		public void Draw()
		{
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Expected O, but got Unknown
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			if (IsOpen)
			{
				float num = Mathf.Min(440, Screen.width - 24);
				float num2 = Mathf.Min(430, Screen.height - 24);
				GUILayout.Window(194043, new Rect(((float)Screen.width - num) * 0.5f, ((float)Screen.height - num2) * 0.5f, num, num2), new WindowFunction(DrawWindow), "Radio collections", Array.Empty<GUILayoutOption>());
			}
		}

		private void DrawWindow(int id)
		{
			//IL_0021: 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)
			if (Object.op_Implicit((Object)(object)CollectionRadio))
			{
				GUILayout.Label("Choose which music collections this radio plays", Array.Empty<GUILayoutOption>());
				scroll = GUILayout.BeginScrollView(scroll, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height((float)Mathf.Min(280, Screen.height - 160)) });
				if (choices.Count == 0)
				{
					GUILayout.Label("No collections available yet", Array.Empty<GUILayoutOption>());
				}
				foreach (CollectionChoice choice in choices)
				{
					selected[choice.Id] = GUILayout.Toggle(selected[choice.Id], choice.Label ?? choice.Id, Array.Empty<GUILayoutOption>());
				}
				GUILayout.EndScrollView();
				if (GUILayout.Button("Apply", Array.Empty<GUILayoutOption>()))
				{
					RadioItemController collectionRadio = CollectionRadio;
					List<string> list = new List<string>();
					foreach (CollectionChoice choice2 in choices)
					{
						if (selected[choice2.Id] && !list.Contains(choice2.Id))
						{
							list.Add(choice2.Id);
						}
					}
					Close();
					this.CollectionsChanged?.Invoke(collectionRadio, list.ToArray());
				}
			}
			if (GUILayout.Button("Close", Array.Empty<GUILayoutOption>()))
			{
				Close();
			}
		}

		public void Close()
		{
			lease.Release();
			CollectionRadio = null;
			choices.Clear();
			selected.Clear();
		}

		public void Dispose()
		{
			if (!disposed)
			{
				Close();
				disposed = true;
			}
		}
	}
}
namespace SailwindRadio.Shops
{
	internal static class NativeShopContract
	{
		private sealed class Instruction
		{
			internal OpCode Code;

			internal MemberInfo Member;
		}

		internal static bool KeeperReady(ShopArea area)
		{
			Shopkeeper shopkeeper = area.GetShopkeeper();
			if (!Object.op_Implicit((Object)(object)shopkeeper))
			{
				return false;
			}
			FieldInfo? field = typeof(Shopkeeper).GetField("parentRegion", BindingFlags.Instance | BindingFlags.NonPublic);
			FieldInfo field2 = typeof(Shopkeeper).GetField("shop", BindingFlags.Instance | BindingFlags.NonPublic);
			if (field?.GetValue(shopkeeper) is Region)
			{
				return field2?.GetValue(shopkeeper) == area;
			}
			return false;
		}

		internal static bool Supports(MethodInfo sale, MethodInfo sell)
		{
			try
			{
				List<Instruction> list = Read(sell);
				int num = list.FindIndex((Instruction i) => i.Code == OpCodes.Stfld && i.Member?.Name == "sold" && i.Member.DeclaringType == typeof(ShipItem));
				int num2 = list.FindIndex((Instruction i) => i.Member is MethodInfo methodInfo && methodInfo.DeclaringType == typeof(SaveablePrefab) && methodInfo.Name == "RegisterToSave");
				List<Instruction> list2 = Read(sale);
				int num3 = list2.FindIndex((Instruction i) => object.Equals(i.Member, sell));
				int num4 = list2.FindIndex((Instruction i) => i.Member is FieldInfo fieldInfo && fieldInfo.DeclaringType == typeof(PlayerGold) && fieldInfo.Name == "currency");
				int num5 = list2.FindIndex((Instruction i) => i.Code == OpCodes.Stelem_I4 || i.Code == OpCodes.Stind_I4);
				return num >= 0 && num2 > num && num3 >= 0 && num4 > num3 && num5 > num4;
			}
			catch
			{
				return false;
			}
		}

		private static List<Instruction> Read(MethodInfo method)
		{
			byte[] array = method?.GetMethodBody()?.GetILAsByteArray();
			if (array == null)
			{
				throw new InvalidOperationException("Native method body unavailable");
			}
			Dictionary<short, OpCode> dictionary = new Dictionary<short, OpCode>();
			FieldInfo[] fields = typeof(OpCodes).GetFields(BindingFlags.Static | BindingFlags.Public);
			foreach (FieldInfo fieldInfo in fields)
			{
				if (fieldInfo.FieldType == typeof(OpCode))
				{
					OpCode value = (OpCode)fieldInfo.GetValue(null);
					dictionary[value.Value] = value;
				}
			}
			List<Instruction> list = new List<Instruction>();
			int num = 0;
			while (num < array.Length)
			{
				short num2 = array[num++];
				if (num2 == 254)
				{
					num2 = (short)(0xFE00 | array[num++]);
				}
				OpCode code = dictionary[num2];
				Instruction instruction = new Instruction
				{
					Code = code
				};
				int num3;
				switch (code.OperandType)
				{
				case OperandType.InlineNone:
					num3 = 0;
					break;
				case OperandType.ShortInlineBrTarget:
				case OperandType.ShortInlineI:
				case OperandType.ShortInlineVar:
					num3 = 1;
					break;
				case OperandType.InlineVar:
					num3 = 2;
					break;
				case OperandType.InlineI8:
				case OperandType.InlineR:
					num3 = 8;
					break;
				case OperandType.InlineSwitch:
					num3 = 4 + 4 * BitConverter.ToInt32(array, num);
					break;
				default:
					num3 = 4;
					break;
				}
				if (code.OperandType == OperandType.InlineMethod || code.OperandType == OperandType.InlineField)
				{
					instruction.Member = method.Module.ResolveMember(BitConverter.ToInt32(array, num));
				}
				num += num3;
				list.Add(instruction);
			}
			return list;
		}
	}
	internal static class RadioShopCatalog
	{
		internal static readonly int[] StockKinds = new int[7] { 3, 2, 2, 0, 0, 1, 1 };

		internal static int BasePrice(int kind)
		{
			return kind switch
			{
				3 => 2632, 
				2 => 1579, 
				1 => 526, 
				0 => 789, 
				_ => 0, 
			};
		}
	}
	internal static class RadioShopPlacement
	{
		internal static bool TryStand(IslandSceneryScene scenery, out Vector3 position, out Quaternion rotation, out string reason)
		{
			//IL_0001: 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_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: 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_0048: 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_005d: 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_008c: 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_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: 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_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_012d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0208: Unknown result type (might be due to invalid IL or missing references)
			//IL_020d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0193: Unknown result type (might be due to invalid IL or missing references)
			//IL_0199: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ac: 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_0229: Unknown result type (might be due to invalid IL or missing references)
			//IL_022f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0234: Unknown result type (might be due to invalid IL or missing references)
			//IL_0239: Unknown result type (might be due to invalid IL or missing references)
			//IL_023e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0243: Unknown result type (might be due to invalid IL or missing references)
			//IL_0246: Unknown result type (might be due to invalid IL or missing references)
			//IL_026d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0273: Unknown result type (might be due to invalid IL or missing references)
			//IL_0287: Unknown result type (might be due to invalid IL or missing references)
			//IL_028c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0291: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ab: Unknown result type (might be due to invalid IL or missing references)
			position = default(Vector3);
			rotation = Quaternion.identity;
			reason = "not an authored capital scene";
			if (!Object.op_Implicit((Object)(object)scenery) || !RadioStandLayout.TryAnchor(scenery.parentIslandIndex, out var sceneryLocalPosition, out var yaw))
			{
				return false;
			}
			Vector3 val = ((Component)scenery).transform.TransformPoint(sceneryLocalPosition);
			rotation = ((Component)scenery).transform.rotation * Quaternion.Euler(0f, yaw, 0f);
			float height;
			bool flag = Ground(val, out height);
			bool flag2 = (scenery.parentIslandIndex == 1 || scenery.parentIslandIndex == 15) && flag && height <= val.y + 0.02f && height >= val.y - 0.3f;
			float num = ((scenery.parentIslandIndex == 1) ? (-0.1f) : 0f);
			position = new Vector3(val.x, (flag2 ? height : (val.y + 0.02f)) + num, val.z);
			string text = (flag ? "" : "no level static ground at the authored anchor");
			if (flag && !flag2 && Mathf.Abs(height - val.y) > 0.15f)
			{
				text = Append(text, "nearby support height differs from authored height by " + (height - val.y));
			}
			bool flag3 = false;
			float[] array = new float[4] { -1.1f, 1.1f, 1.39f, 2.21f };
			foreach (float num2 in array)
			{
				float[] array2 = new float[2] { -0.39f, 0.39f };
				foreach (float num3 in array2)
				{
					if (!Ground(position + rotation * new Vector3(num2, 0f, num3), out var height2) || Mathf.Abs(height2 - position.y) > 0.045f)
					{
						flag3 = true;
					}
				}
			}
			if (flag3)
			{
				text = Append(text, "uneven or missing ground beneath the display");
			}
			Vector3 envelopeHalf = RadioStandLayout.EnvelopeHalf;
			if (scenery.parentIslandIndex == 1)
			{
				envelopeHalf.x += 0.15f;
			}
			string text2 = Blocker(position + rotation * RadioStandLayout.EnvelopeCenter, envelopeHalf, rotation, null);
			if (text2 != null)
			{
				text = Append(text, "display footprint overlaps " + text2);
			}
			text2 = Blocker(position + rotation * new Vector3(0.55f, 0.91f, -1.02f), new Vector3(1.8f, 0.85f, 0.38f), rotation, null);
			if (text2 != null)
			{
				text = Append(text, "customer approach overlaps " + text2);
			}
			reason = text;
			return true;
		}

		internal static bool SlotClear(RadioShopStand stand, int index, int kind, out string reason)
		{
			//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_002f: 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_003b: 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_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: 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_0073: 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_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_0085: Unknown result type (might be due to invalid IL or missing references)
			IslandSceneryScene componentInParent = ((Component)stand).GetComponentInParent<IslandSceneryScene>();
			Vector3 val = ((Component)stand).transform.TransformPoint(RadioStandLayout.Slot(Object.op_Implicit((Object)(object)componentInParent) ? componentInParent.parentIslandIndex : (-1), index, stand.UsesNativeGoldRockCounter));
			Vector3 half = RadioDevice.Size(kind) * 0.5f + new Vector3(0.02f, 0.008f, 0.025f);
			Quaternion val2 = ((Component)stand).transform.rotation * RadioStandLayout.SlotRotation(kind);
			reason = Blocker(val + val2 * RadioDevice.Center(kind), half, val2, ((Component)stand).transform);
			return true;
		}

		private static string Append(string previous, string message)
		{
			if (previous.Length != 0)
			{
				return previous + "; " + message;
			}
			return message;
		}

		private static bool Ground(Vector3 expected, out float height)
		{
			//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_0012: 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_0070: Unknown result type (mi