using System;
using System.Collections.ObjectModel;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using Microsoft.CodeAnalysis;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETFramework,Version=v4.7.1", FrameworkDisplayName = ".NET Framework 4.7.1")]
[assembly: AssemblyCompany("MapStation.API")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+2a9f5e71dc280b5c7d4e74f2e1ad0f6a1ac841a2")]
[assembly: AssemblyProduct("MapStation.API")]
[assembly: AssemblyTitle("MapStation.API")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.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 MapStation.API
{
	public static class APIManager
	{
		public static IMapStationAPI API;

		public static bool Initialized;

		public static event Action OnInitialized;

		public static void Initialize(IMapStationAPI api)
		{
			API = api;
			Initialized = true;
			APIManager.OnInitialized?.Invoke();
		}
	}
	public interface ICustomStage
	{
		string DisplayName { get; }

		string InternalName { get; }

		string AuthorName { get; }

		int StageID { get; }
	}
	public interface IMapStationAPI
	{
		ReadOnlyCollection<ICustomStage> CustomStages { get; }

		ICustomStage GetCustomStageByID(int stageID);

		int GetStageID(string stageInternalName);
	}
}

using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.IO.Compression;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx.Logging;
using MapStation.Common.Runtime;
using MapStation.Common.Serialization;
using Microsoft.CodeAnalysis;
using Microsoft.Win32;
using Reptile;
using UnityEngine;
using UnityEngine.Audio;
using UnityEngine.Playables;
using UnityEngine.Rendering.PostProcessing;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETFramework,Version=v4.7.1", FrameworkDisplayName = ".NET Framework 4.7.1")]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp")]
[assembly: AssemblyCompany("MapStation.Common")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+2a9f5e71dc280b5c7d4e74f2e1ad0f6a1ac841a2")]
[assembly: AssemblyProduct("MapStation.Common")]
[assembly: AssemblyTitle("MapStation.Common")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.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;
		}
	}
}
[AttributeUsage(AttributeTargets.Field, Inherited = true)]
public class UidAttribute : PropertyAttribute
{
}
namespace cspotcode.UnityGUI
{
	public static class GUIUtil
	{
		private class EndScrollViewDisposable : IDisposable
		{
			public void Dispose()
			{
				GUILayout.EndScrollView();
			}
		}

		private class EndVerticalDisposable : IDisposable
		{
			public void Dispose()
			{
				GUILayout.EndVertical();
			}
		}

		private class EndHorizontalDisposable : IDisposable
		{
			public void Dispose()
			{
				GUILayout.EndHorizontal();
			}
		}

		private class EndDisabledDisposable : IDisposable
		{
			private readonly bool stateBefore;

			internal EndDisabledDisposable(bool stateBefore)
			{
				this.stateBefore = stateBefore;
			}

			public void Dispose()
			{
				GUI.enabled = stateBefore;
			}
		}

		private class IndentDisposable : IDisposable
		{
			private readonly int increment;

			internal IndentDisposable(int increment)
			{
				this.increment = increment;
			}

			public void Dispose()
			{
				indentLevel -= increment;
			}
		}

		private class ApplyIndentDisposable : IDisposable
		{
			public void Dispose()
			{
				GUILayout.EndVertical();
				GUILayout.EndHorizontal();
			}
		}

		public const char UpTriangle = '▲';

		public const char DownTriangle = '▼';

		public const char RightTriangle = '▶';

		public static readonly IDisposable EndScrollView = new EndScrollViewDisposable();

		public static readonly IDisposable EndHorizontal = new EndHorizontalDisposable();

		private const int PixelsPerIndentLevel = 15;

		public static readonly IDisposable EndApplyIndent = new ApplyIndentDisposable();

		public static int indentLevel { get; set; }

		public static IDisposable ScrollView(ref Vector2 position)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Expected O, but got Unknown
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			ScrollViewScope val = new ScrollViewScope(position, Array.Empty<GUILayoutOption>());
			position = val.scrollPosition;
			return (IDisposable)val;
		}

		public static IDisposable Horizontal()
		{
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			return EndHorizontal;
		}

		public static IDisposable Disabled(bool disabled = true)
		{
			EndDisabledDisposable result = new EndDisabledDisposable(GUI.enabled);
			GUI.enabled = !disabled;
			return result;
		}

		public static IDisposable Indent(int increment = 1, bool apply = false)
		{
			indentLevel += increment;
			IndentDisposable indentDisposable = new IndentDisposable(increment);
			if (apply)
			{
				IDisposable disposable = ApplyIndent();
				return new CompositeDisposable(disposable, indentDisposable);
			}
			return indentDisposable;
		}

		public static IDisposable ApplyIndent()
		{
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			GUILayout.Label("", (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.Width((float)(15 * indentLevel)),
				GUILayout.ExpandWidth(false)
			});
			GUILayout.BeginVertical((GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandWidth(false) });
			return EndApplyIndent;
		}
	}
	public static class Extensions
	{
	}
	public class CompositeDisposable : IDisposable
	{
		private readonly IDisposable[] disposables;

		public CompositeDisposable(params IDisposable[] disposables)
		{
			this.disposables = disposables;
		}

		public void Dispose()
		{
			IDisposable[] array = disposables;
			for (int i = 0; i < array.Length; i++)
			{
				array[i].Dispose();
			}
		}
	}
}
namespace MapStation.Common
{
	public abstract class AGameMapStationPlugin
	{
		public virtual void OnAddMapToDatabase(ZipArchive archive, string path, string mapName)
		{
		}

