using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.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.Audio;
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.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.5.13.0")]
[assembly: AssemblyInformationalVersion("1.5.13")]
[assembly: AssemblyProduct("SailwindRadio")]
[assembly: AssemblyTitle("SailwindRadio")]
[assembly: AssemblyVersion("1.5.13.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 enum DeviceRole
	{
		Radio,
		SmallSpeaker,
		Speaker,
		Woofer
	}
	public static class DeviceKind
	{
		public const int Count = 16;

		public const int Walnut = 0;

		public const int AlAnkh = 1;

		public const int Aestrin = 2;

		public const int Emerald = 3;

		public const int WalnutRadio = 0;

		public const int WalnutSmallSpeaker = 1;

		public const int WalnutSpeaker = 2;

		public const int WalnutWoofer = 3;

		public const int MaximumStack = 6;

		public static bool IsValid(int kind)
		{
			if (kind >= 0)
			{
				return kind < 16;
			}
			return false;
		}

		public static DeviceRole Role(int kind)
		{
			return (DeviceRole)(kind & 3);
		}

		public static int Family(int kind)
		{
			return kind >> 2;
		}

		public static bool IsWalnut(int kind)
		{
			return Family(kind) == 0;
		}

		public static int Of(int family, DeviceRole role)
		{
			return (int)(family * 4 + role);
		}

		public static bool CanStack(int bottom, int top)
		{
			if (IsValid(bottom) && IsValid(top) && Family(bottom) == Family(top) && IsCabinet(bottom))
			{
				if (!IsCabinet(top))
				{
					return Role(top) == DeviceRole.Radio;
				}
				return true;
			}
			return false;
		}

		private static bool IsCabinet(int kind)
		{
			if (Role(kind) != DeviceRole.Speaker)
			{
				return Role(kind) == DeviceRole.Woofer;
			}
			return true;
		}
	}
	[BepInPlugin("local.sailwind.radio", "Sailwind Radio", "1.5.13")]
	[BepInProcess("Sailwind.exe")]
	public sealed class Plugin : BaseUnityPlugin
	{
		public const string Id = "local.sailwind.radio";

		public const string Version = "1.5.13";

		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 ConfigEntry<float> mechanismVolume;

		private ConfigEntry<bool> songHover;

		private ConfigEntry<bool> logDisplayTiming;

		private LibraryScanner library;

		private RadioMenus menus;

		private Task<List<AudioApplication>> applicationList;

		private RadioPlaybackSet<RadioItemController> radios;

		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 onlyLoading;

		private bool Suspended
		{
			get
			{
				if (!Loading)
				{
					return Paused;
				}
				return true;
			}
		}

		private static bool Loading
		{
			get
			{
				if (GameState.playing && !GameState.currentlyLoading)
				{
					return GameState.loadingScenes > 0;
				}
				return true;
			}
		}

		private bool Paused
		{
			get
			{
				if ((!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_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Expected O, but got Unknown
			//IL_013a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0144: Expected O, but got Unknown
			//IL_0197: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a1: 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<float> appVolume = ((BaseUnityPlugin)this).Config.Bind<float>("Audio", "AppVolume", 1f, new ConfigDescription("Volume multiplier for apps playing through a radio, such as Spotify or a browser. 1 plays an app as loud as its own volume allows. Raise it to bring an app up to your music without turning the app itself up. Loud peaks are smoothly limited instead of clipping.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0.1f, 50f), Array.Empty<object>()));
				ApplicationRing.Boost = appVolume.Value;
				appVolume.SettingChanged += delegate
				{
					ApplicationRing.Boost = appVolume.Value;
				};
				BindFalloff("RadioFalloff", "the radio's built-in speaker", RadioSpeakerProfile.BuiltIn);
				BindFalloff("SmallSpeakerFalloff", "Small Speakers", RadioSpeakerProfile.Small);
				BindFalloff("SpeakerFalloff", "Speakers", RadioSpeakerProfile.Normal);
				BindFalloff("WooferFalloff", "Woofers and Turbo Wolfers", RadioSpeakerProfile.TurboWoofer);
				mechanismVolume = ((BaseUnityPlugin)this).Config.Bind<float>("Display", "MechanismVolume", 0.2f, new ConfigDescription("Volume of the regional radio display mechanisms, from silent at 0 to full at 1. Game volume also applies.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 1f), Array.Empty<object>()));
				songHover = ((BaseUnityPlugin)this).Config.Bind<bool>("Display", "ShowSongOnHover", false, "Show the current song's title and artist when looking at a radio.");
				logDisplayTiming = ((BaseUnityPlugin)this).Config.Bind<bool>("Development", "LogDisplayTiming", false, "Log regional display timing, mesh updates and allocations every 10 seconds for performance checks.");
				RemoveRetiredSettings();
				harmony = new Harmony("local.sailwind.radio");
				MediaFoundationSupport.Detect();
				LibraryPaths.MediaFoundationFormats = MediaFoundationSupport.Enabled;
				((BaseUnityPlugin)this).Logger.LogInfo((object)MediaFoundationSupport.Summary);
				ApplicationAudioSupport.Detect(Path.Combine(Paths.ConfigPath, "SailwindRadio.held-volumes.txt"), Warn);
				((BaseUnityPlugin)this).Logger.LogInfo((object)ApplicationAudioSupport.Summary);
				acoustics = new RadioAcousticsService();
				library = new LibraryScanner();
				radios = new RadioPlaybackSet<RadioItemController>((RadioItemController item, RadioState state) => new RadioPlayback((MonoBehaviour)(object)this, state, Warn), AttachEngine, delegate(RadioItemController item)
				{
					if (Object.op_Implicit((Object)(object)item) && item.State.Powered)
					{
						item.TogglePower();
					}
				}, Warn);
				menus = new RadioMenus();
				DisplayTiming.Configure(() => logDisplayTiming.Value, delegate(string message)
				{
					((BaseUnityPlugin)this).Logger.LogInfo((object)message);
				});
				world = new RadioWorldService(harmony, Warn, new DisplaySoundBank(() => mechanismVolume.Value, Warn));
				world.BeforeSave += CapturePositions;
				world.ActionRequested += HandleAction;
				world.RadioReplaced += delegate(RadioItemController from, RadioItemController to)
				{
					radios.Move(from, to);
				};
				shops = new RadioShopService(world, Warn);
				menus.CollectionsChanged += SelectCollections;
				menus.ApplicationChosen += ChooseApplication;
				library.RequestScan(musicFolders.Value);
				InstallSuspendBoundary(typeof(StartMenu), "GameToSettings");
				InstallSuspendBoundary(typeof(Sleep), "FallAsleep");
				ready = true;
				int num = 0;
				string[] array = (musicFolders.Value ?? "").Split(new char[1] { '|' });
				for (int num2 = 0; num2 < array.Length; num2++)
				{
					if (!string.IsNullOrWhiteSpace(array[num2]))
					{
						num++;
					}
				}
				((BaseUnityPlugin)this).Logger.LogInfo((object)((num == 0) ? "Sailwind Radio 1.5.13 ready. Set MusicFolders in the Radio config file to load music." : ("Sailwind Radio 1.5.13 ready with " + num + ((num == 1) ? " music folder." : " music folders."))));
			}
			catch (Exception ex)
			{
				((BaseUnityPlugin)this).Logger.LogError((object)("Radio initialization failed: " + ex));
				Shutdown();
				((Behaviour)this).enabled = false;
			}
		}

		private void BindFalloff(string key, string output, RadioSpeakerProfile profile)
		{
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Expected O, but got Unknown
			ConfigEntry<float> entry = ((BaseUnityPlugin)this).Config.Bind<float>("Audio", key, profile.DefaultRadius, new ConfigDescription("How far " + output + " can be heard, in metres." + ((profile == RadioSpeakerProfile.BuiltIn) ? "" : (" They join a playing radio up to " + 50f + " m away whatever this is set to.")), (AcceptableValueBase)(object)new AcceptableValueRange<float>(5f, 50f), Array.Empty<object>()));
			profile.SetRadius(entry.Value);
			entry.SettingChanged += delegate
			{
				profile.SetRadius(entry.Value);
			};
		}

		private void RemoveRetiredSettings()
		{
			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);
			ConfigEntry<float> val7 = ((BaseUnityPlugin)this).Config.Bind<float>("Display", "PageHoldSeconds", 4f, "Retired page hold setting.");
			((BaseUnityPlugin)this).Config.Remove(((ConfigEntryBase)val7).Definition);
			((BaseUnityPlugin)this).Config.Save();
			if (num)
			{
				Warn("MusicFile has been retired. Set MusicFolders to a folder containing your music.");
			}
		}

		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();
				LibrarySnapshot snapshot = library.Snapshot;
				if (library.Poll())
				{
					foreach (string item in library.Snapshot.WarningsSince(snapshot))
					{
						Warn(item);
					}
					radios.SetSnapshot(library.Snapshot);
					if (Object.op_Implicit((Object)(object)menus.CollectionRadio))
					{
						ShowCollections(menus.CollectionRadio);
					}
				}
				menus.Tick();
				PollApplications();
				bool paused = Paused;
				onlyLoading = !paused && Loading;
				bool suspended = paused || onlyLoading;
				radios.Tick(Time.realtimeSinceStartup, world.ActiveRadioId, (RadioItemController item) => Object.op_Implicit((Object)(object)item) ? item.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 radioItemController = items[i];
				if (Object.op_Implicit((Object)(object)radioItemController) && radioItemController.State.Role == DeviceRole.Radio)
				{
					seen.Add(radioItemController);
					radios.Add(radioItemController, radioItemController.State);
				}
			}
			removed.Clear();
			foreach (RadioItemController key in radios.Keys)
			{
				if (!Object.op_Implicit((Object)(object)key) || !seen.Contains(key))
				{
					removed.Add(key);
				}
			}
			foreach (RadioItemController item in removed)
			{
				radios.Remove(item);
			}
		}

		private void AttachEngine(RadioItemController item, RadioPlayback engine)
		{
			if (!Object.op_Implicit((Object)(object)item))
			{
				return;
			}
			if (engine == null)
			{
				item.CapturePosition = null;
				item.SuspendPlayback = null;
				item.ForgetPlayback();
				return;
			}
			item.CapturePosition = delegate
			{
				radios.Capture(item);
			};
			item.SuspendPlayback = delegate
			{
				radios.Run(item, delegate(RadioPlayback current, RadioQueue queue)
				{
					//IL_0007: Unknown result type (might be due to invalid IL or missing references)
					current.Tick(item.VisualAudioPosition, suspended: true);
				}, rethrow: true);
			};
		}

		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 bool HeardFromHead(DeviceVessel vessel)
		{
			if (acoustics.HeadKnown)
			{
				return DeviceVessels.OnPlayerBoat(vessel);
			}
			return false;
		}

		private bool ShouldMuffle(bool audible, float volume, Vector3 position, RadioSpeakerProfile profile, bool fromHead)
		{
			//IL_0028: 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_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			if (!audible || volume <= 0f || profile == null)
			{
				return false;
			}
			Vector3 val = ((fromHead && acoustics.HeadKnown) ? acoustics.HeadPosition : acoustics.ListenerPosition);
			Vector3 val2 = position - val;
			return ((Vector3)(ref val2)).sqrMagnitude <= profile.Radius * profile.Radius;
		}

		private float Muffling(RadioItemController device, bool audible, float volume, Vector3 position, bool carried, RadioSpeakerProfile profile, bool fromHead)
		{
			//IL_0010: 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)
			if (acoustics.ListenerKnown)
			{
				if (!ShouldMuffle(audible, volume, position, profile, fromHead))
				{
					return acoustics.LastObstruction((Component)(object)device);
				}
				return acoustics.ObstructionAt((Component)(object)device, position, carried, fromHead);
			}
			return 0f;
		}

		private void TickPlayback(RadioItemController item, RadioPlayback engine, RadioQueue queue, bool suspended)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: 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_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)item))
			{
				return;
			}
			DevicePlacement devicePlacement = item.Place();
			Vector3 val = devicePlacement.SoundPosition;
			bool flag = HeardFromHead(devicePlacement.Vessel);
			if (devicePlacement.Carried && acoustics.ListenerKnown)
			{
				val = acoustics.ListenerPosition;
			}
			bool audible = engine.Audible(suspended);
			float obstruction = Muffling(item, audible, item.State.Volume * item.State.LocalVolume, val, devicePlacement.Carried, RadioSpeakerProfile.BuiltIn, flag);
			item.HearFromHead(flag, acoustics.HeadPosition);
			engine.SetAcoustics(flag ? acoustics.HeadPosition : acoustics.ListenerPosition, acoustics.ListenerKnown, obstruction, flag);
			engine.SetCarried(devicePlacement.Carried);
			engine.BeginEndpoints();
			if (item.InstanceId == world.ActiveRadioId && item.State.Powered)
			{
				ConnectSpeakers(devicePlacement.Vessel, engine, devicePlacement.VisualPosition, flag, audible, item.State.Volume);
			}
			engine.EndEndpoints();
			engine.Tick(val, suspended, suspended && !onlyLoading);
			if (!suspended && item.State.Powered && !item.State.Paused)
			{
				bool num;
				if (!engine.LoadFailed)
				{
					if (!engine.TrackEnded)
					{
						goto IL_0186;
					}
					num = queue.TrackEnded();
				}
				else
				{
					num = queue.TrackFailed(engine.FailedPath);
				}
				if (num)
				{
					engine.SetTrack(item.State.TrackPath);
				}
			}
			goto IL_0186;
			IL_0186:
			engine.PreloadTrack((item.InstanceId == world.ActiveRadioId && item.State.Powered) ? queue.PeekNext() : "");
			AudioApplication playingApplication = engine.PlayingApplication;
			if (playingApplication != null)
			{
				MediaControls.Track applicationTrack = engine.ApplicationTrack;
				bool flag2 = applicationTrack != null && applicationTrack.Title.Length > 0;
				item.SetTrackInfo(flag2 ? applicationTrack.Title : playingApplication.Label, flag2 ? applicationTrack.Artist : "", flag2 ? applicationTrack.Album : "", item.State.Powered && songHover.Value);
			}
			else
			{
				TrackInfo trackInfo = library.Snapshot.GetTrackInfo(item.State.TrackPath);
				item.SetTrackInfo(trackInfo.Title, trackInfo.Artist, trackInfo.Album, engine.NamesTrack && songHover.Value);
			}
		}

		private void ConnectSpeakers(DeviceVessel sourceVessel, RadioPlayback engine, Vector3 devicePosition, bool fromHead, bool audible, float masterVolume)
		{
			//IL_0056: 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_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			foreach (RadioItemController item in world.Items)
			{
				if (Object.op_Implicit((Object)(object)item) && item.State.Role != DeviceRole.Radio && item.State.SpeakerEnabled)
				{
					DevicePlacement devicePlacement = item.Place();
					if (DeviceVessels.CanConnect(sourceVessel, devicePlacement.Vessel, devicePosition, devicePlacement.VisualPosition))
					{
						Vector3 position = ((devicePlacement.Carried && acoustics.ListenerKnown) ? acoustics.ListenerPosition : devicePlacement.SoundPosition);
						float num = ((item.State.Role == DeviceRole.Woofer) ? 1f : item.State.Volume);
						float obstruction = Muffling(item, audible, masterVolume * num, position, devicePlacement.Carried, RadioSpeakerProfile.ForKind(item.State.Kind), fromHead);
						engine.SetEndpoint(item.InstanceId, position, devicePlacement.Carried, item.State.Kind, num, item.State.Bass, obstruction);
					}
				}
			}
		}

		private void HandleAction(RadioItemController item, RadioAction action)
		{
			if (!ready || !Object.op_Implicit((Object)(object)item) || item.State.Role != DeviceRole.Radio)
			{
				return;
			}
			if (action == RadioAction.Power)
			{
				if (item.State.Powered)
				{
					library.RequestScan(musicFolders.Value);
				}
			}
			else if (action == RadioAction.Collections)
			{
				ShowCollections(item);
				ListApplications(item);
			}
			else
			{
				if (action == RadioAction.PlayPause && !item.State.Powered)
				{
					return;
				}
				radios.Run(item, delegate(RadioPlayback engine, RadioQueue queue)
				{
					bool flag = false;
					bool flag2 = engine.PlayingApplication != null;
					switch (action)
					{
					case RadioAction.PlayPause:
						if (!flag2 || item.State.Paused || !engine.SendToApplication(MediaControls.Command.PlayPause))
						{
							engine.CapturePosition();
							item.State.Paused = !item.State.Paused;
							if (item.State.Paused)
							{
								item.SuspendPlayback?.Invoke();
							}
						}
						break;
					case RadioAction.Previous:
						if (flag2)
						{
							engine.SendToApplication(MediaControls.Command.Previous);
						}
						else
						{
							flag = queue.Previous();
						}
						break;
					case RadioAction.Next:
						if (flag2)
						{
							engine.SendToApplication(MediaControls.Command.Next);
						}
						else
						{
							flag = queue.Next();
						}
						break;
					case RadioAction.Shuffle:
						flag = queue.SetShuffle(!item.State.Shuffle);
						break;
					}
					if (flag)
					{
						engine.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))
			{
				return;
			}
			radios.Run(item, delegate(RadioPlayback engine, RadioQueue queue)
			{
				if (queue.SetCollections(library.Snapshot, selected))
				{
					engine.SetTrack(item.State.TrackPath);
				}
			});
		}

		private void ListApplications(RadioItemController item)
		{
			if (!ApplicationAudioSupport.Enabled)
			{
				menus.ShowApplications(PlayingApplication(item), null, ApplicationAudioSupport.Summary);
				return;
			}
			menus.ShowApplications(PlayingApplication(item), null, "Looking for applications playing sound");
			if (applicationList != null)
			{
				return;
			}
			applicationList = Task.Run(delegate
			{
				using (new ComCalls.Apartment())
				{
					return AudioApplications.List();
				}
			});
		}

		private void PollApplications()
		{
			if (applicationList == null || !applicationList.IsCompleted)
			{
				return;
			}
			Task<List<AudioApplication>> task = applicationList;
			applicationList = null;
			RadioItemController collectionRadio = menus.CollectionRadio;
			if (task.IsFaulted)
			{
				Warn("Could not list applications: " + task.Exception.GetBaseException().Message);
				if (Object.op_Implicit((Object)(object)collectionRadio))
				{
					menus.ShowApplications(PlayingApplication(collectionRadio), null, "Could not list applications");
				}
			}
			else if (Object.op_Implicit((Object)(object)collectionRadio))
			{
				menus.ShowApplications(PlayingApplication(collectionRadio), task.Result, (task.Result.Count == 0) ? "No other application is playing sound. Start your music app and open this menu again." : null);
			}
		}

		private AudioApplication PlayingApplication(RadioItemController item)
		{
			AudioApplication playing = null;
			radios.Run(item, delegate(RadioPlayback engine, RadioQueue queue)
			{
				playing = engine.PlayingApplication;
			});
			return playing;
		}

		private void ChooseApplication(RadioItemController item, AudioApplication application)
		{
			if (Object.op_Implicit((Object)(object)item))
			{
				radios.Run(item, delegate(RadioPlayback engine, RadioQueue queue)
				{
					engine.SetApplication(application);
				});
			}
		}

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

		private void CapturePositions()
		{
			radios?.ForEachEngine(delegate(RadioItemController item, RadioPlayback engine)
			{
				engine.CapturePosition();
			}, "Could not capture a radio position");
		}

		private void SuspendNow()
		{
			bool paused = Paused;
			radios?.ForEachEngine(delegate(RadioItemController item, RadioPlayback engine)
			{
				//IL_000a: Unknown result type (might be due to invalid IL or missing references)
				if (Object.op_Implicit((Object)(object)item))
				{
					engine.Tick(item.VisualAudioPosition, suspended: true, paused);
				}
			}, "Could not suspend a radio");
		}

		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();
			radios?.Clear();
			library?.Dispose();
			library = null;
			menus?.Dispose();
			menus = null;
			try
			{
				shops?.Dispose();
			}
			catch (Exception ex)
			{
				Warn("Could not release radio shops: " + ex.Message);
			}
			shops = null;
			try
			{
				world?.Dispose();
			}
			catch (Exception ex2)
			{
				Warn("Could not release radio item hooks: " + ex2.Message);
			}
			world = null;
			acoustics?.Dispose();
			acoustics = null;
			try
			{
				Harmony obj = harmony;
				if (obj != null)
				{
					obj.UnpatchSelf();
				}
			}
			catch (Exception ex3)
			{
				Warn("Could not remove radio hooks: " + ex3.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;

		public RadioState Stacked;

		public DeviceRole Role => DeviceKind.Role(Kind);

		public List<RadioState> Above()
		{
			List<RadioState> list = new List<RadioState>();
			for (RadioState stacked = Stacked; stacked != null; stacked = stacked.Stacked)
			{
				list.Add(stacked);
			}
			return list;
		}

		public static RadioState NewDevice(int kind)
		{
			return new RadioState
			{
				Kind = kind,
				Volume = ((DeviceKind.Role(kind) == DeviceRole.Radio) ? 0.5f : 0.75f),
				TrackPath = ""
			};
		}
	}
}
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 readonly List<AudioApplication> applications = new List<AudioApplication>();

		private AudioApplication playing;

		private string applicationNote;

		private Vector2 scroll;

		private bool disposed;

		public bool IsOpen => lease.Owned;

		public RadioItemController CollectionRadio { get; private set; }

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

		public event Action<RadioItemController, AudioApplication> ApplicationChosen;

		public void ShowApplications(AudioApplication current, IReadOnlyList<AudioApplication> available, string note)
		{
			playing = current;
			applicationNote = note;
			applications.Clear();
			if (available != null)
			{
				applications.AddRange(available);
			}
		}

		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.Role != DeviceRole.Radio)
			{
				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.EnsureOwned() || !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(520, 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 music", 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(370, 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>());
				}
				DrawApplications();
				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();
			}
		}

		private void DrawApplications()
		{
			GUILayout.Space(12f);
			GUILayout.Label((playing != null) ? ("Playing " + playing.Label + " through the radio") : "Or play an application through the radio", Array.Empty<GUILayoutOption>());
			bool flag = playing != null && GUILayout.Button("Back to music", Array.Empty<GUILayoutOption>());
			AudioApplication arg = null;
			if (applicationNote != null)
			{
				GUILayout.Label(applicationNote, Array.Empty<GUILayoutOption>());
			}
			foreach (AudioApplication application in applications)
			{
				if (!application.Same(playing) && GUILayout.Button(application.Label, Array.Empty<GUILayoutOption>()))
				{
					flag = true;
					arg = application;
				}
			}
			if (flag)
			{
				RadioItemController collectionRadio = CollectionRadio;
				Close();
				this.ApplicationChosen?.Invoke(collectionRadio, arg);
			}
		}

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

		public void Dispose()
		{
			if (!disposed)
			{
				Close();
				disposed = true;
			}
		}
	}
}
namespace SailwindRadio.Shops
{
	internal static class NativeShopContract
	{
		internal static readonly FieldInfo KeeperRegion = typeof(Shopkeeper).GetField("parentRegion", BindingFlags.Instance | BindingFlags.NonPublic);