		public virtual void OnReload()
		{
		}
	}
	public class NoOpDynamicPickup : MonoBehaviour
	{
		private void Awake()
		{
			Object.Destroy((Object)(object)((Component)this).gameObject);
		}
	}
	public class PathConstants
	{
		public const string MapFileExtension = ".brcmap";

		public const string ConfigDirectory = "MapStation";

		public const string TestMapsDirectory = "TestMaps";

		public static string AbsoluteTestMapsDirectoryFromBepInExProfile(string BepInExProfileDirectory)
		{
			return Path.Combine(BepInExProfileDirectory, "Config", "MapStation", "TestMaps");
		}
	}
	public class AssetNames
	{
		public const string MapDirectory = "Maps";

		public const string SceneBasenamePrefix = "Scene.";

		public const string PropertiesBasename = "Properties";

		public const string BundlePrefix = "maps/";

		public const string SceneBundleBasename = "scene";

		public const string SceneBundleSuffix = "/scene";

		public const string AssetsBundleBasename = "assets";

		public const string AssetsBundleSuffix = "/assets";

		public const string BundleVariant = "";

		public static string GetMiniMapPathForMap(string name)
		{
			return "Assets/Maps/" + name + "/MiniMap.prefab";
		}

		public static string GetAssetDirectoryForMap(string name)
		{
			return "Assets/Maps/" + name;
		}

		public static string GetScenePathForMap(string name)
		{
			return "Assets/Maps/" + name + "/Scene." + name + ".unity";
		}

		public static string GetPropertiesPathForMap(string name)
		{
			return "Assets/Maps/" + name + "/Properties.asset";
		}

		public static string GetReadmePathForMap(string name)
		{
			return "Assets/Maps/" + name + "/README.md";
		}

		public static string GetIconPathForMap(string name)
		{
			return "Assets/Maps/" + name + "/icon.png";
		}

		public static string GetChangelogPathForMap(string name)
		{
			return "Assets/Maps/" + name + "/CHANGELOG.md";
		}

		public static string GetSceneBundleNameForMap(string name)
		{
			return "maps/" + name.ToLower() + "/scene";
		}

		public static string GetAssetBundleNameForMap(string name)
		{
			return "maps/" + name.ToLower() + "/assets";
		}
	}
	public static class EnumeratePairsExtensions
	{
		public static IEnumerable<KeyValuePair<int, T>> Pairs<T>(this T[] array)
		{
			for (int i = 0; i < array.Length; i++)
			{
				yield return new KeyValuePair<int, T>(i, array[i]);
			}
		}

		public static IEnumerable<KeyValuePair<int, T>> Pairs<T>(this List<T> list)
		{
			for (int i = 0; i < list.Count; i++)
			{
				yield return new KeyValuePair<int, T>(i, list[i]);
			}
		}
	}
	public static class DeconstructPairsExtensions
	{
		public static void Deconstruct<T, U>(this KeyValuePair<T, U> pair, out T key, out U value)
		{
			key = pair.Key;
			value = pair.Value;
		}
	}
	public static class EnumeratorExtensions
	{
		public static T TakeNext<T>(this IEnumerator<T> enumerator)
		{
			enumerator.MoveNext();
			return enumerator.Current;
		}
	}
	public static class Log
	{
		public static ManualLogSource Logger;

		public static void Info(string message)
		{
			Logger.LogInfo((object)message);
		}

		public static void Error(string message)
		{
			Logger.LogError((object)message);
		}

		public static void Warning(string message)
		{
			Logger.LogWarning((object)message);
		}

		public static void Debug(string message)
		{
			Logger.LogDebug((object)message);
		}
	}
	public class BaseMapDatabaseEntry
	{
		public string Name;

		public string ScenePath;

		public string SceneBundleName => AssetNames.GetSceneBundleNameForMap(Name);

		public string AssetsBundleName => AssetNames.GetAssetBundleNameForMap(Name);
	}
	[Serializable]
	public class MapProperties
	{
		public int format = 1;

		public string internalName;

		public string version = "0.0.0";

		public string displayName = "";

		public string authorName = "";

		public bool showInFastTravelMenus = true;

		public bool disableCops;

		[Tooltip("Override the shadow distance for your map. Can be used to avoid shadows fading out too close.")]
		public bool overrideShadowDistance = true;

		[Range(0f, 500f)]
		public float shadowDistance = 150f;
	}
	public class MapZip : IDisposable
	{
		public const string propertiesFilename = "properties.json";

		public const string sceneBundleFilename = "scene";

		public const string assetsBundleFilename = "assets";

		private string path;

		private ZipArchive zip;

		public MapZip(string path)
		{
			this.path = path;
		}

		public ZipArchive WriteZip(string propertiesContents, string sceneBundlePath, string assetsBundlePath, bool compressed = true)
		{
			CompressionLevel compressionLevel = ((!compressed) ? CompressionLevel.NoCompression : CompressionLevel.Optimal);
			zip = ZipFile.Open(path, ZipArchiveMode.Create);
			zip.CreateEntryFromFile(sceneBundlePath, "scene", compressionLevel);
			zip.CreateEntryFromFile(assetsBundlePath, "assets", compressionLevel);
			using (Stream stream = zip.CreateEntry("properties.json", compressionLevel).Open())
			{
				using StreamWriter streamWriter = new StreamWriter(stream);
				streamWriter.Write(propertiesContents);
			}
			return zip;
		}