		internal static readonly FieldInfo KeeperEconomy = typeof(Shopkeeper).GetField("economy", BindingFlags.Instance | BindingFlags.NonPublic);

		internal static readonly FieldInfo KeeperHome = typeof(Shopkeeper).GetField("homePos", BindingFlags.Instance | BindingFlags.NonPublic);

		internal static readonly FieldInfo KeeperShop = typeof(Shopkeeper).GetField("shop", BindingFlags.Instance | BindingFlags.NonPublic);

		internal static readonly FieldInfo AreaKeeper = typeof(ShopArea).GetField("keeper", BindingFlags.Instance | BindingFlags.NonPublic);

		internal static bool KeeperReady(ShopArea area)
		{
			Shopkeeper shopkeeper = area.GetShopkeeper();
			if (!Object.op_Implicit((Object)(object)shopkeeper))
			{
				return false;
			}
			if (KeeperRegion?.GetValue(shopkeeper) is Region)
			{
				return KeeperShop?.GetValue(shopkeeper) == area;
			}
			return false;
		}
	}
	internal static class RadioShopCatalog
	{
		internal static readonly DeviceRole[] StockRoles = new DeviceRole[7]
		{
			DeviceRole.Woofer,
			DeviceRole.Speaker,
			DeviceRole.Speaker,
			DeviceRole.Radio,
			DeviceRole.Radio,
			DeviceRole.SmallSpeaker,
			DeviceRole.SmallSpeaker
		};