		private void openForReading()
		{
			if (zip == null)
			{
				zip = ZipFile.Open(path, ZipArchiveMode.Read);
			}
		}

		public void DoPluginOnAddMapToDatabase(string mapName)
		{
			openForReading();
			GamePluginManager.OnAddMapToDatabase(zip, path, mapName);
		}

		public string GetPropertiesText()
		{
			openForReading();
			using Stream stream = zip.GetEntry("properties.json").Open();
			using StreamReader streamReader = new StreamReader(stream);
			return streamReader.ReadToEnd();
		}

		public Stream GetSceneBundleStream()
		{
			openForReading();
			return zip.GetEntry("scene").Open();
		}

		public Stream GetAssetsBundleStream()
		{
			openForReading();
			return zip.GetEntry("assets").Open();
		}

		public void Dispose()
		{
			zip?.Dispose();
		}
	}
	public class MiniMapProperties : MonoBehaviour
	{
		[Header("Material that will change colors in phone and pause menu.")]
		public Material MapMaterial;
	}
	public class PathDetection
	{
		public const string RegistryKey = "HKEY_CURRENT_USER\\Software\\BRCMapStation\\MapStation";

		public const string RegistryValueBepInExProfile = "BepInExProfile";

		public const string RegistryValueBRCPath = "BRCPath";

		public const string RegistryValueUnityEditorDataDir = "UnityEditorDataDir";

		public static string GetBepInExProfileInRegistry()
		{
			return Registry.GetValue("HKEY_CURRENT_USER\\Software\\BRCMapStation\\MapStation", "BepInExProfile", "") as string;
		}

		public static void SetBepInExProfileInRegistry(string path)
		{
			Registry.SetValue("HKEY_CURRENT_USER\\Software\\BRCMapStation\\MapStation", "BepInExProfile", path);
		}

		public static string GetBRCPathInRegistry()
		{
			return Registry.GetValue("HKEY_CURRENT_USER\\Software\\BRCMapStation\\MapStation", "BRCPath", "") as string;
		}

		public static void SetBRCPathInRegistry(string path)
		{
			Registry.SetValue("HKEY_CURRENT_USER\\Software\\BRCMapStation\\MapStation", "BRCPath", path);
		}

		public static string GetUnityEditorDataDirInRegistry()
		{
			return Registry.GetValue("HKEY_CURRENT_USER\\Software\\BRCMapStation\\MapStation", "UnityEditorDataDir", "") as string;
		}

		public static void SetUnityEditorDataDirInRegistry(string path)
		{
			Registry.SetValue("HKEY_CURRENT_USER\\Software\\BRCMapStation\\MapStation", "UnityEditorDataDir", path);
		}
	}
	public class StageObject : MonoBehaviour
	{
		[Header("Name of the chunk GameObject. Leave this empty to automatically find a chunk.")]
		[SerializeField]
		private string chunkName = "";

		public void PutInChunk()
		{
			//IL_00db: 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_0112: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)((Component)this).GetComponentInParent<StageChunk>(true) != (Object)null)
			{
				return;
			}
			StageObject componentInParent = ((Component)this).GetComponentInParent<StageObject>(true);
			if ((Object)(object)componentInParent != (Object)(object)this && (Object)(object)componentInParent != (Object)null)
			{
				componentInParent.PutInChunk();
				return;
			}
			StageChunk[] array = Object.FindObjectsOfType<StageChunk>(true);
			StageChunk val = null;
			float num = 0f;
			StageChunk[] array2 = array;
			foreach (StageChunk val2 in array2)
			{
				if ((Object)(object)val2 == (Object)null || ((Object)((Component)val2).gameObject).name.StartsWith("!"))
				{
					continue;
				}
				if (!string.IsNullOrEmpty(chunkName))
				{
					if (((Object)((Component)val2).gameObject).name == chunkName)
					{
						((Component)this).transform.SetParent(((Component)val2).transform);
						return;
					}
					continue;
				}
				BoxCollider[] componentsInChildren = ((Component)val2).GetComponentsInChildren<BoxCollider>(true);
				bool flag = false;
				BoxCollider[] array3 = componentsInChildren;
				foreach (BoxCollider val3 in array3)
				{
					if (!((Object)(object)val3 == (Object)null) && StageChunk.PointInOBB(((Component)this).transform.position, val3))
					{
						flag = true;
						break;
					}
				}
				if (flag)
				{
					float num2 = Vector3.Distance(((Component)this).transform.position, ((Component)val2).transform.position);
					if ((Object)(object)val == (Object)null)
					{
						val = val2;
						num = num2;
					}
					else if (num2 < num)
					{
						val = val2;
						num = num2;
					}
				}
			}
			if ((Object)(object)val != (Object)null)
			{
				((Component)this).transform.SetParent(((Component)val).transform);
			}
		}
	}
	public static class StagePrefabHijacker
	{
		public class StagePrefabs
		{
			public GameObject Parent;

			public List<GameObject> Toilets = new List<GameObject>();

			public GameObject GetToilet()
			{
				GameObject result = Toilets[0];
				Toilets.RemoveAt(0);
				return result;
			}
		}

		public const Stage StageToHijackPrefabsFrom = 5;

		public static string[] ProtectedAssetBundles = new string[16]
		{
			"characters", "graffiti", "common_assets", "enemies", "enemy_animation", "character_animation", "in_game_assets", "mocap_animation_two", "mocap_animation", "finalboss_assets",
			"playeranimation", "finalboss_animation", "storyanimation", "minimap", "common_game_shaders", "city_assets"
		};

		public static Stage ActualTargetStage = (Stage)(-1);

		public static bool Loaded = false;

		public static bool Active = false;

		public static StagePrefabs Prefabs;

		private const int PublicToiletPool = 100;

		public static void Log(string text)
		{
			MapStation.Common.Log.Info("[StagePrefabHijacker] " + text);
		}

		private static void CleanUp()
		{
			if (Prefabs != null && !((Object)(object)Prefabs.Parent == (Object)null))
			{
				Object.Destroy((Object)(object)Prefabs.Parent);
			}
		}

		public static void RunOnHijackStage()
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Expected O, but got Unknown
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			CleanUp();
			Prefabs = new StagePrefabs();
			Prefabs.Parent = new GameObject("Custom Stage Prefabs");
			Object.DontDestroyOnLoad((Object)(object)Prefabs.Parent);
			Prefabs.Parent.SetActive(false);
			PublicToilet val = Object.FindObjectOfType<PublicToilet>();
			for (int i = 0; i < 100; i++)
			{
				GameObject val2 = Object.Instantiate<GameObject>(((Component)val).gameObject);
				val2.transform.SetParent(Prefabs.Parent.transform, false);
				val2.transform.SetPositionAndRotation(Vector3.zero, Quaternion.identity);
				Prefabs.Toilets.Add(val2);
			}
		}

		public static void RunOnCustomStage()
		{
		}
	}
	public class DebugShapeUtility
	{
		public static IEnumerable<Renderer> FindDebugShapes(GameObject root)
		{
			return root.GetComponentsInChildren<Renderer>(true).Where(delegate(Renderer r)
			{
				Material sharedMaterial = r.sharedMaterial;
				return ((sharedMaterial != null) ? ((Object)sharedMaterial).name : null) == "Debug";
			});
		}

		public static void SetDebugShapesVisibility(GameObject root, bool visible)
		{
			foreach (Renderer item in FindDebugShapes(root))
			{
				item.enabled = visible;
			}
		}
	}
	public class DebugUI : MonoBehaviour
	{
		public abstract class DebugMenu
		{
			public abstract string Name { get; }

			public virtual int? Width { get; }

			public abstract void OnGUI();
		}

		public const int DefaultWidth = 400;

		private const int Height = 1200;

		private List<DebugMenu> debugMenus = new List<DebugMenu>();

		private bool show = true;

		private DebugMenu currentDebugMenu;

		public static DebugUI Instance { get; private set; }

		public bool UiEnabled
		{
			get
			{
				return ((Component)this).gameObject.activeSelf;
			}
			set
			{
				((Component)this).gameObject.SetActive(value);
			}
		}

		public static void Create(bool enabled)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Expected O, but got Unknown
			if (!((Object)(object)Instance != (Object)null))
			{
				GameObject val = new GameObject("MapStation Debug UI");
				val.SetActive(enabled);
				Instance = val.AddComponent<DebugUI>();
				Object.DontDestroyOnLoad((Object)val);
			}
		}

		public void RegisterMenu(DebugMenu menu)
		{
			debugMenus.Add(menu);
		}

		private void OnGUI()
		{
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			int num = ((show && currentDebugMenu != null && currentDebugMenu.Width.HasValue) ? currentDebugMenu.Width.Value : 400);
			GUILayout.BeginArea(new Rect(0f, 0f, (float)num, 1200f));
			GUILayout.BeginVertical(GUI.skin.box, Array.Empty<GUILayoutOption>());
			GUILayout.BeginVertical(GUI.skin.box, Array.Empty<GUILayoutOption>());
			GUILayout.BeginVertical("Debug UI", GUI.skin.box, Array.Empty<GUILayoutOption>());
			GUILayout.Space(20f);
			try
			{
				if (GUILayout.Button("Show/Hide", Array.Empty<GUILayoutOption>()))
				{
					show = !show;
				}
				if (!show)
				{
					return;
				}
				if (currentDebugMenu != null)
				{
					if (GUILayout.Button("Back", Array.Empty<GUILayoutOption>()))
					{
						currentDebugMenu = null;
					}
					else
					{
						currentDebugMenu.OnGUI();
					}
					return;
				}
				foreach (DebugMenu debugMenu in debugMenus)
				{
					if (GUILayout.Button(debugMenu.Name, Array.Empty<GUILayoutOption>()))
					{
						currentDebugMenu = debugMenu;
					}
				}
			}
			finally
			{
				GUILayout.EndVertical();
				GUILayout.EndVertical();
				GUILayout.EndVertical();
				GUILayout.EndArea();
			}
		}
	}
	public static class PluginInfo
	{
		public const string PLUGIN_GUID = "MapStation.Common";

		public const string PLUGIN_NAME = "MapStation.Common";

		public const string PLUGIN_VERSION = "1.0.0";
	}
}
namespace MapStation.Common.Serialization
{
	internal class SerializationExample : MonoBehaviour
	{
		[Serializable]
		private class Conversation
		{
			public string showIfUnlockableIsUnlocked;
		}