		internal static int StallFamily(int island)
		{
			if (!RadioStalls.TryGet(island, out var stall))
			{
				return 0;
			}
			return stall.Family;
		}

		internal static int StockKind(int island, int slot)
		{
			return DeviceKind.Of(StallFamily(island), StockRoles[slot]);
		}

		internal static int BasePrice(int kind)
		{
			if (!DeviceKind.IsValid(kind))
			{
				return 0;
			}
			return DeviceKind.Role(kind) switch
			{
				DeviceRole.Speaker => 1579, 
				DeviceRole.SmallSpeaker => 526, 
				DeviceRole.Radio => 789, 
				_ => 2632, 
			};
		}
	}
	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_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: 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_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_0173: Unknown result type (might be due to invalid IL or missing references)
			//IL_0179: Unknown result type (might be due to invalid IL or missing references)
			//IL_0187: Unknown result type (might be due to invalid IL or missing references)
			//IL_018c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0191: 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_020e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0213: Unknown result type (might be due to invalid IL or missing references)
			//IL_0218: Unknown result type (might be due to invalid IL or missing references)
			//IL_021d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0222: Unknown result type (might be due to invalid IL or missing references)
			//IL_0225: Unknown result type (might be due to invalid IL or missing references)
			//IL_024b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0251: Unknown result type (might be due to invalid IL or missing references)
			//IL_0265: Unknown result type (might be due to invalid IL or missing references)
			//IL_026a: Unknown result type (might be due to invalid IL or missing references)
			//IL_026f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0283: Unknown result type (might be due to invalid IL or missing references)
			//IL_0289: 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) || !RadioStalls.TryGet(scenery.parentIslandIndex, out var stall))
			{
				return false;
			}
			Vector3 val = ((Component)scenery).transform.TransformPoint(stall.SceneryAnchor);
			rotation = ((Component)scenery).transform.rotation * Quaternion.Euler(0f, stall.Yaw, 0f);
			float height;
			bool flag = Ground(val, out height);
			bool flag2 = stall.SettlesOnSupport && flag && height <= val.y + 0.02f && height >= val.y - 0.3f;
			position = new Vector3(val.x, (flag2 ? height : (val.y + 0.02f)) + stall.GroundVisualOffset, 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 num in array)
			{
				float[] array2 = new float[2] { -0.39f, 0.39f };
				foreach (float num2 in array2)
				{
					if (!Ground(position + rotation * new Vector3(num, 0f, num2), 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 (stall.WideCounter)
			{
				envelopeHalf.x += 0.15f;
			}
			string text2 = Blocker(position + rotation * RadioStandLayout.EnvelopeCenter, envelopeHalf, rotation);
			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);
			if (text2 != null)
			{
				text = Append(text, "customer approach overlaps " + text2);
			}
			reason = text;
			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 (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			height = 0f;
			RaycastHit val = default(RaycastHit);
			if (!Physics.Raycast(expected + Vector3.up, Vector3.down, ref val, 3f, -1, (QueryTriggerInteraction)1) || !Object.op_Implicit((Object)(object)((RaycastHit)(ref val)).collider) || ((RaycastHit)(ref val)).normal.y < 0.5f || Object.op_Implicit((Object)(object)((RaycastHit)(ref val)).collider.attachedRigidbody) || Object.op_Implicit((Object)(object)((Component)((RaycastHit)(ref val)).collider).GetComponentInParent<ShipItem>()) || Mathf.Abs(((RaycastHit)(ref val)).point.y - expected.y) > 1.5f)
			{
				return false;
			}
			height = ((RaycastHit)(ref val)).point.y;
			return true;
		}

		private static string Blocker(Vector3 center, Vector3 half, Quaternion rotation)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			Collider[] array = Physics.OverlapBox(center, half, rotation, -1, (QueryTriggerInteraction)2);
			foreach (Collider val in array)
			{
				if (Object.op_Implicit((Object)(object)val) && val.enabled && (!val.isTrigger || Object.op_Implicit((Object)(object)((Component)val).GetComponentInParent<ShipItem>())))
				{
					return ((Object)val).name;
				}
			}
			return null;
		}
	}
	internal sealed class RadioShopService : IDisposable
	{
		private sealed class Slot
		{
			internal int Kind;

			internal int Index;

			internal ShopRestock Clock = new ShopRestock();

			internal GameObject Anchor;

			internal RadioShopStock Stock;
		}

		private sealed class Vendor
		{
			internal IslandSceneryScene Scenery;

			internal ShopArea Area;

			internal Slot[] Slots;

			internal RadioShopStand Stand;

			internal GameObject OwnedNpc;

			internal Shopkeeper Template;

			internal Collider[] MerchantTriggers;

			internal bool DisplayShown;

			internal bool InitialStockAttempted;

			internal float StageReadyAt = -1f;

			internal float NextStockAttempt;

			internal float NextBuildAttempt;

			internal bool FoundWhileStarting;

			internal readonly HashSet<string> ReportedReasons = new HashSet<string>();
		}

		private static RadioShopService active;

		private readonly RadioWorldService world;

		private readonly Action<string> warn;

		private readonly Harmony harmony = new Harmony("local.sailwind.radio.shops");

		private readonly List<Vendor> vendors = new List<Vendor>();

		private SaveLoadManager session;

		private const float SafetyScanSeconds = 30f;

		private const float BuildRetrySeconds = 0.5f;

		private const float InPlaceDistance = 0.03f;

		private const float NativeStockDistance = 500f;

		private bool sessionScanned;

		private float nextSafetyScan;

		private bool disposed;

		private bool supported;

		internal RadioShopService(RadioWorldService world, Action<string> warn)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Expected O, but got Unknown
			//IL_0135: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: Expected O, but got Unknown
			//IL_015b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0169: Expected O, but got Unknown
			//IL_01cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01da: Expected O, but got Unknown
			//IL_01f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0200: Expected O, but got Unknown
			if (active != null)
			{
				throw new InvalidOperationException("Radio shops already active");
			}
			this.world = world;
			this.warn = warn ?? ((Action<string>)delegate
			{
			});
			active = this;
			SceneManager.sceneLoaded += SceneLoaded;
			try
			{
				MethodInfo method = typeof(ShipItem).GetMethod("EnterBoat", BindingFlags.Instance | BindingFlags.NonPublic, null, new Type[1] { typeof(Collider) }, null);
				MethodInfo method2 = typeof(Shopkeeper).GetMethod("GetPrice", BindingFlags.Instance | BindingFlags.NonPublic, null, new Type[1] { typeof(ShipItem) }, null);
				if (method == null || method2 == null || method.ReturnType != typeof(void) || method2.ReturnType != typeof(int))
				{
					throw new MissingMethodException("Native shop purchase methods changed");
				}
				harmony.Patch((MethodBase)method, new HarmonyMethod(typeof(RadioShopService), "BeforeEnterBoat", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				harmony.Patch((MethodBase)method2, new HarmonyMethod(typeof(RadioShopService), "BeforePrice", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				MethodInfo method3 = typeof(ShopArea).GetMethod("OnTriggerEnter", BindingFlags.Instance | BindingFlags.NonPublic);
				MethodInfo method4 = typeof(Shopkeeper).GetMethod("OnTriggerEnter", BindingFlags.Instance | BindingFlags.NonPublic);
				if (method3 == null || method4 == null)
				{
					throw new MissingMethodException("Native shop trigger methods changed");
				}
				harmony.Patch((MethodBase)method3, new HarmonyMethod(typeof(RadioShopService), "BeforeAreaEnter", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				harmony.Patch((MethodBase)method4, new HarmonyMethod(typeof(RadioShopService), "BeforeKeeperEnter", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				supported = true;
			}
			catch (Exception ex)
			{
				harmony.UnpatchSelf();
				this.warn("Radio shop stock unavailable: " + ex.Message);
			}
		}

		internal void Tick()
		{
			if (disposed)
			{
				return;
			}
			if ((Object)(object)session != (Object)(object)SaveLoadManager.instance || GameState.currentlyLoading)
			{
				Clear();
				session = SaveLoadManager.instance;
			}
			if (GameState.currentlyLoading || !Object.op_Implicit((Object)(object)session) || !GameState.playing || GameState.loadingScenes > 0)
			{
				return;
			}
			if (!sessionScanned || Time.unscaledTime >= nextSafetyScan)
			{
				ScanScenery();
			}
			for (int num = vendors.Count - 1; num >= 0; num--)
			{
				Vendor vendor = vendors[num];
				if (!Object.op_Implicit((Object)(object)vendor.Scenery))
				{
					Clear(vendor);
					vendors.RemoveAt(num);
				}
				else
				{
					if (world.ReadyToStageShop && vendor.StageReadyAt < 0f)
					{
						vendor.StageReadyAt = Time.unscaledTime;
					}
					if (!Object.op_Implicit((Object)(object)vendor.Stand) || !Object.op_Implicit((Object)(object)vendor.Area))
					{
						Build(vendor);
					}
					if (Object.op_Implicit((Object)(object)vendor.Stand) && Object.op_Implicit((Object)(object)vendor.Area) && (world.ReadyToStageShop || !vendor.DisplayShown))
					{
						Update(vendor);
					}
				}
			}
		}

		private void SceneLoaded(Scene scene, LoadSceneMode mode)
		{
			if (disposed)
			{
				return;
			}
			GameObject[] rootGameObjects = ((Scene)(ref scene)).GetRootGameObjects();
			foreach (GameObject val in rootGameObjects)
			{
				if (Object.op_Implicit((Object)(object)val))
				{
					IslandSceneryScene[] componentsInChildren = val.GetComponentsInChildren<IslandSceneryScene>();
					foreach (IslandSceneryScene scenery in componentsInChildren)
					{
						ObserveScenery(scenery);
					}
				}
			}
		}

		private void ScanScenery()
		{
			sessionScanned = true;
			nextSafetyScan = Time.unscaledTime + 30f;
			IslandSceneryScene[] array = Object.FindObjectsOfType<IslandSceneryScene>();
			foreach (IslandSceneryScene scenery in array)
			{
				ObserveScenery(scenery);
			}
		}

		private void ObserveScenery(IslandSceneryScene scenery)
		{
			if (!Object.op_Implicit((Object)(object)scenery) || !RadioStandLayout.TryAnchor(scenery.parentIslandIndex, out var _, out var _))
			{
				return;
			}
			foreach (Vendor vendor2 in vendors)
			{
				if ((Object)(object)vendor2.Scenery == (Object)(object)scenery)
				{
					return;
				}
			}
			Vendor vendor = new Vendor
			{
				Scenery = scenery,
				Slots = new Slot[RadioShopCatalog.StockRoles.Length],
				FoundWhileStarting = GameState.justStarted
			};
			for (int i = 0; i < vendor.Slots.Length; i++)
			{
				vendor.Slots[i] = new Slot
				{
					Kind = RadioShopCatalog.StockKind(scenery.parentIslandIndex, i),
					Index = i
				};
			}
			vendors.Add(vendor);
		}

		private void Build(Vendor vendor)
		{
			if (!(Time.unscaledTime < vendor.NextBuildAttempt))
			{
				vendor.NextBuildAttempt = Time.unscaledTime + 0.5f;
				if (Object.op_Implicit((Object)(object)vendor.Stand))
				{
					TryMerchant(vendor);
				}
				else if (InPlace(vendor.Scenery))
				{
					TryDisplay(vendor);
				}
			}
		}

		private static bool InPlace(IslandSceneryScene scenery)
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			Transform[] islands = Refs.islands;
			int parentIslandIndex = scenery.parentIslandIndex;
			if (islands == null || parentIslandIndex < 0 || parentIslandIndex >= islands.Length || !Object.op_Implicit((Object)(object)islands[parentIslandIndex]))
			{
				return false;
			}
			Vector3 val = ((Component)scenery).transform.position - islands[parentIslandIndex].position;
			return ((Vector3)(ref val)).sqrMagnitude < 0.0009f;
		}

		private void Update(Vendor vendor)
		{
			//IL_01b2: Unknown result type (might be due to invalid IL or missing references)
			if (vendor.MerchantTriggers != null)
			{
				Collider[] merchantTriggers = vendor.MerchantTriggers;
				foreach (Collider val in merchantTriggers)
				{
					if (Object.op_Implicit((Object)(object)val) && val.enabled)
					{
						val.enabled = false;
					}
				}
			}
			bool flag = world.ReadyToStageShop && ReadyToStock(vendor);
			bool flag2 = ((Component)vendor.Area.GetShopkeeper()).gameObject.activeInHierarchy && (vendor.Area.openAtNight || (Object.op_Implicit((Object)(object)Sun.sun) && Sun.sun.localTime >= 7f && Sun.sun.localTime <= 18f));
			bool saleReady = SaleReady(vendor, flag2);
			bool flag3 = false;
			Slot[] slots = vendor.Slots;
			foreach (Slot slot in slots)
			{
				slot.Clock.Tick(Time.deltaTime);
				if (slot.Clock.Occupied && (!Object.op_Implicit((Object)(object)slot.Stock) || slot.Stock.Purchased || ((Component)slot.Stock).GetComponent<ShipItem>().sold))
				{
					slot.Clock.Removed();
					slot.Stock = null;
					if (Object.op_Implicit((Object)(object)slot.Anchor))
					{
						Object.Destroy((Object)(object)slot.Anchor);
					}
					slot.Anchor = null;
				}
				if (Object.op_Implicit((Object)(object)slot.Stock))
				{
					ProtectStock(slot.Stock);
					((Component)slot.Stock).gameObject.SetActive(StockVisible(vendor, slot.Stock, flag2, saleReady));
				}
				else if (flag && slot.Clock.Ready && SpawnsHere(vendor, SlotPosition(vendor, slot)) && (!vendor.InitialStockAttempted || !(Time.unscaledTime < vendor.NextStockAttempt)))
				{
					flag3 = true;
					TryStock(vendor, slot);
				}
			}
			if (flag3)
			{
				vendor.InitialStockAttempted = true;
				vendor.NextStockAttempt = Time.unscaledTime + 5f;
			}
			if (!vendor.DisplayShown && (flag || (vendor.StageReadyAt >= 0f && Time.unscaledTime - vendor.StageReadyAt >= 5f)))
			{
				vendor.DisplayShown = true;
				vendor.Stand.SetVisible(visible: true);
				SetNpcVisible(vendor.OwnedNpc, visible: true);
				SphereCollider val2 = (Object.op_Implicit((Object)(object)vendor.OwnedNpc) ? vendor.OwnedNpc.GetComponent<SphereCollider>() : null);
				if (Object.op_Implicit((Object)(object)val2))
				{
					((Collider)val2).enabled = true;
				}
				saleReady = SaleReady(vendor, flag2);
			}
			else if (!vendor.DisplayShown || !flag2)
			{
				return;
			}
			slots = vendor.Slots;
			foreach (Slot slot2 in slots)
			{
				if (Object.op_Implicit((Object)(object)slot2.Stock))
				{
					((Component)slot2.Stock).gameObject.SetActive(StockVisible(vendor, slot2.Stock, flag2, saleReady));
				}
			}
		}

		private bool SaleReady(Vendor vendor, bool open)
		{
			if (open && vendor.DisplayShown && world.ReadyForShop)
			{
				return PurchaseEnvironmentReady(vendor);
			}
			return false;
		}

		private static bool StockVisible(Vendor vendor, RadioShopStock stock, bool open, bool saleReady)
		{
			if (!saleReady)
			{
				if (open && vendor.DisplayShown)
				{
					return KeepStockActive(stock);
				}
				return false;
			}
			return true;
		}

		private void TryDisplay(Vendor vendor)
		{
			//IL_0029: 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)
			if (!RadioShopPlacement.TryStand(vendor.Scenery, out var position, out var rotation, out var reason))
			{
				ReportSetupFailure(vendor, reason);
				return;
			}
			try
			{
				vendor.Stand = RadioShopStand.Create(((Component)vendor.Scenery).transform, position, rotation, vendor.Scenery.parentIslandIndex);
				vendor.Stand.SetVisible(visible: false);
				Physics.SyncTransforms();
				TryMerchant(vendor);
			}
			catch (Exception ex)
			{
				Clear(vendor);
				for (int i = 0; i < vendor.Slots.Length; i++)
				{
					vendor.Slots[i] = new Slot
					{
						Kind = RadioShopCatalog.StockKind(vendor.Scenery.parentIslandIndex, i),
						Index = i
					};
				}
				ReportSetupFailure(vendor, ex.Message);
			}
		}

		private void TryMerchant(Vendor vendor)
		{
			try
			{
				CreateMerchant(vendor);
			}
			catch (Exception ex)
			{
				if (Object.op_Implicit((Object)(object)vendor.Area))
				{
					Object.Destroy((Object)(object)((Component)vendor.Area).gameObject);
				}
				if (Object.op_Implicit((Object)(object)vendor.OwnedNpc))
				{
					Object.Destroy((Object)(object)vendor.OwnedNpc);
				}
				vendor.Area = null;
				vendor.OwnedNpc = null;
				vendor.MerchantTriggers = null;
				if (Object.op_Implicit((Object)(object)vendor.Stand) && vendor.StageReadyAt >= 0f && Time.unscaledTime - vendor.StageReadyAt >= 10f)
				{
					vendor.DisplayShown = true;
					vendor.Stand.SetVisible(visible: true);
					if (Time.unscaledTime - vendor.StageReadyAt >= 60f)
					{
						ReportSetupFailure(vendor, "its merchant is unavailable (" + ex.Message + ")");
					}
				}
			}
		}

		private static void CreateMerchant(Vendor vendor)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0196: Unknown result type (might be due to invalid IL or missing references)
			//IL_019c: Expected O, but got Unknown
			//IL_01c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01db: Unknown result type (might be due to invalid IL or missing references)
			//IL_0215: Unknown result type (might be due to invalid IL or missing references)
			//IL_022e: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = null;
			GameObject val2 = null;
			try
			{
				Shopkeeper val3 = FindNativeMerchant(vendor.Scenery, ((Component)vendor.Stand).transform.position);
				if (!Object.op_Implicit((Object)(object)val3))
				{
					throw new MissingComponentException("native shopkeeper template is not loaded yet");
				}
				val2 = Object.Instantiate<GameObject>(((Component)val3).gameObject, ((Component)vendor.Scenery).transform);
				val2.SetActive(false);
				((Object)val2).name = "Radio shopkeeper";
				val2.transform.position = ((Component)vendor.Stand).transform.TransformPoint(RadioStandLayout.MerchantOffset);
				val2.transform.rotation = ((Component)vendor.Stand).transform.rotation * Quaternion.Euler(0f, 180f, 0f);
				Shopkeeper component = val2.GetComponent<Shopkeeper>();
				if (!Object.op_Implicit((Object)(object)component))
				{
					throw new MissingComponentException("native shopkeeper clone lost Shopkeeper");
				}
				vendor.MerchantTriggers = ConfigureMerchantTriggers(val2, vendor.Scenery.parentIslandIndex);
				SphereCollider component2 = val2.GetComponent<SphereCollider>();
				if (Object.op_Implicit((Object)(object)component2))
				{
					((Collider)component2).enabled = vendor.DisplayShown;
				}
				FieldInfo keeperHome = NativeShopContract.KeeperHome;
				if (keeperHome == null || keeperHome.FieldType != typeof(Transform))
				{
					throw new MissingFieldException("Shopkeeper.homePos changed");
				}
				keeperHome.SetValue(component, val2.transform);
				FieldInfo keeperRegion = NativeShopContract.KeeperRegion;
				if (keeperRegion == null || keeperRegion.FieldType != typeof(Region))
				{
					throw new MissingFieldException("Shopkeeper.parentRegion changed");
				}
				object? value = keeperRegion.GetValue(val3);
				keeperRegion.SetValue(component, (value is Region) ? value : null);
				vendor.Template = val3;
				val = new GameObject("Radio merchant area");
				val.SetActive(false);
				val.transform.SetParent(((Component)vendor.Stand).transform, false);
				val.transform.localPosition = Vector3.zero;
				val.transform.position = ((Component)vendor.Stand).transform.position;
				Rigidbody obj = val.AddComponent<Rigidbody>();
				obj.isKinematic = true;
				obj.useGravity = false;
				BoxCollider obj2 = val.AddComponent<BoxCollider>();
				((Collider)obj2).isTrigger = true;
				obj2.center = new Vector3(0f, 1.15f, 0f);
				obj2.size = new Vector3(2.65f, 2.3f, 1.5f);
				ShopArea val4 = val.AddComponent<ShopArea>();
				FieldInfo areaKeeper = NativeShopContract.AreaKeeper;
				if (areaKeeper == null || areaKeeper.FieldType != typeof(Shopkeeper))
				{
					throw new MissingFieldException("ShopArea.keeper changed");
				}
				areaKeeper.SetValue(val4, component);
				component.RegisterShop(val4);
				val4.itemsForSale = new List<ShipItem>();
				vendor.Area = val4;
				vendor.OwnedNpc = val2;
				SetNpcVisible(val2, vendor.DisplayShown);
				val2.SetActive(true);
				val.SetActive(true);
			}
			catch
			{
				if (Object.op_Implicit((Object)(object)val))
				{
					Object.Destroy((Object)(object)val);
				}
				if (Object.op_Implicit((Object)(object)val2))
				{
					Object.Destroy((Object)(object)val2);
				}
				throw;
			}
		}

		private static void SetNpcVisible(GameObject npc, bool visible)
		{
			if (Object.op_Implicit((Object)(object)npc))
			{
				Renderer[] componentsInChildren = npc.GetComponentsInChildren<Renderer>(true);
				for (int i = 0; i < componentsInChildren.Length; i++)
				{
					componentsInChildren[i].enabled = visible;
				}
			}
		}

		private static Collider[] ConfigureMerchantTriggers(GameObject npc, int islandIndex)
		{
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			List<Collider> list = new List<Collider>();
			bool flag = false;
			RadioStall stall;
			float num = (RadioStalls.TryGet(islandIndex, out stall) ? stall.SaleRadius : 1.75f);
			Collider[] componentsInChildren = npc.GetComponentsInChildren<Collider>(true);
			foreach (Collider val in componentsInChildren)
			{
				if (!val.isTrigger)
				{
					continue;
				}
				if ((Object)(object)((Component)val).transform == (Object)(object)npc.transform)
				{
					SphereCollider val2 = (SphereCollider)(object)((val is SphereCollider) ? val : null);
					if (val2 != null && !flag)
					{
						val2.radius = Mathf.Min(val2.radius, num);
						flag = true;
						continue;
					}
				}
				val.enabled = false;
				list.Add(val);
			}
			if (!flag)
			{
				throw new MissingComponentException("native shopkeeper root sale trigger contract changed");
			}
			return list.ToArray();
		}

		private static Shopkeeper FindNativeMerchant(IslandSceneryScene scenery, Vector3 standPosition)
		{
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			Shopkeeper result = null;
			float num = 30f;
			Shopkeeper[] componentsInChildren = ((Component)scenery).GetComponentsInChildren<Shopkeeper>(true);
			foreach (Shopkeeper val in componentsInChildren)
			{
				if (Object.op_Implicit((Object)(object)val) && (Object)(object)((Component)val).transform.parent == (Object)(object)((Component)scenery).transform && NativeKeeperName(((Object)val).name) && Object.op_Implicit((Object)(object)((Component)val).GetComponent<Renderer>()))
				{
					float num2 = Vector3.Distance(standPosition, ((Component)val).transform.position);
					if (num2 < num)
					{
						result = val;
						num = num2;
					}
				}
			}
			return result;
		}

		private static bool NativeKeeperName(string name)
		{
			if (string.Equals(name, "shopkeeper", StringComparison.OrdinalIgnoreCase))
			{
				return true;
			}
			int result;
			if (name != null && name.StartsWith("shopkeeper (", StringComparison.OrdinalIgnoreCase) && name.EndsWith(")", StringComparison.Ordinal))
			{
				return int.TryParse(name.Substring("shopkeeper (".Length, name.Length - "shopkeeper (".Length - 1), out result);
			}
			return false;
		}

		private void ReportSetupFailure(Vendor vendor, string reason)
		{
			if (vendor.ReportedReasons.Add(reason))
			{
				warn("Radio shop at " + ((Object)vendor.Scenery).name + " could not be set up: " + reason);
			}
		}

		private static Vector3 SlotPosition(Vendor vendor, Slot slot)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			return ((Component)vendor.Stand).transform.TransformPoint(RadioStandLayout.Slot(vendor.Scenery.parentIslandIndex, slot.Index, vendor.Stand.UsesNativeGoldRockCounter));
		}

		private static bool SpawnsHere(Vendor vendor, Vector3 position)
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			if (!GameState.justStarted && (!vendor.FoundWhileStarting || vendor.InitialStockAttempted))
			{
				if (Object.op_Implicit((Object)(object)Camera.main))
				{
					return Vector3.Distance(((Component)Camera.main).transform.position, position) < 500f;
				}
				return false;
			}
			return true;
		}

		private void TryStock(Vendor vendor, Slot slot)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Expected O, but got Unknown
			//IL_0056: 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_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			if (!ReadyToStock(vendor))
			{
				return;
			}
			Vector3 position = SlotPosition(vendor, slot);
			Quaternion rotation = ((Component)vendor.Stand).transform.rotation;
			GameObject val = null;
			RadioItemController radioItemController = null;
			try
			{
				val = new GameObject("Radio shop stock anchor");
				val.SetActive(false);
				val.transform.SetParent(((Component)vendor.Stand).transform, false);
				val.transform.position = position;
				val.transform.rotation = rotation;
				Vector3 lossyScale = val.transform.parent.lossyScale;
				val.transform.localScale = new Vector3(1f / lossyScale.x, 1f / lossyScale.y, 1f / lossyScale.z);
				ShopItemSpawner obj = val.AddComponent<ShopItemSpawner>();
				((Behaviour)obj).enabled = false;
				obj.priceMult = 1f;
				MeshRenderer component = val.GetComponent<MeshRenderer>();
				if (!Object.op_Implicit((Object)(object)component))
				{
					throw new MissingComponentException("Native shop spawner renderer was not created");
				}
				((Renderer)component).enabled = false;
				val.SetActive(true);
				radioItemController = world.CreateShopStock(val.transform, position, rotation, slot.Kind);
				if (!Object.op_Implicit((Object)(object)radioItemController))
				{
					Object.Destroy((Object)(object)val);
					return;
				}
				RadioShopStock radioShopStock = ((Component)radioItemController).gameObject.AddComponent<RadioShopStock>();
				radioShopStock.Service = this;
				radioShopStock.Shop = vendor.Area;
				radioShopStock.Controller = radioItemController;
				radioShopStock.Anchor = val.transform;
				((Component)radioItemController).GetComponent<ShipItem>().AddToShop(vendor.Area);
				radioItemController.SetShopStock(stock: true);
				slot.Anchor = val;
				slot.Stock = radioShopStock;
				slot.Clock.Spawned();
				((Component)radioShopStock).gameObject.SetActive(false);
				Physics.SyncTransforms();
			}
			catch (Exception ex)
			{
				if (Object.op_Implicit((Object)(object)radioItemController))
				{
					vendor.Area.itemsForSale.Remove(((Component)radioItemController).GetComponent<ShipItem>());
					Object.Destroy((Object)(object)((Component)radioItemController).gameObject);
				}
				if (Object.op_Implicit((Object)(object)val))
				{
					Object.Destroy((Object)(object)val);
				}
				ReportSetupFailure(vendor, ex.Message);
			}
		}

		private bool ReadyToStock(Vendor vendor)
		{
			if (!supported || !Object.op_Implicit((Object)(object)vendor.Area))
			{
				return false;
			}
			Shopkeeper shopkeeper = vendor.Area.GetShopkeeper();
			if (!Object.op_Implicit((Object)(object)shopkeeper))
			{
				return false;
			}
			if (Object.op_Implicit((Object)(object)KeeperRegion(vendor)) && NativeShopContract.KeeperEconomy?.GetValue(shopkeeper) != null)
			{
				return NativeShopContract.KeeperReady(vendor.Area);
			}
			return false;
		}

		private static Region KeeperRegion(Vendor vendor)
		{
			Shopkeeper shopkeeper = vendor.Area.GetShopkeeper();
			object? obj = NativeShopContract.KeeperRegion?.GetValue(shopkeeper);
			Region val = (Region)((obj is Region) ? obj : null);
			if (Object.op_Implicit((Object)(object)vendor.Template))
			{
				object? obj2 = NativeShopContract.KeeperRegion?.GetValue(vendor.Template);
				Region val2 = (Region)((obj2 is Region) ? obj2 : null);
				if (val2 != null && Object.op_Implicit((Object)(object)val2) && (Object)(object)val2 != (Object)(object)val)
				{
					NativeShopContract.KeeperRegion.SetValue(shopkeeper, val2);
					val = val2;
				}
			}
			return val;
		}

		private bool PurchaseEnvironmentReady(Vendor vendor)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Expected I4, but got Unknown
			if (!ReadyToStock(vendor) || vendor.Area.itemsForSale == null)
			{
				return false;
			}
			int num = (int)KeeperRegion(vendor).portRegion;
			if (num >= 0 && PlayerGold.currency != null && PlayerGold.currency.Length > num && PlayerReputation.retailDiscounts != null && PlayerReputation.retailDiscounts.Length > num && Object.op_Implicit((Object)(object)CurrencyMarket.instance) && Object.op_Implicit((Object)(object)UISoundPlayer.instance) && Object.op_Implicit((Object)(object)BuyItemUI.instance) && Object.op_Implicit((Object)(object)DayLogs.instance) && DayLogs.instance.dayLogs != null && DayLogs.instance.dayLogs.Length > num && DayLogs.instance.dayLogs[num] != null)
			{
				return Object.op_Implicit((Object)(object)MoneyNotification.instance);
			}
			return false;
		}

		private static bool BeforeAreaEnter(ShopArea __instance, Collider other)
		{
			if (active == null)
			{
				return true;
			}
			Shopkeeper val = (Object.op_Implicit((Object)(object)other) ? ((Component)other).GetComponentInParent<Shopkeeper>() : null);
			ShipItem val2 = (Object.op_Implicit((Object)(object)other) ? ((Component)other).GetComponentInParent<ShipItem>() : null);
			RadioShopStock radioShopStock = (Object.op_Implicit((Object)(object)val2) ? ((Component)val2).GetComponent<RadioShopStock>() : null);
			bool flag = Object.op_Implicit((Object)(object)radioShopStock) && radioShopStock.Service == active && (!radioShopStock.Purchased || !val2.sold);
			if (!active.Owns(__instance))
			{
				if (!Object.op_Implicit((Object)(object)val) || !active.Owns(val))
				{
					return !flag;
				}
				return false;
			}
			if (Object.op_Implicit((Object)(object)val))
			{
				return (Object)(object)val == (Object)(object)__instance.GetShopkeeper();
			}
			if (Object.op_Implicit((Object)(object)val2) && (!Object.op_Implicit((Object)(object)radioShopStock) || !radioShopStock.Purchased || !val2.sold))
			{
				if (flag)
				{
					return (Object)(object)radioShopStock.Shop == (Object)(object)__instance;
				}
				return false;
			}
			return true;
		}

		private static bool BeforeKeeperEnter(Shopkeeper __instance, Collider other)
		{
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			if (active == null)
			{
				return true;
			}
			ShipItem val = (Object.op_Implicit((Object)(object)other) ? ((Component)other).GetComponentInParent<ShipItem>() : null);
			RadioShopStock radioShopStock = (Object.op_Implicit((Object)(object)val) ? ((Component)val).GetComponent<RadioShopStock>() : null);
			bool flag = Object.op_Implicit((Object)(object)radioShopStock) && radioShopStock.Service == active && (!radioShopStock.Purchased || !val.sold);
			if (!active.Owns(__instance))
			{
				return !flag;
			}
			if (!Object.op_Implicit((Object)(object)val))
			{
				return true;
			}
			if (flag)
			{
				if (Object.op_Implicit((Object)(object)radioShopStock.Shop))
				{
					return (Object)(object)radioShopStock.Shop.GetShopkeeper() == (Object)(object)__instance;
				}
				return false;
			}
			foreach (Vendor vendor in active.vendors)
			{
				if (Object.op_Implicit((Object)(object)vendor.OwnedNpc) && (Object)(object)vendor.OwnedNpc.GetComponent<Shopkeeper>() == (Object)(object)__instance)
				{
					return val.sold && Object.op_Implicit((Object)(object)((PickupableItem)val).held) && active.world.ReadyForShop && active.ReadyToStock(vendor) && Object.op_Implicit((Object)(object)Camera.main) && Vector3.Distance(((Component)Camera.main).transform.position, ((Component)vendor.Stand).transform.position) <= 3.25f;
				}
			}
			return false;
		}

		private bool Owns(ShopArea area)
		{
			foreach (Vendor vendor in vendors)
			{
				if ((Object)(object)vendor.Area == (Object)(object)area)
				{
					return true;
				}
			}
			return false;
		}

		private bool Owns(Shopkeeper keeper)
		{
			foreach (Vendor vendor in vendors)
			{
				if (Object.op_Implicit((Object)(object)vendor.OwnedNpc) && (Object)(object)vendor.OwnedNpc.GetComponent<Shopkeeper>() == (Object)(object)keeper)
				{
					return true;
				}
			}
			return false;
		}

		private static bool KeepStockActive(RadioShopStock stock)
		{
			ShipItem component = ((Component)stock).GetComponent<ShipItem>();
			BoxCollider component2 = ((Component)stock).GetComponent<BoxCollider>();
			if (Object.op_Implicit((Object)(object)component))
			{
				if (!Object.op_Implicit((Object)(object)((PickupableItem)component).held))
				{
					if (Object.op_Implicit((Object)(object)component2))
					{
						return !((Collider)component2).enabled;
					}
					return false;
				}
				return true;
			}
			return false;
		}

		private static void ProtectStock(RadioShopStock stock)
		{
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			ShipItem component = ((Component)stock).GetComponent<ShipItem>();
			if (Object.op_Implicit((Object)(object)component) && !component.sold && !stock.Purchased && Object.op_Implicit((Object)(object)stock.Anchor))
			{
				if (Object.op_Implicit((Object)(object)stock.Shop) && stock.Shop.itemsForSale != null && !stock.Shop.itemsForSale.Contains(component))
				{
					stock.Shop.itemsForSale.Add(component);
				}
				if ((Object)(object)((Component)component).transform.parent != (Object)(object)stock.Anchor)
				{
					((Component)component).transform.SetParent(stock.Anchor, true);
				}
				if (Object.op_Implicit((Object)(object)((PickupableItem)component).held) && Vector3.Distance(((Component)component).transform.position, stock.Anchor.position) > 1.8f)
				{
					component.ReturnToShopPos();
				}
			}
		}

		private static void BeforePrice(ShipItem item)
		{
			RadioShopStock radioShopStock = (Object.op_Implicit((Object)(object)item) ? ((Component)item).GetComponent<RadioShopStock>() : null);
			if (Object.op_Implicit((Object)(object)radioShopStock))
			{
				ProtectStock(radioShopStock);
			}
		}

		private static bool BeforeEnterBoat(ShipItem __instance)
		{
			if (!__instance.sold)
			{
				return !Object.op_Implicit((Object)(object)((Component)__instance).GetComponent<RadioShopStock>());
			}
			return true;
		}

		private static void Clear(Vendor vendor)
		{
			Slot[] slots = vendor.Slots;
			foreach (Slot slot in slots)
			{
				if (Object.op_Implicit((Object)(object)slot.Stock) && !((Component)slot.Stock).GetComponent<ShipItem>().sold)
				{
					if (Object.op_Implicit((Object)(object)vendor.Area))
					{
						vendor.Area.itemsForSale.Remove(((Component)slot.Stock).GetComponent<ShipItem>());
					}
					Object.Destroy((Object)(object)((Component)slot.Stock).gameObject);
				}
				if (Object.op_Implicit((Object)(object)slot.Anchor))
				{
					Object.Destroy((Object)(object)slot.Anchor);
				}
			}
			if (Object.op_Implicit((Object)(object)vendor.Stand))
			{
				Object.Destroy((Object)(object)((Component)vendor.Stand).gameObject);
			}
			if (Object.op_Implicit((Object)(object)vendor.Area))
			{
				Object.Destroy((Object)(object)((Component)vendor.Area).gameObject);
			}
			if (Object.op_Implicit((Object)(object)vendor.OwnedNpc))
			{
				Object.Destroy((Object)(object)vendor.OwnedNpc);
			}
			vendor.Stand = null;
			vendor.Area = null;
			vendor.OwnedNpc = null;
			vendor.MerchantTriggers = null;
			vendor.DisplayShown = false;
			vendor.InitialStockAttempted = false;
			vendor.StageReadyAt = -1f;
			vendor.NextStockAttempt = 0f;
		}

		private void Clear()
		{
			foreach (Vendor vendor in vendors)
			{
				Clear(vendor);
			}
			vendors.Clear();
			sessionScanned = false;
		}

		public void Dispose()
		{
			if (!disposed)
			{
				disposed = true;
				SceneManager.sceneLoaded -= SceneLoaded;
				Clear();
				harmony.UnpatchSelf();
				if (active == this)
				{
					active = null;
				}
			}
		}
	}
	internal sealed class RadioShopStand : MonoBehaviour
	{
		private Material wood;

		private Material platformWood;

		private Material canvas;

		private Material roofWood;

		private readonly List<Renderer> structureRenderers = new List<Renderer>();

		private readonly List<Collider> structureColliders = new List<Collider>();

		internal bool UsesNativeGoldRockCounter { get; private set; }

		internal void SetVisible(bool visible)
		{
			foreach (Renderer structureRenderer in structureRenderers)
			{
				if (Object.op_Implicit((Object)(object)structureRenderer))
				{
					structureRenderer.enabled = visible;
				}
			}
			foreach (Collider structureCollider in structureColliders)
			{
				if (Object.op_Implicit((Object)(object)structureCollider))
				{
					structureCollider.enabled = visible;
				}
			}
		}

		internal static RadioShopStand Create(Transform scenery, Vector3 position, Quaternion rotation, int island)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Expected O, but got Unknown
			//IL_001e: 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_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Expected O, but got Unknown
			//IL_00cc: 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_0188: 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_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_0131: Expected O, but got Unknown
			//IL_0148: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: 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_016c: Expected O, but got Unknown
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_019d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c2: Expected O, but got Unknown
			//IL_020b: Unknown result type (might be due to invalid IL or missing references)
			//IL_021f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0240: Unknown result type (might be due to invalid IL or missing references)
			//IL_0254: Unknown result type (might be due to invalid IL or missing references)
			//IL_0275: Unknown result type (might be due to invalid IL or missing references)
			//IL_0289: Unknown result type (might be due to invalid IL or missing references)
			//IL_0573: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_0350: Unknown result type (might be due to invalid IL or missing references)
			//IL_0364: Unknown result type (might be due to invalid IL or missing references)
			//IL_0385: Unknown result type (might be due to invalid IL or missing references)
			//IL_0399: Unknown result type (might be due to invalid IL or missing references)
			//IL_042c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0440: Unknown result type (might be due to invalid IL or missing references)
			//IL_0305: Unknown result type (might be due to invalid IL or missing references)
			//IL_0319: Unknown result type (might be due to invalid IL or missing references)
			//IL_047b: Unknown result type (might be due to invalid IL or missing references)
			//IL_048f: Unknown result type (might be due to invalid IL or missing references)
			//IL_073b: Unknown result type (might be due to invalid IL or missing references)
			//IL_074f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0773: Unknown result type (might be due to invalid IL or missing references)
			//IL_0792: Unknown result type (might be due to invalid IL or missing references)
			//IL_07a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_07ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_04c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_04dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_065a: Unknown result type (might be due to invalid IL or missing references)
			//IL_066e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0692: Unknown result type (might be due to invalid IL or missing references)
			//IL_06bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_06d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_06fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0710: Unknown result type (might be due to invalid IL or missing references)
			//IL_051e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0532: Unknown result type (might be due to invalid IL or missing references)
			//IL_05fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_060f: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("Radio merchant display");
			try
			{
				val.transform.SetParent(scenery, false);
				val.transform.position = position;
				val.transform.rotation = rotation;
				Vector3 lossyScale = scenery.lossyScale;
				val.transform.localScale = new Vector3(1f / lossyScale.x, 1f / lossyScale.y, 1f / lossyScale.z);
				RadioShopStand radioShopStand = val.AddComponent<RadioShopStand>();
				Shader val2 = Shader.Find("Standard");
				if (!Object.op_Implicit((Object)(object)val2))
				{
					throw new InvalidOperationException("Display stand shader unavailable");
				}
				Material val3 = new Material(val2);
				Color color;
				switch (island)
				{
				default:
					color = new Color(0.39f, 0.24f, 0.15f);
					break;
				case 15:
				case 25:
					color = new Color(0.37f, 0.29f, 0.23f);
					break;
				case 9:
					color = new Color(0.31f, 0.18f, 0.14f);
					break;
				}
				val3.color = color;
				radioShopStand.wood = val3;
				radioShopStand.wood.SetFloat("_Glossiness", 0.16f);
				if (island == 9)
				{
					radioShopStand.platformWood = new Material(val2)
					{
						color = new Color(0.34f, 0.23f, 0.18f)
					};
					radioShopStand.platformWood.SetFloat("_Glossiness", 0.1f);
					radioShopStand.roofWood = new Material(val2)
					{
						color = new Color(0.25f, 0.14f, 0.11f)
					};
					radioShopStand.roofWood.SetFloat("_Glossiness", 0.1f);
				}
				radioShopStand.canvas = new Material(val2)
				{
					color = ((island == 9) ? new Color(0.36f, 0.2f, 0.16f) : new Color(0.42f, 0.21f, 0.15f))
				};
				radioShopStand.canvas.SetFloat("_Glossiness", 0.05f);
				if (!(radioShopStand.UsesNativeGoldRockCounter = island == 1 && radioShopStand.NativeGoldRockStall(scenery)))
				{
					radioShopStand.Board("Flat display top", new Vector3(0f, 0.78f, 0f), new Vector3(2.36f, 0.075f, 1.13f));
					radioShopStand.Board("Front retaining lip", new Vector3(0f, 0.78f, -0.55f), new Vector3(2.38f, 0.09f, 0.055f));
					radioShopStand.Board("Rear retaining lip", new Vector3(0f, 0.78f, 0.55f), new Vector3(2.38f, 0.09f, 0.055f));
					for (int i = -1; i <= 1; i += 2)
					{
						radioShopStand.Board("Side retaining lip", new Vector3((float)i * 1.17f, 0.78f, 0f), new Vector3(0.055f, 0.09f, 1.1f));
					}
					for (int j = -1; j <= 1; j += 2)
					{
						for (int k = -1; k <= 1; k += 2)
						{
							radioShopStand.Board("Wooden leg", new Vector3((float)j * 1.06f, 0.38f, (float)k * 0.44f), new Vector3(0.105f, 0.76f, 0.105f));
						}
					}
					radioShopStand.Board("Rear brace", new Vector3(0f, 0.37f, 0.45f), new Vector3(2.2f, 0.09f, 0.08f));
					radioShopStand.Board("Front brace", new Vector3(0f, 0.26f, -0.45f), new Vector3(2.2f, 0.09f, 0.08f));
				}
				if (island == 9 && !radioShopStand.NativeDragonCliffsDeck(scenery))
				{
					for (int l = -5; l <= 7; l++)
					{
						radioShopStand.Board("Dragon Cliffs platform plank", new Vector3((float)l * 0.33f, -0.045f, 0.7f), new Vector3(0.31f, 0.09f, 3.8f), radioShopStand.platformWood);
					}
					for (int m = -1; m <= 1; m += 2)
					{
						radioShopStand.Board("Platform cross beam", new Vector3(0.33f, -0.13f, 0.7f + (float)m * 1.8f), new Vector3(4.28f, 0.15f, 0.1f), radioShopStand.platformWood);
					}
					for (int n = -5; n <= 7; n++)
					{
						radioShopStand.Board("Rear Dragon Cliffs platform plank", new Vector3((float)n * 0.33f, -0.045f, 4.9f), new Vector3(0.31f, 0.09f, 3.8f), radioShopStand.platformWood);
					}
					for (int num = 4; num <= 16; num++)
					{
						radioShopStand.Board("Left Dragon Cliffs platform plank", new Vector3((float)num * 0.33f, -0.05f, 0.7f), new Vector3(0.31f, 0.09f, 3.8f), radioShopStand.platformWood);
					}
					for (int num2 = -1; num2 <= 1; num2 += 2)
					{
						radioShopStand.Board("Left platform cross beam", new Vector3(3.2f, -0.135f, 0.7f + (float)num2 * 1.8f), new Vector3(4.2f, 0.15f, 0.1f), radioShopStand.platformWood);
					}
				}
				bool flag2 = island == 9 && radioShopStand.NativeDragonCliffsVisual(scenery, "east_market_roof", "east_market_roof", "Dragon Cliffs native canopy", new Vector3(0f, 2.05f, 0.1875f), 0.65f, solid: false);
				if ((island == 9 && !flag2) || island == 15)
				{
					float num3 = ((island == 9) ? 0.1875f : 0f);
					for (int num4 = -1; num4 <= 1; num4 += 2)
					{
						for (int num5 = -1; num5 <= 1; num5 += 2)
						{
							float num6 = ((island == 9) ? ((num5 < 0) ? 2.36f : 2.66f) : 2.5f);
							radioShopStand.Board("Canopy post", new Vector3((float)num4 * 1.34f, num6 / 2f, 0.35f + (float)num5 * 1.05f + num3), new Vector3(0.065f, num6, 0.065f));
						}
					}
					if (island == 9)
					{
						for (int num7 = -1; num7 <= 1; num7++)
						{
							radioShopStand.Board("Dragon Cliffs canvas roof panel", new Vector3((float)num7 * 0.98f, 2.53f, 0.35f + num3), new Vector3(0.99f, 0.04f, 2.45f), radioShopStand.canvas).transform.localRotation = Quaternion.Euler(-7f, 0f, 0f);
						}
						radioShopStand.Board("Dragon Cliffs hanging front fabric", new Vector3(0f, 2.29f, -0.88f + num3), new Vector3(2.9f, 0.18f, 0.045f), radioShopStand.canvas);
						radioShopStand.Board("Dragon Cliffs front wood rail", new Vector3(0f, 2.39f, -0.88f + num3), new Vector3(2.9f, 0.075f, 0.065f), radioShopStand.roofWood);
					}
					else
					{
						radioShopStand.Board("Canvas canopy left", new Vector3(-0.72f, 2.52f, 0.35f), new Vector3(1.5f, 0.055f, 2.35f), radioShopStand.canvas).transform.localRotation = Quaternion.Euler(0f, 0f, 7f);
						radioShopStand.Board("Canvas canopy right", new Vector3(0.72f, 2.52f, 0.35f), new Vector3(1.5f, 0.055f, 2.35f), radioShopStand.canvas).transform.localRotation = Quaternion.Euler(0f, 0f, -7f);
					}
				}
				return radioShopStand;
			}
			catch
			{
				Object.Destroy((Object)(object)val);
				throw;
			}
		}

		private GameObject Board(string name, Vector3 center, Vector3 size, Material material = null)
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = GameObject.CreatePrimitive((PrimitiveType)3);
			((Object)val).name = name;
			val.transform.SetParent(((Component)this).transform, false);
			val.transform.localPosition = center;
			val.transform.localScale = size;
			Renderer component = val.GetComponent<Renderer>();
			component.sharedMaterial = (Object.op_Implicit((Object)(object)material) ? material : wood);
			structureRenderers.Add(component);
			structureColliders.Add(val.GetComponent<Collider>());
			return val;
		}

		private bool NativeGoldRockStall(Transform scenery)
		{
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: Unknown result type (might be due to invalid IL or missing references)
			//IL_012d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0132: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			//IL_013c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0141: Unknown result type (might be due to invalid IL or missing references)
			//IL_014b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0157: Unknown result type (might be due to invalid IL or missing references)
			//IL_0161: Unknown result type (might be due to invalid IL or missing references)
			//IL_0176: Unknown result type (might be due to invalid IL or missing references)
			//IL_0180: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0210: 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_0248: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			MeshFilter val = null;
			MeshRenderer val2 = null;
			float num = 30f;
			MeshFilter[] componentsInChildren = ((Component)scenery).GetComponentsInChildren<MeshFilter>(true);
			foreach (MeshFilter val3 in componentsInChildren)
			{
				if (!Object.op_Implicit((Object)(object)val3) || !Object.op_Implicit((Object)(object)val3.sharedMesh) || ((Object)val3).name != "market_stall (2)" || ((Object)val3.sharedMesh).name != "market_stall_001")
				{
					continue;
				}
				MeshRenderer component = ((Component)val3).GetComponent<MeshRenderer>();
				if (Object.op_Implicit((Object)(object)component) && ((Renderer)component).sharedMaterials.Length == 1 && Object.op_Implicit((Object)(object)((Renderer)component).sharedMaterials[0]) && !(((Object)((Renderer)component).sharedMaterials[0]).name != "buildings_A_paint"))
				{
					float num2 = Vector3.Distance(((Component)val3).transform.position, ((Component)this).transform.position);
					if (!(num2 >= num))
					{
						val = val3;
						val2 = component;
						num = num2;
					}
				}
			}
			if (!Object.op_Implicit((Object)(object)val))
			{
				return false;
			}
			GameObject val4 = new GameObject("Gold Rock native covered market stall");
			val4.transform.SetParent(((Component)this).transform, false);
			val4.transform.localRotation = Quaternion.Euler(0f, 181f, 0f) * Quaternion.LookRotation(Vector3.up, Vector3.left);
			val4.transform.localScale = ((Component)val).transform.lossyScale;
			val4.transform.localPosition = new Vector3(0f, 1.045f, 0.24f);
			val4.AddComponent<MeshFilter>().sharedMesh = val.sharedMesh;
			MeshRenderer val5 = val4.AddComponent<MeshRenderer>();
			((Renderer)val5).sharedMaterials = ((Renderer)val2).sharedMaterials;
			structureRenderers.Add((Renderer)(object)val5);
			Support("Gold Rock front plank support", new Vector3(0f, 0.86f, -0.4625f), new Vector3(2.52f, 0.06f, 0.315f), 0f);
			Support("Gold Rock middle plank support", new Vector3(0f, 0.89f, 0.02f), new Vector3(2.7f, 0.06f, 0.65f), -2.6f);
			Support("Gold Rock rear plank