		[Serializable]
		private class Dialog
		{
			public string say;

			public string animation;

			public bool askYesNo;
		}

		private class SList_NpcDialog : SList<Dialog>
		{
		}

		[SerializeReference]
		private Conversation conversation = new Conversation();

		[SerializeReference]
		private SList_NpcDialog npcDialog_ = new SList_NpcDialog();

		private List<Dialog> npcDialogs => npcDialog_.items;

		private void Awake()
		{
			string text = "";
			text += string.Format("{0} serialized data:\n", "SerializationExample");
			text += string.Format("{0}.{1}={2}\n", "Conversation", "showIfUnlockableIsUnlocked", conversation.showIfUnlockableIsUnlocked);
			text += string.Format("{0}.Count={1}\n", "npcDialogs", npcDialogs.Count);
			for (int i = 0; i < npcDialogs.Count; i++)
			{
				text += string.Format("{0}[{1}].{2}={3}\n", "npcDialogs", i, "say", npcDialogs[i].say);
				text += string.Format("{0}[{1}].{2}={3}\n", "npcDialogs", i, "animation", npcDialogs[i].animation);
				text += string.Format("{0}[{1}].{2}={3}\n", "npcDialogs", i, "askYesNo", npcDialogs[i].askYesNo);
			}
			Log.Info(text);
		}
	}
	public class SList
	{
	}
	[Serializable]
	public class SList<T> : SList, ISerializationCallbackReceiver where T : new()
	{
		[HideInInspector]
		[SerializeReference]
		private Node linkedList;

		[SerializeReference]
		public List<T> items;

		public void copyToLinkedList()
		{
			if (items == null || items.Count == 0)
			{
				linkedList = null;
				return;
			}
			if (linkedList == null)
			{
				linkedList = new Node();
			}
			Node next = linkedList;
			int i = 0;
			for (int count = items.Count; i < count; i++)
			{
				next.value = items[i];
				if (i < count - 1)
				{
					Node node = next;
					if (node.next == null)
					{
						node.next = new Node();
					}
					next = next.next;
				}
				else
				{
					next.next = null;
				}
			}
		}

		public void copyToList()
		{
			if (items == null)
			{
				items = new List<T>();
			}
			else
			{
				items.Clear();
			}
			for (Node next = linkedList; next != null; next = next.next)
			{
				items.Add((T)next.value);
			}
		}

		private void instantiateNullList()
		{
			if (items == null)
			{
				items = new List<T>();
			}
		}

		private void instantiateNullItemsInList()
		{
			int i = 0;
			for (int count = items.Count; i < count; i++)
			{
				if (items[i] == null)
				{
					items[i] = new T();
				}
			}
		}

		public void OnBeforeSerialize()
		{
			instantiateNullList();
			instantiateNullItemsInList();
			copyToLinkedList();
		}

		public void OnAfterDeserialize()
		{
			if (!Application.isEditor)
			{
				copyToList();
			}
		}
	}
	[Serializable]
	public class Node
	{
		[SerializeReference]
		public object value;

		[SerializeReference]
		public Node next;
	}
}
namespace MapStation.Common.Gameplay
{
	[AddComponentMenu("")]
	public class GrindPath_FixComboBreakingProperty : MonoBehaviour
	{
	}
	public class MapStationVert : MonoBehaviour
	{
	}
}
namespace MapStation.Common.Runtime
{
	[RequireComponent(typeof(AudioSource))]
	public class GameAudio : MonoBehaviour
	{
		public enum AudioTypes
		{
			Master = 0,
			Music = 4,
			SFX = 1,
			UI = 2,
			Gameplay = 3,
			Voices = 5,
			Ambience = 6
		}

		public AudioTypes AudioType = AudioTypes.Gameplay;

		private void Awake()
		{
			((Component)this).GetComponent<AudioSource>().outputAudioMixerGroup = Core.Instance.AudioManager.mixerGroups[(int)AudioType];
		}
	}
	public static class GamePluginManager
	{
		private static ManualLogSource LogSource = Logger.CreateLogSource("MapStation Plugin Manager");

		private static List<AGameMapStationPlugin> GetPlugins()
		{
			List<AGameMapStationPlugin> list = new List<AGameMapStationPlugin>();
			Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
			foreach (Assembly assembly in assemblies)
			{
				try
				{
					Type[] types = assembly.GetTypes();
					foreach (Type type in types)
					{
						try
						{
							if (typeof(AGameMapStationPlugin).IsAssignableFrom(type) && !type.IsAbstract)
							{
								AGameMapStationPlugin item = Activator.CreateInstance(type) as AGameMapStationPlugin;
								list.Add(item);
							}
						}
						catch (Exception arg)
						{
							LogSource.LogWarning((object)$"Problem loading Type, silently handled.{Environment.NewLine}{arg}");
						}
					}
				}
				catch (Exception arg2)
				{
					LogSource.LogWarning((object)$"Problem loading Assembly, silently handled.{Environment.NewLine}{arg2}");
				}
			}
			return list;
		}

		public static void OnAddMapToDatabase(ZipArchive archive, string path, string mapName)
		{
			foreach (AGameMapStationPlugin plugin in GetPlugins())
			{
				plugin.OnAddMapToDatabase(archive, path, mapName);
			}
		}

		public static void OnReload()
		{
			foreach (AGameMapStationPlugin plugin in GetPlugins())
			{
				plugin.OnReload();
			}
		}
	}
	[RequireComponent(typeof(Camera))]
	public class MapStationCameraOverride : MonoBehaviour
	{
		public bool AlsoAffectPhoneCamera = true;

		private PostProcessLayer _layer;

		public static MapStationCameraOverride Instance { get; private set; }

		private void Awake()
		{
			Instance = this;
			Camera component = ((Component)this).GetComponent<Camera>();
			if ((Object)(object)component != (Object)null)
			{
				((Behaviour)component).enabled = false;
			}
			_layer = ((Component)this).GetComponent<PostProcessLayer>();
			if ((Object)(object)_layer != (Object)null)
			{
				((Behaviour)_layer).enabled = false;
			}
			AudioListener component2 = ((Component)this).GetComponent<AudioListener>();
			if ((Object)(object)component2 != (Object)null)
			{
				((Behaviour)component2).enabled = false;
			}
		}

		private void OnDestroy()
		{
			Instance = null;
		}

		public void ApplyToCamera(Camera camera)
		{
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_layer != (Object)null)
			{
				PostProcessLayer val = ((Component)camera).gameObject.GetComponent<PostProcessLayer>();
				if ((Object)(object)val == (Object)null)
				{
					val = ((Component)camera).gameObject.AddComponent<PostProcessLayer>();
				}
				val.finalBlitToCameraTarget = _layer.finalBlitToCameraTarget;
				val.stopNaNPropagation = _layer.stopNaNPropagation;
				val.volumeTrigger = ((Component)camera).transform;
				val.volumeLayer = _layer.volumeLayer;
				val.antialiasingMode = _layer.antialiasingMode;
				val.fastApproximateAntialiasing = _layer.fastApproximateAntialiasing;
				val.subpixelMorphologicalAntialiasing = _layer.subpixelMorphologicalAntialiasing;
				val.temporalAntialiasing = _layer.temporalAntialiasing;
				FieldInfo field = typeof(PostProcessLayer).GetField("m_Resources", BindingFlags.Instance | BindingFlags.NonPublic);
				field.SetValue(val, field.GetValue(_layer));
			}
		}
	}
}
namespace MapStation.Common.Runtime.Gameplay
{
	public class MapStationPublicToilet : MonoBehaviour
	{
		public Transform Exit;

		public Animator DoorAnimator;

		public GameObject GreenLight;

		public GameObject RedLight;

		private void Awake()
		{
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			Transform val = ((Component)this).transform.Find("Trigger");
			GameObject toilet = StagePrefabHijacker.Prefabs.GetToilet();
			PublicToilet component = toilet.GetComponent<PublicToilet>();
			Object.Destroy((Object)(object)((Component)((Component)component).transform.Find("OutHouse").Find("Cube.007")).gameObject);
			Object.Destroy((Object)(object)((Component)((Component)component).transform.Find("OutHouse").Find("Cube.001")).gameObject);
			Object.Destroy((Object)(object)((Component)((Component)component).transform.Find("Trigger")).gameObject);
			Object.Destroy((Object)(object)((Component)component.doorAnimator).gameObject);
			component.exit = Exit;
			component.doorAnimator = DoorAnimator;
			component.greenLight = GreenLight;
			component.redLight = RedLight;
			foreach (PlayableBinding output in component.sequence.playableAsset.outputs)
			{
				PlayableBinding current = output;
				if (((PlayableBinding)(ref current)).streamName == "Animation Track (3)")
				{
					component.sequence.SetGenericBinding(((PlayableBinding)(ref current)).sourceObject, (Object)(object)DoorAnimator);
					break;
				}
			}
			toilet.transform.SetParent(((Component)this).transform, false);
			toilet.transform.SetLocalPositionAndRotation(Vector3.zero, Quaternion.identity);
			((Component)val).transform.SetParent(toilet.transform, true);
		}
	}
}
namespace MapStation.Common.VanillaAssets
{
	public class DeleteVanillaGameObjectsV1 : MonoBehaviour
	{
		public class SList_Deletion : SList<Deletion>
		{
		}

		[Serializable]
		public class Deletion
		{
			public string Path;
		}

		private HashSet<GameObject> disabledGameObjects = new HashSet<GameObject>();

		[SerializeReference]
		private SList_Deletion deletions = new SList_Deletion();

		public static DeleteVanillaGameObjectsV1 Instance { get; private set; }

		private List<Deletion> Deletions => deletions.items;

		private void Awake()
		{
			if (!Application.isEditor)
			{
				Instance = this;
				DeleteGameObjects();
			}
		}

		public void DeleteGameObjects()
		{
			foreach (Deletion deletion in Deletions)
			{
				GameObject val = GameObject.Find(deletion.Path);
				if ((Object)(object)val == (Object)null)
				{
					Log.Info("DeleteVanillaGameObjectsV1 could not find GameObject to delete at path: " + deletion.Path);
				}
				else
				{
					HandleDeleteGameObject(val);
				}
			}
		}

		private void HandleDeleteGameObject(GameObject gameObject)
		{
			if ((Object)(object)gameObject.GetComponent<StreetLifeCluster>() != (Object)null)
			{
				DisableGameObject(gameObject);
			}
			else
			{
				Object.Destroy((Object)(object)gameObject);
			}
		}

		private void DisableGameObject(GameObject gameObject)
		{
			gameObject.SetActive(false);
			disabledGameObjects.Add(gameObject);
		}

		public bool IsDisabled(GameObject gameObject)
		{
			if (disabledGameObjects.Contains(gameObject))
			{
				return true;
			}
			return false;
		}
	}
	public class MoveVanillaGameObjectV1 : MonoBehaviour
	{
		public string moveThis;

		public Transform targetLocation;

		private void Awake()
		{
			if (!Application.isEditor)
			{
				MoveGameObject();
			}
		}

		public void MoveGameObject()
		{
			//IL_0017: 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)
			GameObject obj = GameObject.Find(moveThis);
			obj.transform.position = targetLocation.position;
			obj.transform.rotation = targetLocation.rotation;
		}
	}
	public class VanillaAssetReference : MonoBehaviour
	{
		public Component component;

		[TextArea(3, 10)]
		public List<string> fields = new List<string>();

		public const BindingFlags UseTheseBindingFlags = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.FlattenHierarchy;

		private void Awake()
		{
			AssignReferences();
		}

		public void AssignReferences()
		{
			if ((Object)(object)component == (Object)null)
			{
				return;
			}
			foreach (string field in fields)
			{
				int num = field.IndexOf("=");
				int num2 = field.IndexOf(":");
				string text = field.Substring(0, num);
				int num3 = -1;
				int num4 = text.IndexOf("[");
				if (num4 >= 0)
				{
					num3 = int.Parse(text.Substring(num4 + 1, -1));
					((Object)this).name = text.Substring(0, num4);
				}
				else
				{
					((Object)this).name = text;
				}
				string text2 = field.Substring(num + 1, num2 - num - 1);
				string text3 = field.Substring(num2 + 1);
				Object val = Core.Instance.Assets.LoadAssetFromBundle<Object>(text2, text3);
				if (val == (Object)null)
				{
					Log.Info(string.Format("{0}: Restoring reference to vanilla asset failed, asset not found: {1}.{2} = LoadAssetFromBundle(\"{3}\", \"{4}\")", "VanillaAssetReference", ((object)component).GetType().Name, ((Object)this).name, text2, text3));
					continue;
				}
				Type type = ((object)component).GetType();
				MemberInfo memberInfo = type.GetMember(((Object)this).name, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.FlattenHierarchy)[0];
				string text4 = string.Format("VanillaAssetReference: Assigning {0}.{1} = asset {2}:{3} (asset found={4}, field found={5}, asset type={6})", type.Name, text, text2, text3, val != (Object)null, memberInfo != null, (val != (Object)null) ? ((object)val).GetType().Name : "<not found>");
				try
				{
					if (num3 >= 0)
					{
						object obj = ((memberInfo is PropertyInfo propertyInfo) ? propertyInfo.GetValue(component) : ((FieldInfo)memberInfo).GetValue(component));
						obj.GetType().GetProperty("Item").SetValue(obj, val, new object[1] { num3 });
					}
					else if (memberInfo is PropertyInfo propertyInfo2)
					{
						propertyInfo2.SetValue(component, val);
					}
					else
					{
						((FieldInfo)memberInfo).SetValue(component, val);
					}
				}
				catch (Exception ex)
				{
					Log.Info(text4 + "\nFailed with error:\n" + ex.Message + "\n" + ex.StackTrace);
				}
			}
		}
	}
	public class VanillaAssetReferenceV2 : MonoBehaviour
	{
		public class SList_Components : SList<ComponentEntry>
		{
		}

		[SerializeReference]
		private SList_Components components = new SList_Components();

		public const BindingFlags UseTheseBindingFlags = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.FlattenHierarchy;

		private List<ComponentEntry> Components => components.items;

		private void Awake()
		{
			AssignReferences();
		}

		public void AssignReferences()
		{
			//IL_014a: Unknown result type (might be due to invalid IL or missing references)
			foreach (ComponentEntry component2 in Components)
			{
				Component component = component2.Component;
				foreach (FieldEntry field in component2.Fields)
				{
					Object val = null;
					Object[] array = null;
					if (field.SubAssetType == SubAssetType.FbxChild)
					{
						array = Core.Instance.Assets.availableBundles[field.BundleName].AssetBundle.LoadAssetWithSubAssets(field.Path);
					}
					else
					{
						val = Core.Instance.Assets.LoadAssetFromBundle<Object>(field.BundleName, field.Path);
					}
					if (val == (Object)null && array == null)
					{
						Log.Info(string.Format("{0}: Restoring reference to vanilla asset failed, asset not found: {1}.{2} = LoadAssetFromBundle(\"{3}\", \"{4}\")", "VanillaAssetReferenceV2", ((object)component).GetType().Name, field.Name, field.BundleName, field.Path));
						continue;
					}
					switch (field.SubAssetType)
					{
					case SubAssetType.FbxChild:
					{
						Object[] array2 = array;
						foreach (Object val2 in array2)
						{
							if (val2.name == field.SubPath && !(val2 is GameObject) && !(val2 is Component))
							{
								val = val2;
								break;
							}
						}
						break;
					}
					case SubAssetType.MixerGroup:
						val = (Object)(object)((AudioMixer)val).FindMatchingGroups(field.SubPath)[0];
						break;
					}
					if (val == (Object)null)
					{
						Log.Info(string.Format("{0}: Restoring reference to vanilla asset failed, sub-asset not found: {1}.{2} = LoadAssetFromBundle(\"{3}\", \"{4}\"); SubAssetType={5}; SubPath={6}", "VanillaAssetReferenceV2", ((object)component).GetType().Name, field.Name, field.BundleName, field.Path, field.SubAssetType.ToString(), field.SubPath));
						continue;
					}
					string message = "";
					try
					{
						if (component is Animation && field.Name == "AddClip")
						{
							AddAnimationClip(val, component, field, out message);
							continue;
						}
						AssignMember(val, component, field, out message);
						Animation val3 = (Animation)(object)((component is Animation) ? component : null);
						if ((Object)(object)val3 != (Object)null && field.Name == "clip" && val3.playAutomatically)
						{
							((MonoBehaviour)this).StartCoroutine(PlayAnimationAutomaticallyCoroutine(val3));
						}
					}
					catch (Exception ex)
					{
						Log.Info(message + "\nFailed with error:\n" + ex.Message + "\n" + ex.StackTrace);
					}
				}
			}
		}

		private IEnumerator PlayAnimationAutomaticallyCoroutine(Animation animationComponent)
		{
			yield return (object)new WaitForEndOfFrame();
			animationComponent.Play();
		}

		public static void AssignMember(Object asset, Component component, FieldEntry f, out string message)
		{
			Type type = ((object)component).GetType();
			MemberInfo memberInfo = type.GetMember(f.Name, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.FlattenHierarchy)[0];
			message = string.Format("{0}: Assigning {1}.{2} = asset {3}:{4} (asset found={5}, field found={6}, asset type={7})", "VanillaAssetReferenceV2", type.Name, f.PropertyPath, f.BundleName, f.Path, asset != (Object)null, memberInfo != null, (asset != (Object)null) ? ((object)asset).GetType().Name : "<not found>");
			if (f.Index >= 0)
			{
				IList list = (IList)((memberInfo is PropertyInfo propertyInfo) ? propertyInfo.GetValue(component) : ((FieldInfo)memberInfo).GetValue(component));
				list[f.Index] = asset;
				if (memberInfo is PropertyInfo)
				{
					((PropertyInfo)memberInfo).SetValue(component, list);
				}
				else
				{
					((FieldInfo)memberInfo).SetValue(component, list);
				}
			}
			else if (memberInfo is PropertyInfo propertyInfo2)
			{
				Object value = GetComponentFromPrefab(propertyInfo2.PropertyType, asset);
				propertyInfo2.SetValue(component, value);
			}
			else if (memberInfo is FieldInfo fieldInfo)
			{
				Object value2 = GetComponentFromPrefab(fieldInfo.FieldType, asset);
				fieldInfo.SetValue(component, value2);
			}
			else
			{
				Log.Info($"Unexpected member type: {memberInfo.MemberType}");
			}
			static Object GetComponentFromPrefab(Type FieldOrPropertyType, Object asset)
			{
				GameObject val = (GameObject)(object)((asset is GameObject) ? asset : null);
				if (val != null && FieldOrPropertyType.IsSubclassOf(typeof(Component)))
				{
					return (Object)(object)val.GetComponent(FieldOrPropertyType);
				}
				return asset;
			}
		}

		public static void AddAnimationClip(Object asset, Component component, FieldEntry f, out string message)
		{
			message = "VanillaAssetReferenceV2: Animation.AddClip(asset, " + asset.name + ") where asset is " + f.BundleName + ":" + f.Path + ((f.SubPath != null) ? (":" + f.SubPath) : "") + " (asset type=" + ((asset != (Object)null) ? ((object)asset).GetType().Name : "<not found>") + ")";
			((Animation)((component is Animation) ? component : null)).AddClip((AnimationClip)(object)((asset is AnimationClip) ? asset : null), asset.name);
		}
	}
	[Serializable]
	public class ComponentEntry
	{
		private class SList_FieldEntry : SList<FieldEntry>
		{
		}

		[SerializeField]
		public Component Component;

		[SerializeReference]
		private SList_FieldEntry fields = new SList_FieldEntry();

		public List<FieldEntry> Fields => fields.items;
	}
	[Serializable]
	public class FieldEntry
	{
		[HideInInspector]
		[SerializeField]
		public bool Enabled = true;

		[HideInInspector]
		[SerializeField]
		public bool AutoSync = true;

		[SerializeField]
		public string Name;

		[SerializeField]
		public int Index = -1;

		[SerializeField]
		public string BundleName;

		[SerializeField]
		public string Path;

		[SerializeField]
		public SubAssetType SubAssetType;

		[SerializeField]
		public string SubPath = "";

		public string PropertyPath
		{
			get
			{
				if (Index < 0)
				{
					return Name;
				}
				return $"{Name}[{Index}]";
			}
		}
	}
	public enum SubAssetType
	{
		None,
		MixerGroup,
		FbxChild
	}
}
namespace MapStation.Common.Dependencies
{
	public class AssemblyDependencies
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	internal sealed class IgnoresAccessChecksToAttribute : Attribute
	{
		public IgnoresAccessChecksToAttribute(string assemblyName)
		{
		}
	}
}