using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security.Cryptography;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using DunGen;
using DunGen.Adapters;
using DunGen.Graph;
using GameNetcodeStuff;
using HarmonyLib;
using LethalExpansionCore.MonoBehaviours;
using LethalExpansionCore.Netcode;
using LethalExpansionCore.Patches;
using LethalExpansionCore.Utils;
using LethalSDK.Component;
using LethalSDK.ScriptableObjects;
using LethalSDK.Utils;
using Microsoft.CodeAnalysis;
using TMPro;
using Unity.AI.Navigation;
using Unity.Netcode;
using Unity.Netcode.Components;
using UnityEngine;
using UnityEngine.AI;
using UnityEngine.Audio;
using UnityEngine.Events;
using UnityEngine.Rendering;
using UnityEngine.Rendering.HighDefinition;
using UnityEngine.SceneManagement;
using UnityEngine.Video;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyTitle("LethalExpansionCore")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("LethalExpansionCore")]
[assembly: AssemblyCopyright("Copyright ©  2023")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("cbb249e6-fea3-431f-bd6a-ff05f9616e3a")]
[assembly: AssemblyFileVersion("1.3.18")]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyVersion("1.3.18.0")]
[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;
		}
	}
}
public class AutoScrollText : MonoBehaviour
{
	public TextMeshProUGUI textMeshPro;

	public float scrollSpeed = 15f;

	private Vector2 startPosition;

	private float textHeight;

	private bool startScrolling = false;

	private bool isWaitingToReset = false;

	private float displayHeight;

	private float fontSize;

	private void Start()
	{
		textMeshPro = ((Component)this).GetComponent<TextMeshProUGUI>();
		InitializeScrolling();
	}

	private void InitializeScrolling()
	{
		//IL_001e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0023: Unknown result type (might be due to invalid IL or missing references)
		//IL_0045: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)textMeshPro != (Object)null)
		{
			startPosition = ((TMP_Text)textMeshPro).rectTransform.anchoredPosition;
			textHeight = ((TMP_Text)textMeshPro).preferredHeight;
			displayHeight = ((TMP_Text)textMeshPro).rectTransform.sizeDelta.y;
			fontSize = ((TMP_Text)textMeshPro).fontSize;
		}
		((MonoBehaviour)this).StartCoroutine(WaitBeforeScrolling(5f));
	}

	private IEnumerator WaitBeforeScrolling(float waitTime)
	{
		yield return (object)new WaitForSeconds(waitTime);
		startScrolling = true;
	}

	private IEnumerator WaitBeforeResetting(float waitTime)
	{
		isWaitingToReset = true;
		yield return (object)new WaitForSeconds(waitTime);
		((TMP_Text)textMeshPro).rectTransform.anchoredPosition = startPosition;
		isWaitingToReset = false;
		((MonoBehaviour)this).StartCoroutine(WaitBeforeScrolling(5f));
	}

	private void Update()
	{
		//IL_0037: Unknown result type (might be due to invalid IL or missing references)
		//IL_004d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0052: 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)
		if ((Object)(object)textMeshPro != (Object)null && startScrolling && !isWaitingToReset)
		{
			RectTransform rectTransform = ((TMP_Text)textMeshPro).rectTransform;
			rectTransform.anchoredPosition += new Vector2(0f, scrollSpeed * Time.deltaTime);
			if (((TMP_Text)textMeshPro).rectTransform.anchoredPosition.y >= startPosition.y + textHeight - displayHeight - fontSize)
			{
				startScrolling = false;
				((MonoBehaviour)this).StartCoroutine(WaitBeforeResetting(5f));
			}
		}
	}

	public void ResetScrolling()
	{
		//IL_0025: Unknown result type (might be due to invalid IL or missing references)
		((MonoBehaviour)this).StopAllCoroutines();
		if ((Object)(object)textMeshPro != (Object)null)
		{
			((TMP_Text)textMeshPro).rectTransform.anchoredPosition = startPosition;
		}
		isWaitingToReset = false;
		InitializeScrolling();
	}
}
namespace LethalExpansionCore
{
	public static class PluginInformation
	{
		public const string PLUGIN_GUID = "com.github.lethalmods.lethalexpansioncorepatch";

		public const string PLUGIN_NAME = "LethalExpansion(core) - Patched";

		public const string PLUGIN_VERSION = "1.3.18";
	}
	[BepInPlugin("com.github.lethalmods.lethalexpansioncorepatch", "LethalExpansion(core) - Patched", "1.3.18")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class LethalExpansion : BaseUnityPlugin
	{
		public static class Settings
		{
			public static ConfigEntry<bool> IgnoreRequiredBundles;

			public static ConfigEntry<bool> UseOriginalLethalExpansion;

			public static ConfigEntry<bool> LoadDefaultBundles;

			public static ConfigEntry<bool> DebugLogs;

			public static ConfigEntry<string> ExcludedMoons;

			public static ConfigEntry<string> ExcludedScrap;

			public static ConfigEntry<bool> ShowVersionNumberOnMainMenu;

			public static void Bind(ConfigFile config)
			{
				IgnoreRequiredBundles = config.Bind<bool>("Core", "IgnoreRequiredBundles", true, "Whether or not to allow a bundle to load without its required bundles");
				UseOriginalLethalExpansion = config.Bind<bool>("Core", "UseOriginalLethalExpansion", false, "Whether or not to use the original LethalExpansion instead of LethalExpansion(core) when they are both loaded");
				LoadDefaultBundles = config.Bind<bool>("Core", "LoadDefaultBundles", false, "Whether or not to load the default bundles from LethalExpansion when both LethalExpansion and LethalExpansion(core) are present");
				ExcludedMoons = config.Bind<string>("Moons & Scrap", "ExcludedMoons", "hidden", "Comma separated list of LethalExpansion based moons to exclude from the game, use `hidden` (without `) to remove all the hidden moons (better LLL compatibility)");
				ExcludedScrap = config.Bind<string>("Moons & Scrap", "ExcludedScrap", "", "Comma separated list of LethalExpansion based scrap to exclude from the game");
				ShowVersionNumberOnMainMenu = config.Bind<bool>("Main Menu", "ShowVersionNumberOnMainMenu", true, "Set true to show the version number of LethalExpansionCore on the main menu");
				DebugLogs = config.Bind<bool>("Debug", "DebugLogs", false, "Debug logs :D");
			}
		}

		public static readonly Version ModVersion = new Version("1.3.18");

		public static string LethalExpansionPath = null;

		public static bool isInGame = false;

		public static ManualLogSource Log;

		public static ManualLogSource DebugLog;

		public static NetworkManager networkManager;

		public GameObject terrainFixer;

		public static Transform currentWaterSurface;

		private int width = 256;

		private int height = 256;

		private int depth = 20;

		private float scale = 20f;

		private static bool LethalExpansion_Awake()
		{
			Log.LogInfo((object)"Prevented LethalExpansion from initializing");
			return false;
		}

		private static Assembly LoadLethalExpansion()
		{
			try
			{
				Assembly assembly = AppDomain.CurrentDomain.Load("LethalExpansion");
				Log.LogInfo((object)$"Loaded LethalExpansion: {assembly}");
				return assembly;
			}
			catch (FileNotFoundException)
			{
				return null;
			}
		}

		private static void PatchLethalExpansion(Harmony harmony, Assembly assembly)
		{
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Expected O, but got Unknown
			if (assembly == null)
			{
				Log.LogInfo((object)"LethalExpansion is not present, all is well!");
				return;
			}
			Type type = assembly.GetType("LethalExpansion.LethalExpansion");
			MethodInfo method = type.GetMethod("Awake", BindingFlags.Instance | BindingFlags.NonPublic);
			MethodInfo method2 = typeof(LethalExpansion).GetMethod("LethalExpansion_Awake", BindingFlags.Static | BindingFlags.NonPublic);
			harmony.Patch((MethodBase)method, new HarmonyMethod(method2), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			Log.LogInfo((object)"Patched LethalExpansion#Awake");
		}

		private void Awake()
		{
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Expected O, but got Unknown
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Expected O, but got Unknown
			//IL_01ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bb: Unknown result type (might be due to invalid IL or missing references)
			Log = ((BaseUnityPlugin)this).Logger;
			Log.LogInfo((object)"Plugin: LethalExpansion(core) - Patched (version: 1.3.18) is loading...");
			Settings.Bind(((BaseUnityPlugin)this).Config);
			if (Settings.DebugLogs.Value)
			{
				DebugLog = Log;
			}
			else
			{
				DebugLog = new ManualLogSource(Log.SourceName);
			}
			Assembly assembly = LoadLethalExpansion();
			if (assembly != null)
			{
				if (Settings.UseOriginalLethalExpansion.Value)
				{
					Log.LogInfo((object)"Using original LethalExpansion instead");
					return;
				}
				LethalExpansionPath = Path.GetDirectoryName(assembly.Location);
			}
			Harmony val = new Harmony("com.github.lethalmods.lethalexpansioncorepatch");
			PatchLethalExpansion(val, assembly);
			AssetBundlesManager.Instance.LoadAllAssetBundles();
			SceneManager.sceneLoaded += OnSceneLoaded;
			SceneManager.sceneUnloaded += OnSceneUnloaded;
			val.PatchAll(typeof(GameNetworkManager_Patch));
			val.PatchAll(typeof(Terminal_Patch));
			val.PatchAll(typeof(MenuManager_Patch));
			val.PatchAll(typeof(RoundManager_Patch));
			val.PatchAll(typeof(StartOfRound_Patch));
			val.PatchAll(typeof(EntranceTeleport_Patch));
			val.PatchAll(typeof(AudioReverbTrigger_Patch));
			val.PatchAll(typeof(InteractTrigger_Patch));
			val.PatchAll(typeof(DungeonGenerator_Patch));
			val.PatchAll(typeof(RuntimeDungeon));
			RenderPipelineAsset currentRenderPipeline = GraphicsSettings.currentRenderPipeline;
			HDRenderPipelineAsset val2 = (HDRenderPipelineAsset)(object)((currentRenderPipeline is HDRenderPipelineAsset) ? currentRenderPipeline : null);
			if ((Object)(object)val2 != (Object)null)
			{
				RenderPipelineSettings currentPlatformRenderPipelineSettings = val2.currentPlatformRenderPipelineSettings;
				currentPlatformRenderPipelineSettings.supportWater = true;
				val2.currentPlatformRenderPipelineSettings = currentPlatformRenderPipelineSettings;
				Log.LogInfo((object)"Water support applied to the HDRenderPipelineAsset.");
			}
			else
			{
				Log.LogError((object)"HDRenderPipelineAsset not found.");
			}
			Log.LogInfo((object)"Plugin: LethalExpansion(core) - Patched (version: 1.3.18) is loaded.");
			Log.LogError((object)"This patch is no longer needed, as the preview version of LethalExpansion now supports v50: https://thunderstore.io/c/lethal-company/p/HolographicWings/LethalExpansion_Preview/");
		}

		private float[,] GenerateHeights()
		{
			float[,] array = new float[width, height];
			for (int i = 0; i < width; i++)
			{
				for (int j = 0; j < height; j++)
				{
					array[i, j] = CalculateHeight(i, j);
				}
			}
			return array;
		}

		private float CalculateHeight(int x, int y)
		{
			float num = (float)x / (float)width * scale;
			float num2 = (float)y / (float)height * scale;
			return Mathf.PerlinNoise(num, num2);
		}

		private void OnSceneLoaded(Scene scene, LoadSceneMode mode)
		{
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			Log.LogInfo((object)("Loading scene '" + ((Scene)(ref scene)).name + "'"));
			try
			{
				if (((Scene)(ref scene)).name == "InitScene")
				{
					networkManager = GameObject.Find("NetworkManager").GetComponent<NetworkManager>();
				}
				else if (((Scene)(ref scene)).name == "MainMenu")
				{
					OnMainMenuLoaded(scene);
				}
				else if (((Scene)(ref scene)).name == "CompanyBuilding" || ((Scene)(ref scene)).name.StartsWith("Level"))
				{
					terrainFixer.SetActive(false);
					Log.LogInfo((object)"Disabled TerrainFixer");
				}
				else if (((Scene)(ref scene)).name == "SampleSceneRelay")
				{
					OnSampleSceneRelayLoaded(scene);
				}
				else if (((Scene)(ref scene)).name == "InitSceneLaunchOptions" && isInGame)
				{
					OnInitSceneLaunchOptionsLoaded(scene);
				}
			}
			catch (Exception arg)
			{
				Log.LogError((object)$"Something went wrong when loading scene '{((Scene)(ref scene)).name}'. {arg}");
			}
		}

		private void OnMainMenuLoaded(Scene scene)
		{
			isInGame = false;
			AssetGather.Instance.AddAudioMixer(GameObject.Find("Canvas/MenuManager").GetComponent<AudioSource>().outputAudioMixerGroup.audioMixer);
		}

		private void OnSampleSceneRelayLoaded(Scene scene)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = Object.Instantiate<GameObject>(GameObject.Find("Systems/GameSystems/TimeAndWeather/Flooding"));
			Object.Destroy((Object)(object)val.GetComponent<FloodWeather>());
			((Object)val).name = "WaterSurface";
			val.transform.position = Vector3.zero;
			((Component)val.transform.Find("Water")).GetComponent<MeshFilter>().sharedMesh = null;
			SpawnPrefab.Instance.waterSurface = val;
			((Component)StartOfRound.Instance.screenLevelDescription).gameObject.AddComponent<AutoScrollText>();
			AssetGather.Instance.AddAudioMixer(GameObject.Find("Systems/Audios/DiageticBackground").GetComponent<AudioSource>().outputAudioMixerGroup.audioMixer);
			SetupTerrainFixer();
			Object[] array = Resources.FindObjectsOfTypeAll(typeof(Volume));
			foreach (Object obj in array)
			{
				Volume val2 = (Volume)(object)((obj is Volume) ? obj : null);
				if (!((Object)(object)val2.sharedProfile != (Object)null))
				{
					val2.sharedProfile = AssetBundlesManager.Instance.mainAssetBundle.LoadAsset<VolumeProfile>("Assets/Mods/LethalExpansion/Sky and Fog Global Volume Profile.asset");
				}
			}
			isInGame = true;
		}

		private void SetupTerrainFixer()
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_0037: 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_0048: Expected O, but got Unknown
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			terrainFixer = new GameObject();
			((Object)terrainFixer).name = "terrainfixer";
			terrainFixer.transform.position = new Vector3(0f, -500f, 0f);
			TerrainData val = new TerrainData();
			val.heightmapResolution = width + 1;
			val.size = new Vector3((float)width, (float)depth, (float)height);
			val.SetHeights(0, 0, GenerateHeights());
			Terrain val2 = terrainFixer.AddComponent<Terrain>();
			val2.terrainData = val;
		}

		private void OnInitSceneLaunchOptionsLoaded(Scene scene)
		{
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02aa: 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)
			//IL_013f: Expected O, but got Unknown
			//IL_0169: 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_032e: Unknown result type (might be due to invalid IL or missing references)
			//IL_034f: Unknown result type (might be due to invalid IL or missing references)
			//IL_039a: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0405: Unknown result type (might be due to invalid IL or missing references)
			terrainFixer.SetActive(false);
			if (!Terminal_Patch.newMoons.ContainsKey(RoundManager.Instance.currentLevel.levelID))
			{
				Log.LogInfo((object)("Skipped custom moon loading in InitSceneLaunchOptions for moon '" + RoundManager.Instance.currentLevel.PlanetName + "', it is not our moon"));
				return;
			}
			Log.LogInfo((object)"OnInitSceneLaunchOptionsLoaded");
			GameObject[] rootGameObjects = ((Scene)(ref scene)).GetRootGameObjects();
			foreach (GameObject val in rootGameObjects)
			{
				val.SetActive(false);
			}
			LoadCustomMoon(scene);
			string[] array = new string[5] { "MapPropsContainer", "OutsideAINode", "SpawnDenialPoint", "ItemShipLandingNode", "OutsideLevelNavMesh" };
			string[] array2 = array;
			foreach (string text in array2)
			{
				if ((Object)(object)GameObject.FindGameObjectWithTag(text) == (Object)null || GameObject.FindGameObjectsWithTag(text).Any(delegate(GameObject o)
				{
					//IL_0001: Unknown result type (might be due to invalid IL or missing references)
					//IL_0006: Unknown result type (might be due to invalid IL or missing references)
					Scene scene2 = o.scene;
					return ((Scene)(ref scene2)).name != "InitSceneLaunchOptions";
				}))
				{
					GameObject val2 = new GameObject();
					((Object)val2).name = text;
					val2.tag = text;
					val2.transform.position = new Vector3(0f, -200f, 0f);
					SceneManager.MoveGameObjectToScene(val2, scene);
					Log.LogInfo((object)("Added required object with tag '" + text + "'"));
				}
			}
			GameObject val3 = GameObject.Find("ItemShipAnimContainer");
			if ((Object)(object)val3 != (Object)null)
			{
				Transform val4 = val3.transform.Find("ItemShip");
				if ((Object)(object)val4 != (Object)null)
				{
					((Component)val4).GetComponent<AudioSource>().outputAudioMixerGroup = AssetGather.Instance.GetDiageticMasterAudioMixer();
				}
				Transform val5 = val3.transform.Find("ItemShip/Music");
				if ((Object)(object)val5 != (Object)null)
				{
					((Component)val5).GetComponent<AudioSource>().outputAudioMixerGroup = AssetGather.Instance.GetDiageticMasterAudioMixer();
				}
				Transform val6 = val3.transform.Find("ItemShip/Music/Music (1)");
				if ((Object)(object)val6 != (Object)null)
				{
					((Component)val6).GetComponent<AudioSource>().outputAudioMixerGroup = AssetGather.Instance.GetDiageticMasterAudioMixer();
				}
			}
			RuntimeDungeon val7 = Object.FindObjectOfType<RuntimeDungeon>(false);
			if ((Object)(object)val7 == (Object)null)
			{
				Log.LogInfo((object)"Adding 'DungeonGenerator'");
				GameObject val8 = CreateDungeonGenerator();
				val7 = val8.GetComponent<RuntimeDungeon>();
				SceneManager.MoveGameObjectToScene(val8, scene);
			}
			else if ((Object)(object)val7.Generator.DungeonFlow == (Object)null)
			{
				val7.Generator.DungeonFlow = RoundManager.Instance.dungeonFlowTypes[0].dungeonFlow;
				Log.LogInfo((object)"Setting missing DungeonFlow in DungeonGenerator");
			}
			GameObject val9 = GameObject.CreatePrimitive((PrimitiveType)3);
			((Object)val9).name = "OutOfBounds";
			val9.layer = 13;
			val9.transform.position = new Vector3(0f, -300f, 0f);
			val9.transform.localScale = new Vector3(1000f, 5f, 1000f);
			BoxCollider component = val9.GetComponent<BoxCollider>();
			((Collider)component).isTrigger = true;
			val9.AddComponent<OutOfBoundsTrigger>();
			Rigidbody val10 = val9.AddComponent<Rigidbody>();
			val10.useGravity = false;
			val10.isKinematic = true;
			val10.collisionDetectionMode = (CollisionDetectionMode)1;
			SceneManager.MoveGameObjectToScene(val9, scene);
			WaitForEntrancesSync(scene).GetAwaiter();
			EntranceTeleport[] array3 = Object.FindObjectsOfType<EntranceTeleport>();
			Log.LogInfo((object)$"Moving {array3.Length} EntranceTeleport(s) to scene");
			EntranceTeleport[] array4 = array3;
			foreach (EntranceTeleport val11 in array4)
			{
				if ((Object)(object)((Component)val11).transform.parent == (Object)null)
				{
					SceneManager.MoveGameObjectToScene(((Component)val11).gameObject, scene);
				}
			}
		}

		private async Task WaitForEntrancesSync(Scene scene)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			int expectedEntranceTeleports = 0;
			GameObject[] rootGameObjects = ((Scene)(ref scene)).GetRootGameObjects();
			foreach (GameObject root in rootGameObjects)
			{
				LECore_InactiveNetworkPrefabInstancier[] componentsInChildren = root.GetComponentsInChildren<LECore_InactiveNetworkPrefabInstancier>(true);
				foreach (LECore_InactiveNetworkPrefabInstancier instancier in componentsInChildren)
				{
					GameObject prefab = instancier.prefab;
					if (!((Object)(object)((prefab != null) ? prefab.GetComponent<SI_EntranceTeleport>() : null) == (Object)null))
					{
						expectedEntranceTeleports++;
					}
				}
			}
			Log.LogInfo((object)$"Expecting {expectedEntranceTeleports} EntranceTeleports");
			if (expectedEntranceTeleports == 0)
			{
				return;
			}
			double maxSyncTime = 2.0;
			double timeStarted = Time.timeAsDouble;
			while (true)
			{
				EntranceTeleport[] entranceTeleports = Object.FindObjectsOfType<EntranceTeleport>();
				if (entranceTeleports.Length == expectedEntranceTeleports)
				{
					Log.LogInfo((object)$"EntranceTeleports was synced in {(Time.timeAsDouble - timeStarted) * 1000.0}ms");
					return;
				}
				if (Time.timeAsDouble - timeStarted > maxSyncTime)
				{
					break;
				}
				await Task.Delay(25);
			}
			Log.LogWarning((object)"Failed to sync EntranceTeleports in time, this may have unintended consequences");
		}

		private GameObject CreateDungeonGenerator()
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: 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)
			GameObject val = new GameObject();
			((Object)val).name = "DungeonGenerator";
			val.tag = "DungeonGenerator";
			val.transform.position = new Vector3(0f, -200f, 0f);
			RuntimeDungeon val2 = val.AddComponent<RuntimeDungeon>();
			val2.Generator.DungeonFlow = RoundManager.Instance.dungeonFlowTypes[0].dungeonFlow;
			val2.Generator.LengthMultiplier = 0.8f;
			val2.Generator.PauseBetweenRooms = 0.2f;
			val2.GenerateOnStart = false;
			val2.Root = val;
			UnityNavMeshAdapter val3 = val.AddComponent<UnityNavMeshAdapter>();
			val3.BakeMode = (RuntimeNavMeshBakeMode)3;
			val3.LayerMask = LayerMask.op_Implicit(35072);
			return val;
		}

		private void LoadCustomMoon(Scene scene)
		{
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			GameObject mainPrefab = Terminal_Patch.newMoons[StartOfRound.Instance.currentLevelID].MainPrefab;
			if ((Object)(object)mainPrefab == (Object)null || (Object)(object)mainPrefab.transform == (Object)null)
			{
				return;
			}
			ComponentWhitelist.CheckAndRemoveIllegalComponents(mainPrefab.transform, ComponentWhitelist.MoonPrefabComponentWhitelist);
			GameObject val = Object.Instantiate<GameObject>(mainPrefab);
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			currentWaterSurface = val.transform.Find("Environment/Water");
			SceneManager.MoveGameObjectToScene(val, scene);
			Transform val2 = val.transform.Find("Systems/Audio/DiageticBackground");
			if ((Object)(object)val2 != (Object)null)
			{
				((Component)val2).GetComponent<AudioSource>().outputAudioMixerGroup = AssetGather.Instance.GetDiageticMasterAudioMixer();
			}
			Terrain[] componentsInChildren = val.GetComponentsInChildren<Terrain>();
			if (componentsInChildren != null && componentsInChildren.Length != 0)
			{
				Terrain[] array = componentsInChildren;
				foreach (Terrain val3 in array)
				{
					val3.drawInstanced = true;
				}
			}
		}

		private void OnSceneUnloaded(Scene scene)
		{
			if (((Scene)(ref scene)).name.Length > 0)
			{
				Log.LogInfo((object)("Unloading scene: " + ((Scene)(ref scene)).name));
			}
			if (((Scene)(ref scene)).name.StartsWith("Level") || ((Scene)(ref scene)).name == "CompanyBuilding" || (((Scene)(ref scene)).name == "InitSceneLaunchOptions" && isInGame))
			{
				currentWaterSurface = null;
			}
		}
	}
	public static class PluginInfo
	{
		public const string PLUGIN_GUID = "LethalExpansionCore";

		public const string PLUGIN_NAME = "";

		public const string PLUGIN_VERSION = "1.0.0.0";
	}
}
namespace LethalExpansionCore.Utils
{
	public class AssetBundlesManager
	{
		private static AssetBundlesManager _instance;

		public AssetBundle mainAssetBundle = AssetBundle.LoadFromFile(Assembly.GetExecutingAssembly().Location.Replace("LethalExpansionCore.dll", "lethalexpansion.lem"));

		public Dictionary<string, (AssetBundle, ModManifest)> assetBundles = new Dictionary<string, (AssetBundle, ModManifest)>();

		public Dictionary<string, (AssetBundle, ModManifest)> contentAssetBundles = new Dictionary<string, (AssetBundle, ModManifest)>();

		public DirectoryInfo modPath = new DirectoryInfo(Assembly.GetExecutingAssembly().Location);

		public DirectoryInfo modDirectory;

		public DirectoryInfo pluginsDirectory;

		public static AssetBundlesManager Instance
		{
			get
			{
				if (_instance == null)
				{
					_instance = new AssetBundlesManager();
				}
				return _instance;
			}
		}

		public (AssetBundle, ModManifest) Load(string name)
		{
			return assetBundles[name.ToLower()];
		}

		public void LoadAllAssetBundles()
		{
			modDirectory = modPath.Parent;
			pluginsDirectory = modDirectory;
			while (pluginsDirectory != null && pluginsDirectory.Name != "plugins")
			{
				pluginsDirectory = pluginsDirectory.Parent;
			}
			if (pluginsDirectory == null)
			{
				LethalExpansion.Log.LogWarning((object)"Mod is not in a plugins folder.");
				return;
			}
			LethalExpansion.Log.LogInfo((object)("Plugins folder found: " + pluginsDirectory.FullName));
			LethalExpansion.Log.LogInfo((object)("Mod path is: " + modDirectory.FullName));
			if (modDirectory.FullName == pluginsDirectory.FullName)
			{
				LethalExpansion.Log.LogWarning((object)("LethalExpansion is Rooting the Plugins folder, this is not recommended. " + modDirectory.FullName));
			}
			string[] files = Directory.GetFiles(pluginsDirectory.FullName, "*.lem", SearchOption.AllDirectories);
			foreach (string file in files)
			{
				LoadBundle(file);
			}
		}

		public void LoadBundle(string file)
		{
			string fileName = Path.GetFileName(file);
			if (fileName == "lethalexpansion.lem")
			{
				return;
			}
			string text = Path.GetFileNameWithoutExtension(file).ToLower();
			if (assetBundles.ContainsKey(text))
			{
				LethalExpansion.Log.LogWarning((object)("An AssetBundle with the same name '" + fileName + "' has already been loaded"));
				return;
			}
			Stopwatch stopwatch = new Stopwatch();
			AssetBundle val = null;
			try
			{
				stopwatch.Start();
				val = AssetBundle.LoadFromFile(file);
				stopwatch.Stop();
			}
			catch (Exception ex)
			{
				LethalExpansion.Log.LogError((object)ex);
			}
			if ((Object)(object)val == (Object)null)
			{
				LethalExpansion.Log.LogWarning((object)("File '" + fileName + "' is not an AssetBundle"));
				return;
			}
			string text2 = "Assets/Mods/" + text + "/ModManifest.asset";
			ModManifest modManifest = val.LoadAsset<ModManifest>(text2);
			if ((Object)(object)modManifest == (Object)null)
			{
				LethalExpansion.Log.LogWarning((object)("AssetBundle '" + fileName + "' does not have a ModManifest"));
				val.Unload(true);
				LethalExpansion.Log.LogInfo((object)("AssetBundle '" + fileName + "' unloaded"));
				return;
			}
			if (assetBundles.Any((KeyValuePair<string, (AssetBundle, ModManifest)> b) => b.Value.Item2.modName == modManifest.modName))
			{
				LethalExpansion.Log.LogWarning((object)("Another mod with same name '" + modManifest.modName + "' is already loaded"));
				val.Unload(true);
				LethalExpansion.Log.LogInfo((object)("AssetBundle '" + fileName + "' unloaded"));
				return;
			}
			ManualLogSource log = LethalExpansion.Log;
			string modName = modManifest.modName;
			ModManifest obj = modManifest;
			log.LogInfo((object)string.Format("Module '{0}' v{1} was loaded in {2}ms", modName, ((obj == null) ? null : ((object)obj.GetVersion())?.ToString()) ?? "0.0.0.0", stopwatch.ElapsedMilliseconds));
			if (modManifest.GetVersion() == null || ((object)modManifest.GetVersion()).ToString() == "0.0.0.0")
			{
				LethalExpansion.Log.LogWarning((object)("Module '" + modManifest.modName + "' does not have a version number, this is unsafe!"));
			}
			assetBundles.Add(text, (val, modManifest));
			if (!LethalExpansion.Settings.LoadDefaultBundles.Value && LethalExpansion.LethalExpansionPath != null && Path.GetDirectoryName(file).StartsWith(LethalExpansion.LethalExpansionPath))
			{
				LethalExpansion.Log.LogWarning((object)("Ignorning content from default AssetBundle '" + fileName + "'"));
			}
			else
			{
				contentAssetBundles.Add(text, (val, modManifest));
			}
		}

		public bool BundleLoaded(string bundleName)
		{
			return assetBundles.ContainsKey(bundleName.ToLower());
		}

		public IEnumerable<string> GetMissingBundles(string[] bundleNames)
		{
			foreach (string bundleName in bundleNames)
			{
				if (!assetBundles.ContainsKey(bundleName.ToLower()))
				{
					yield return bundleName;
				}
			}
		}

		public IEnumerable<string> GetLoadedBundles(string[] bundleNames)
		{
			foreach (string bundleName in bundleNames)
			{
				if (assetBundles.ContainsKey(bundleName.ToLower()))
				{
					yield return bundleName;
				}
			}
		}

		public bool BundlesLoaded(string[] bundleNames)
		{
			foreach (string text in bundleNames)
			{
				if (!assetBundles.ContainsKey(text.ToLower()))
				{
					return false;
				}
			}
			return true;
		}

		public bool IncompatibleBundlesLoaded(string[] bundleNames)
		{
			foreach (string text in bundleNames)
			{
				if (assetBundles.ContainsKey(text.ToLower()))
				{
					return true;
				}
			}
			return false;
		}

		public bool IsScrapCompatible(Scrap scrap)
		{
			if ((Object)(object)scrap == (Object)null || (Object)(object)scrap.prefab == (Object)null)
			{
				return false;
			}
			if (scrap.RequiredBundles != null)
			{
				List<string> list = Instance.GetMissingBundles(scrap.RequiredBundles).ToList();
				if (list.Count > 0)
				{
					if (!LethalExpansion.Settings.IgnoreRequiredBundles.Value)
					{
						LethalExpansion.Log.LogWarning((object)("Scrap '" + scrap.itemName + "' can't be added, missing required bundles: " + string.Join(", ", list)));
						return false;
					}
					LethalExpansion.Log.LogWarning((object)("Scrap '" + scrap.itemName + "' may not work as intended, missing required bundles: " + string.Join(", ", list)));
				}
			}
			if (scrap.IncompatibleBundles != null)
			{
				List<string> list2 = Instance.GetLoadedBundles(scrap.IncompatibleBundles).ToList();
				if (list2.Count > 0)
				{
					LethalExpansion.Log.LogWarning((object)("Scrap '" + scrap.itemName + "' can't be added, incompatible bundles: " + string.Join(", ", list2)));
					return false;
				}
			}
			return true;
		}

		public bool IsMoonCompatible(Moon moon)
		{
			if ((Object)(object)moon == (Object)null || !moon.IsEnabled)
			{
				return false;
			}
			if (moon.RequiredBundles != null)
			{
				List<string> list = Instance.GetMissingBundles(moon.RequiredBundles).ToList();
				if (list.Count > 0)
				{
					if (!LethalExpansion.Settings.IgnoreRequiredBundles.Value)
					{
						LethalExpansion.Log.LogWarning((object)("Moon '" + moon.MoonName + "' can't be added, missing required bundles: " + string.Join(", ", list)));
						return false;
					}
					LethalExpansion.Log.LogWarning((object)("Moon '" + moon.MoonName + "' may not work as intended, missing required bundles: " + string.Join(", ", list)));
				}
			}
			if (moon.IncompatibleBundles != null)
			{
				List<string> list2 = Instance.GetLoadedBundles(moon.IncompatibleBundles).ToList();
				if (list2.Count > 0)
				{
					LethalExpansion.Log.LogWarning((object)("Moon '" + moon.MoonName + "' can't be added, incompatible bundles: " + string.Join(", ", list2)));
					return false;
				}
			}
			return true;
		}
	}
	public class AssetGather
	{
		private static AssetGather _instance;

		public Dictionary<string, AudioClip> audioClips = new Dictionary<string, AudioClip>();

		public Dictionary<string, (AudioMixer, AudioMixerGroup[])> audioMixers = new Dictionary<string, (AudioMixer, AudioMixerGroup[])>();

		public Dictionary<string, GameObject> planetPrefabs = new Dictionary<string, GameObject>();

		public Dictionary<string, GameObject> mapObjects = new Dictionary<string, GameObject>();

		public Dictionary<string, SpawnableOutsideObject> outsideObjects = new Dictionary<string, SpawnableOutsideObject>();

		public Dictionary<string, Item> scraps = new Dictionary<string, Item>();

		public Dictionary<string, LevelAmbienceLibrary> levelAmbiances = new Dictionary<string, LevelAmbienceLibrary>();

		public Dictionary<string, EnemyType> enemies = new Dictionary<string, EnemyType>();

		public Dictionary<string, Sprite> sprites = new Dictionary<string, Sprite>();

		public static AssetGather Instance
		{
			get
			{
				if (_instance == null)
				{
					_instance = new AssetGather();
				}
				return _instance;
			}
		}

		public void GetList()
		{
			LethalExpansion.Log.LogInfo((object)"Audio Clips");
			foreach (KeyValuePair<string, AudioClip> audioClip in audioClips)
			{
				LethalExpansion.Log.LogInfo((object)audioClip.Key);
			}
			LethalExpansion.Log.LogInfo((object)"Audio Mixers");
			foreach (KeyValuePair<string, (AudioMixer, AudioMixerGroup[])> audioMixer in audioMixers)
			{
				LethalExpansion.Log.LogInfo((object)audioMixer.Key);
			}
			LethalExpansion.Log.LogInfo((object)"Planet Prefabs");
			foreach (KeyValuePair<string, GameObject> planetPrefab in planetPrefabs)
			{
				LethalExpansion.Log.LogInfo((object)planetPrefab.Key);
			}
			LethalExpansion.Log.LogInfo((object)"Map Objects");
			foreach (KeyValuePair<string, GameObject> mapObject in mapObjects)
			{
				LethalExpansion.Log.LogInfo((object)mapObject.Key);
			}
			LethalExpansion.Log.LogInfo((object)"Outside Objects");
			foreach (KeyValuePair<string, SpawnableOutsideObject> outsideObject in outsideObjects)
			{
				LethalExpansion.Log.LogInfo((object)outsideObject.Key);
			}
			LethalExpansion.Log.LogInfo((object)"Scraps");
			foreach (KeyValuePair<string, Item> scrap in scraps)
			{
				LethalExpansion.Log.LogInfo((object)scrap.Key);
			}
			LethalExpansion.Log.LogInfo((object)"Level Ambiances");
			foreach (KeyValuePair<string, LevelAmbienceLibrary> levelAmbiance in levelAmbiances)
			{
				LethalExpansion.Log.LogInfo((object)levelAmbiance.Key);
			}
			LethalExpansion.Log.LogInfo((object)"Enemies");
			foreach (KeyValuePair<string, EnemyType> enemy in enemies)
			{
				LethalExpansion.Log.LogInfo((object)enemy.Key);
			}
			LethalExpansion.Log.LogInfo((object)"Sprites");
			foreach (KeyValuePair<string, Sprite> sprite in sprites)
			{
				LethalExpansion.Log.LogInfo((object)sprite.Key);
			}
		}

		public AudioMixerGroup GetDiageticMasterAudioMixer()
		{
			if (!audioMixers.TryGetValue("Diagetic", out var value))
			{
				return null;
			}
			return value.Item2.First((AudioMixerGroup a) => ((Object)a).name == "Master");
		}

		private void Add<T>(Dictionary<string, T> dictionary, string key, T value)
		{
			if (key != null && value != null && !dictionary.ContainsKey(key) && !dictionary.ContainsValue(value))
			{
				dictionary[key] = value;
			}
		}

		public void AddAudioClip(AudioClip clip)
		{
			AddAudioClip((clip != null) ? ((Object)clip).name : null, clip);
		}

		public void AddAudioClip(string name, AudioClip clip)
		{
			Add(audioClips, name, clip);
		}

		public void AddAudioClip(AudioClip[] clips)
		{
			if (clips != null)
			{
				foreach (AudioClip clip in clips)
				{
					AddAudioClip(clip);
				}
			}
		}

		public void AddAudioClip(string[] names, AudioClip[] clips)
		{
			if (names != null && clips != null)
			{
				for (int i = 0; i < clips.Length && i < names.Length; i++)
				{
					AddAudioClip(names[i], clips[i]);
				}
			}
		}

		public void AddAudioMixer(AudioMixer audioMixer)
		{
			if ((Object)(object)audioMixer == (Object)null || audioMixers.ContainsKey(((Object)audioMixer).name))
			{
				return;
			}
			List<AudioMixerGroup> list = new List<AudioMixerGroup>();
			AudioMixerGroup[] array = audioMixer.FindMatchingGroups(string.Empty);
			foreach (AudioMixerGroup val in array)
			{
				if (!((Object)(object)val == (Object)null) && !list.Contains(val))
				{
					list.Add(val);
				}
			}
			Add(audioMixers, ((Object)audioMixer).name, (audioMixer, list.ToArray()));
		}

		public void AddPlanetPrefabs(GameObject prefab)
		{
			AddPlanetPrefabs((prefab != null) ? ((Object)prefab).name : null, prefab);
		}

		public void AddPlanetPrefabs(string name, GameObject prefab)
		{
			Add(planetPrefabs, name, prefab);
		}

		public void AddMapObjects(GameObject mapObject)
		{
			Add(mapObjects, (mapObject != null) ? ((Object)mapObject).name : null, mapObject);
		}

		public void AddOutsideObject(SpawnableOutsideObject outsideObject)
		{
			Add(outsideObjects, (outsideObject != null) ? ((Object)outsideObject).name : null, outsideObject);
		}

		public void AddScrap(Item scrap)
		{
			Add(scraps, (scrap != null) ? ((Object)scrap).name : null, scrap);
		}

		public void AddLevelAmbiances(LevelAmbienceLibrary levelAmbiance)
		{
			Add(levelAmbiances, (levelAmbiance != null) ? ((Object)levelAmbiance).name : null, levelAmbiance);
		}

		public void AddEnemies(EnemyType enemy)
		{
			Add(enemies, (enemy != null) ? ((Object)enemy).name : null, enemy);
		}

		public void AddSprites(Sprite sprite)
		{
			AddSprites((sprite != null) ? ((Object)sprite).name : null, sprite);
		}

		public void AddSprites(string name, Sprite sprite)
		{
			Add(sprites, name, sprite);
		}
	}
	public static class ComponentWhitelist
	{
		public static List<Type> MoonPrefabComponentWhitelist = new List<Type>
		{
			typeof(Transform),
			typeof(MeshFilter),
			typeof(MeshRenderer),
			typeof(SkinnedMeshRenderer),
			typeof(MeshCollider),
			typeof(BoxCollider),
			typeof(SphereCollider),
			typeof(CapsuleCollider),
			typeof(SphereCollider),
			typeof(TerrainCollider),
			typeof(WheelCollider),
			typeof(ArticulationBody),
			typeof(ConstantForce),
			typeof(ConfigurableJoint),
			typeof(FixedJoint),
			typeof(HingeJoint),
			typeof(Cloth),
			typeof(Rigidbody),
			typeof(NetworkObject),
			typeof(NetworkRigidbody),
			typeof(NetworkTransform),
			typeof(NetworkAnimator),
			typeof(Animator),
			typeof(Animation),
			typeof(Terrain),
			typeof(Tree),
			typeof(WindZone),
			typeof(DecalProjector),
			typeof(LODGroup),
			typeof(Light),
			typeof(HDAdditionalLightData),
			typeof(LightProbeGroup),
			typeof(LightProbeProxyVolume),
			typeof(LocalVolumetricFog),
			typeof(OcclusionArea),
			typeof(OcclusionPortal),
			typeof(ReflectionProbe),
			typeof(PlanarReflectionProbe),
			typeof(HDAdditionalReflectionData),
			typeof(Skybox),
			typeof(SortingGroup),
			typeof(SpriteRenderer),
			typeof(Volume),
			typeof(AudioSource),
			typeof(AudioReverbZone),
			typeof(AudioReverbFilter),
			typeof(AudioChorusFilter),
			typeof(AudioDistortionFilter),
			typeof(AudioEchoFilter),
			typeof(AudioHighPassFilter),
			typeof(AudioLowPassFilter),
			typeof(AudioListener),
			typeof(LensFlare),
			typeof(TrailRenderer),
			typeof(LineRenderer),
			typeof(ParticleSystem),
			typeof(ParticleSystemRenderer),
			typeof(ParticleSystemForceField),
			typeof(Projector),
			typeof(VideoPlayer),
			typeof(NavMeshSurface),
			typeof(NavMeshModifier),
			typeof(NavMeshModifierVolume),
			typeof(NavMeshLink),
			typeof(NavMeshObstacle),
			typeof(OffMeshLink),
			typeof(SI_AudioReverbPresets),
			typeof(SI_AudioReverbTrigger),
			typeof(SI_DungeonGenerator),
			typeof(SI_MatchLocalPlayerPosition),
			typeof(SI_AnimatedSun),
			typeof(SI_EntranceTeleport),
			typeof(SI_ScanNode),
			typeof(SI_DoorLock),
			typeof(SI_WaterSurface),
			typeof(SI_Ladder),
			typeof(SI_ItemDropship),
			typeof(SI_NetworkPrefabInstancier),
			typeof(SI_InteractTrigger),
			typeof(SI_DamagePlayer),
			typeof(SI_SoundYDistance),
			typeof(SI_AudioOutputInterface),
			typeof(SI_NetworkDataInterfacing),
			typeof(PlayerShip),
			typeof(LECore_InactiveNetworkPrefabInstancier)
		};

		public static List<Type> ScrapPrefabComponentWhitelist = new List<Type>
		{
			typeof(Transform),
			typeof(MeshFilter),
			typeof(MeshRenderer),
			typeof(SkinnedMeshRenderer),
			typeof(MeshCollider),
			typeof(BoxCollider),
			typeof(SphereCollider),
			typeof(CapsuleCollider),
			typeof(SphereCollider),
			typeof(TerrainCollider),
			typeof(WheelCollider),
			typeof(ArticulationBody),
			typeof(ConstantForce),
			typeof(ConfigurableJoint),
			typeof(FixedJoint),
			typeof(HingeJoint),
			typeof(Cloth),
			typeof(Rigidbody),
			typeof(NetworkObject),
			typeof(NetworkRigidbody),
			typeof(NetworkTransform),
			typeof(NetworkAnimator),
			typeof(Animator),
			typeof(Animation),
			typeof(DecalProjector),
			typeof(LODGroup),
			typeof(Light),
			typeof(HDAdditionalLightData),
			typeof(LightProbeGroup),
			typeof(LightProbeProxyVolume),
			typeof(LocalVolumetricFog),
			typeof(OcclusionArea),
			typeof(OcclusionPortal),
			typeof(ReflectionProbe),
			typeof(PlanarReflectionProbe),
			typeof(HDAdditionalReflectionData),
			typeof(SortingGroup),
			typeof(SpriteRenderer),
			typeof(AudioSource),
			typeof(AudioReverbZone),
			typeof(AudioReverbFilter),
			typeof(AudioChorusFilter),
			typeof(AudioDistortionFilter),
			typeof(AudioEchoFilter),
			typeof(AudioHighPassFilter),
			typeof(AudioLowPassFilter),
			typeof(AudioListener),
			typeof(LensFlare),
			typeof(TrailRenderer),
			typeof(LineRenderer),
			typeof(ParticleSystem),
			typeof(ParticleSystemRenderer),
			typeof(ParticleSystemForceField),
			typeof(VideoPlayer),
			typeof(SI_DamagePlayer),
			typeof(SI_AudioOutputInterface)
		};

		public static void CheckAndRemoveIllegalComponents(Transform prefab, List<Type> whitelist)
		{
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Expected O, but got Unknown
			try
			{
				Component[] components = ((Component)prefab).GetComponents<Component>();
				Component[] array = components;
				foreach (Component component in array)
				{
					if (!whitelist.Any((Type whitelistType) => ((object)component).GetType() == whitelistType))
					{
						LethalExpansion.Log.LogWarning((object)$"Removed illegal component '{((object)component).GetType().Name}' from prefab '{prefab}'");
						Object.Destroy((Object)(object)component);
					}
				}
				foreach (Transform item in prefab)
				{
					Transform prefab2 = item;
					CheckAndRemoveIllegalComponents(prefab2, whitelist);
				}
			}
			catch (Exception arg)
			{
				LethalExpansion.Log.LogError((object)$"Failed to remove illegal components from prefab '{prefab}'. {arg}");
			}
		}
	}
	public static class VanillaAssetGatherer
	{
		public static void GatherAssets()
		{
			GatherIconAssets();
			foreach (Item items in StartOfRound.Instance.allItemsList.itemsList)
			{
				GatherItemAssets(items);
			}
			SelectableLevel[] levels = StartOfRound.Instance.levels;
			foreach (SelectableLevel level in levels)
			{
				GatherLevelAssets(level);
			}
		}

		public static void GatherIconAssets()
		{
			AssetGather.Instance.AddSprites(GameObject.Find("Environment/HangarShip/StartGameLever").GetComponent<InteractTrigger>().hoverIcon);
			AssetGather.Instance.AddSprites(GameObject.Find("Environment/HangarShip/Terminal/TerminalTrigger/TerminalScript").GetComponent<InteractTrigger>().hoverIcon);
			AssetGather.Instance.AddSprites(GameObject.Find("Environment/HangarShip/OutsideShipRoom/Ladder/LadderTrigger").GetComponent<InteractTrigger>().hoverIcon);
		}

		public static void GatherItemAssets(Item item)
		{
			AssetGather.Instance.AddAudioClip(item.grabSFX);
			AssetGather.Instance.AddAudioClip(item.dropSFX);
			AssetGather.Instance.AddAudioClip(item.pocketSFX);
			AssetGather.Instance.AddAudioClip(item.throwSFX);
			GameObject spawnPrefab = item.spawnPrefab;
			if ((Object)(object)spawnPrefab != (Object)null)
			{
				GatherItemPrefabAssets(spawnPrefab);
			}
		}

		public static void GatherItemPrefabAssets(GameObject spawnPrefab)
		{
			Component[] components = spawnPrefab.GetComponents<Component>();
			foreach (Component component in components)
			{
				GatherItemPrefabComponentAssets(component);
			}
		}

		public static void GatherItemPrefabComponentAssets(Component component)
		{
			Shovel val = (Shovel)(object)((component is Shovel) ? component : null);
			if (val != null)
			{
				AssetGather.Instance.AddAudioClip(val.reelUp);
				AssetGather.Instance.AddAudioClip(val.swing);
				AssetGather.Instance.AddAudioClip(val.hitSFX);
				return;
			}
			FlashlightItem val2 = (FlashlightItem)(object)((component is FlashlightItem) ? component : null);
			if (val2 != null)
			{
				AssetGather.Instance.AddAudioClip(val2.flashlightClips);
				AssetGather.Instance.AddAudioClip(val2.outOfBatteriesClip);
				AssetGather.Instance.AddAudioClip(val2.flashlightFlicker);
				return;
			}
			WalkieTalkie val3 = (WalkieTalkie)(object)((component is WalkieTalkie) ? component : null);
			if (val3 != null)
			{
				AssetGather.Instance.AddAudioClip(val3.stopTransmissionSFX);
				AssetGather.Instance.AddAudioClip(val3.startTransmissionSFX);
				AssetGather.Instance.AddAudioClip(val3.switchWalkieTalkiePowerOff);
				AssetGather.Instance.AddAudioClip(val3.switchWalkieTalkiePowerOn);
				AssetGather.Instance.AddAudioClip(val3.talkingOnWalkieTalkieNotHeldSFX);
				AssetGather.Instance.AddAudioClip(val3.playerDieOnWalkieTalkieSFX);
				return;
			}
			ExtensionLadderItem val4 = (ExtensionLadderItem)(object)((component is ExtensionLadderItem) ? component : null);
			if (val4 != null)
			{
				AssetGather.Instance.AddAudioClip(val4.hitRoof);
				AssetGather.Instance.AddAudioClip(val4.fullExtend);
				AssetGather.Instance.AddAudioClip(val4.hitWall);
				AssetGather.Instance.AddAudioClip(val4.ladderExtendSFX);
				AssetGather.Instance.AddAudioClip(val4.ladderFallSFX);
				AssetGather.Instance.AddAudioClip(val4.ladderShrinkSFX);
				AssetGather.Instance.AddAudioClip(val4.blinkWarningSFX);
				AssetGather.Instance.AddAudioClip(val4.lidOpenSFX);
				return;
			}
			NoisemakerProp val5 = (NoisemakerProp)(object)((component is NoisemakerProp) ? component : null);
			if (val5 != null)
			{
				AssetGather.Instance.AddAudioClip(val5.noiseSFX);
				AssetGather.Instance.AddAudioClip(val5.noiseSFXFar);
				return;
			}
			PatcherTool val6 = (PatcherTool)(object)((component is PatcherTool) ? component : null);
			if (val6 != null)
			{
				AssetGather.Instance.AddAudioClip(val6.activateClips);
				AssetGather.Instance.AddAudioClip(val6.beginShockClips);
				AssetGather.Instance.AddAudioClip(val6.overheatClips);
				AssetGather.Instance.AddAudioClip(val6.finishShockClips);
				AssetGather.Instance.AddAudioClip(val6.outOfBatteriesClip);
				AssetGather.Instance.AddAudioClip(val6.detectAnomaly);
				AssetGather.Instance.AddAudioClip(val6.scanAnomaly);
				return;
			}
			WhoopieCushionItem val7 = (WhoopieCushionItem)(object)((component is WhoopieCushionItem) ? component : null);
			if (val7 != null)
			{
				AssetGather.Instance.AddAudioClip(val7.fartAudios);
				return;
			}
			ShotgunItem val8 = (ShotgunItem)(object)((component is ShotgunItem) ? component : null);
			if (val8 != null)
			{
				AssetGather.Instance.AddAudioClip(val8.gunShootSFX);
				AssetGather.Instance.AddAudioClip(val8.gunReloadSFX);
				AssetGather.Instance.AddAudioClip(val8.gunReloadFinishSFX);
				AssetGather.Instance.AddAudioClip(val8.noAmmoSFX);
				AssetGather.Instance.AddAudioClip(val8.gunSafetySFX);
				AssetGather.Instance.AddAudioClip(val8.switchSafetyOnSFX);
				AssetGather.Instance.AddAudioClip(val8.switchSafetyOffSFX);
			}
			else
			{
				AudioSource val9 = (AudioSource)(object)((component is AudioSource) ? component : null);
				if (val9 != null)
				{
					AssetGather.Instance.AddAudioClip(val9.clip);
				}
			}
		}

		public static void GatherLevelAssets(SelectableLevel level)
		{
			AssetGather.Instance.AddPlanetPrefabs(level.planetPrefab);
			AssetGather.Instance.AddLevelAmbiances(level.levelAmbienceClips);
			level.spawnableMapObjects.ToList().ForEach(delegate(SpawnableMapObject e)
			{
				AssetGather.Instance.AddMapObjects(e.prefabToSpawn);
			});
			level.spawnableOutsideObjects.ToList().ForEach(delegate(SpawnableOutsideObjectWithRarity e)
			{
				AssetGather.Instance.AddOutsideObject(e.spawnableObject);
			});
			level.spawnableScrap.ForEach(delegate(SpawnableItemWithRarity e)
			{
				AssetGather.Instance.AddScrap(e.spawnableItem);
			});
			level.Enemies.ForEach(delegate(SpawnableEnemyWithRarity e)
			{
				AssetGather.Instance.AddEnemies(e.enemyType);
			});
			level.OutsideEnemies.ForEach(delegate(SpawnableEnemyWithRarity e)
			{
				AssetGather.Instance.AddEnemies(e.enemyType);
			});
			level.DaytimeEnemies.ForEach(delegate(SpawnableEnemyWithRarity e)
			{
				AssetGather.Instance.AddEnemies(e.enemyType);
			});
		}
	}
	public static class VanillaItemInstancier
	{
		public static Item GetItem(Scrap scrap)
		{
			object result;
			if (scrap == null)
			{
				result = null;
			}
			else
			{
				GameObject prefab = scrap.prefab;
				result = ((prefab == null) ? null : prefab.GetComponent<GrabbableObject>()?.itemProperties);
			}
			return (Item)result;
		}

		public static void UpdateAudio(Scrap scrap)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: 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_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Expected I4, but got Unknown
			UpdateItemAudio(scrap);
			ScrapType scrapType = scrap.scrapType;
			ScrapType val = scrapType;
			switch (val - 1)
			{
			case 0:
				UpdateShovelAudio(scrap);
				break;
			case 1:
				UpdateFlashlightAudio(scrap);
				break;
			case 2:
				UpdateNoisemakerAudio(scrap);
				break;
			case 3:
				UpdateWhoopieCushionAudio(scrap);
				break;
			}
		}

		public static void UpdateItemAudio(Scrap scrap)
		{
			Item item = GetItem(scrap);
			AudioSource component = scrap.prefab.GetComponent<AudioSource>();
			if ((Object)(object)component != (Object)null)
			{
				component.outputAudioMixerGroup = AssetGather.Instance.GetDiageticMasterAudioMixer();
			}
			item.grabSFX = GetAudioClip(scrap.grabSFX, "ShovelPickUp");
			item.dropSFX = GetAudioClip(scrap.dropSFX, "DropCan");
		}

		public static void UpdateShovelAudio(Scrap scrap)
		{
			Shovel component = scrap.prefab.GetComponent<Shovel>();
			if (!((Object)(object)component == (Object)null))
			{
				component.reelUp = GetAudioClip(scrap.reelUp, "ShovelReelUp");
				component.swing = GetAudioClip(scrap.swing, "ShovelSwing");
				component.hitSFX = GetAudioClips(scrap.hitSFX, "ShovelHitDefault", "ShovelHitDefault2");
			}
		}

		public static void UpdateFlashlightAudio(Scrap scrap)
		{
			FlashlightItem component = scrap.prefab.GetComponent<FlashlightItem>();
			if (!((Object)(object)component == (Object)null))
			{
				component.outOfBatteriesClip = GetAudioClip(scrap.outOfBatteriesClip, "FlashlightOutOfBatteries");
				component.flashlightFlicker = GetAudioClip(scrap.flashlightFlicker, "FlashlightFlicker");
				component.flashlightClips = GetAudioClips(scrap.flashlightClips, "FlashlightClick");
			}
		}

		public static void UpdateNoisemakerAudio(Scrap scrap)
		{
			NoisemakerProp component = scrap.prefab.GetComponent<NoisemakerProp>();
			if (!((Object)(object)component == (Object)null))
			{
				component.noiseAudio.outputAudioMixerGroup = AssetGather.Instance.GetDiageticMasterAudioMixer();
				component.noiseSFX = GetAudioClips(scrap.noiseSFX, "ClownHorn1");
				component.noiseSFXFar = GetAudioClips(scrap.noiseSFXFar, "ClownHornFar");
			}
		}

		public static void UpdateWhoopieCushionAudio(Scrap scrap)
		{
			WhoopieCushionItem component = scrap.prefab.GetComponent<WhoopieCushionItem>();
			if (!((Object)(object)component == (Object)null))
			{
				component.fartAudios = GetAudioClips(scrap.fartAudios, "Fart1", "Fart2", "Fart3", "Fart5");
			}
		}

		public static AudioClip GetAudioClip(string audioClipName, string defaultAudioClipName)
		{
			AudioClip value = null;
			if (!string.IsNullOrWhiteSpace(audioClipName))
			{
				AssetGather.Instance.audioClips.TryGetValue(audioClipName, out value);
			}
			if ((Object)(object)value != (Object)null)
			{
				return value;
			}
			return AssetGather.Instance.audioClips[defaultAudioClipName];
		}

		public static AudioClip[] GetAudioClips(string[] audioClipNames, params string[] defaultAudioClipNames)
		{
			List<AudioClip> list = new List<AudioClip>();
			if (audioClipNames != null)
			{
				foreach (string key in audioClipNames)
				{
					if (AssetGather.Instance.audioClips.TryGetValue(key, out var value))
					{
						list.Add(value);
					}
				}
			}
			if (list.Count > 0)
			{
				return list.ToArray();
			}
			return defaultAudioClipNames.Select((string audioClipName) => AssetGather.Instance.audioClips[audioClipName]).ToArray();
		}

		public static void AddItemToScrap(Scrap scrap, Sprite scrapSprite)
		{
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			//IL_012f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			AudioSource val = scrap.prefab.AddComponent<AudioSource>();
			val.playOnAwake = false;
			val.spatialBlend = 1f;
			Item val2 = ScriptableObject.CreateInstance<Item>();
			((Object)val2).name = ((Object)scrap).name;
			val2.itemName = scrap.itemName;
			val2.canBeGrabbedBeforeGameStart = true;
			val2.isScrap = true;
			val2.minValue = scrap.minValue;
			val2.maxValue = scrap.maxValue;
			val2.weight = (float)scrap.weight / 100f + 1f;
			ComponentWhitelist.CheckAndRemoveIllegalComponents(scrap.prefab.transform, ComponentWhitelist.ScrapPrefabComponentWhitelist);
			val2.spawnPrefab = scrap.prefab;
			val2.twoHanded = scrap.twoHanded;
			val2.requiresBattery = scrap.requiresBattery;
			val2.isConductiveMetal = scrap.isConductiveMetal;
			(bool, string) grabAnimation = GetGrabAnimation(scrap);
			bool item = grabAnimation.Item1;
			string item2 = grabAnimation.Item2;
			val2.twoHandedAnimation = item;
			val2.grabAnim = item2;
			val2.itemIcon = scrapSprite;
			val2.syncGrabFunction = false;
			val2.syncUseFunction = false;
			val2.syncDiscardFunction = false;
			val2.syncInteractLRFunction = false;
			val2.verticalOffset = scrap.verticalOffset;
			val2.restingRotation = scrap.restingRotation;
			val2.positionOffset = scrap.positionOffset;
			val2.rotationOffset = scrap.rotationOffset;
			val2.meshOffset = false;
			val2.meshVariants = scrap.meshVariants;
			val2.materialVariants = scrap.materialVariants;
			val2.canBeInspected = false;
			GrabbableObject val3 = AddGrabbableObject(scrap, val2);
			val3.grabbable = true;
			val3.itemProperties = val2;
			val3.mainObjectRenderer = scrap.prefab.GetComponent<MeshRenderer>();
			Transform val4 = scrap.prefab.transform.Find("ScanNode");
			if ((Object)(object)val4 != (Object)null)
			{
				ScanNodeProperties val5 = ((Component)val4).gameObject.AddComponent<ScanNodeProperties>();
				val5.maxRange = 13;
				val5.minRange = 1;
				val5.headerText = scrap.itemName;
				val5.subText = "Value: ";
				val5.nodeType = 2;
			}
		}

		public static GrabbableObject AddGrabbableObject(Scrap scrap, Item item)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: 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_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Expected I4, but got Unknown
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Expected O, but got Unknown
			//IL_04ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_04f9: Expected I4, but got Unknown
			//IL_0135: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Expected O, but got Unknown
			//IL_03ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0404: Unknown result type (might be due to invalid IL or missing references)
			//IL_041f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0424: Unknown result type (might be due to invalid IL or missing references)
			//IL_043f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0444: Unknown result type (might be due to invalid IL or missing references)
			//IL_0449: Unknown result type (might be due to invalid IL or missing references)
			//IL_0453: Expected O, but got Unknown
			//IL_01b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d4: Unknown result type (might be due to invalid IL or missing references)
			ScrapType scrapType = scrap.scrapType;
			ScrapType val = scrapType;
			switch ((int)val)
			{
			case 0:
				return (GrabbableObject)(object)scrap.prefab.AddComponent<PhysicsProp>();
			case 1:
			{
				item.holdButtonUse = true;
				Shovel val3 = scrap.prefab.AddComponent<Shovel>();
				val3.shovelHitForce = scrap.shovelHitForce;
				val3.shovelAudio = scrap.shovelAudio ?? scrap.prefab.GetComponent<AudioSource>() ?? scrap.prefab.AddComponent<AudioSource>();
				if ((Object)(object)scrap.prefab.GetComponent<OccludeAudio>() == (Object)null)
				{
					scrap.prefab.AddComponent<OccludeAudio>();
				}
				return (GrabbableObject)(object)val3;
			}
			case 2:
			{
				FlashlightItem val4 = scrap.prefab.AddComponent<FlashlightItem>();
				val4.usingPlayerHelmetLight = scrap.usingPlayerHelmetLight;
				val4.flashlightInterferenceLevel = scrap.flashlightInterferenceLevel;
				val4.flashlightBulb = scrap.flashlightBulb;
				if ((Object)(object)val4.flashlightBulb == (Object)null)
				{
					val4.flashlightBulb = new Light();
					val4.flashlightBulb.intensity = 0f;
				}
				val4.flashlightBulbGlow = scrap.flashlightBulbGlow;
				if ((Object)(object)val4.flashlightBulbGlow == (Object)null)
				{
					val4.flashlightBulbGlow = new Light();
					val4.flashlightBulbGlow.intensity = 0f;
				}
				val4.flashlightAudio = scrap.flashlightAudio ?? scrap.prefab.GetComponent<AudioSource>() ?? scrap.prefab.AddComponent<AudioSource>();
				if ((Object)(object)scrap.prefab.GetComponent<OccludeAudio>() == (Object)null)
				{
					scrap.prefab.AddComponent<OccludeAudio>();
				}
				val4.bulbLight = (Material)(((object)scrap.bulbLight) ?? ((object)new Material(Shader.Find("HDRP/Lit"))));
				val4.bulbDark = (Material)(((object)scrap.bulbDark) ?? ((object)new Material(Shader.Find("HDRP/Lit"))));
				val4.flashlightMesh = scrap.flashlightMesh ?? ((GrabbableObject)val4).mainObjectRenderer;
				val4.flashlightTypeID = scrap.flashlightTypeID;
				val4.changeMaterial = scrap.changeMaterial;
				return (GrabbableObject)(object)val4;
			}
			case 3:
			{
				NoisemakerProp val5 = scrap.prefab.AddComponent<NoisemakerProp>();
				val5.noiseAudio = scrap.noiseAudio;
				if ((Object)(object)val5.noiseAudio == (Object)null)
				{
					val5.noiseAudio = scrap.prefab.AddComponent<AudioSource>();
					val5.noiseAudio.playOnAwake = false;
					val5.noiseAudio.priority = 128;
					val5.noiseAudio.pitch = 1f;
					val5.noiseAudio.panStereo = 0f;
					val5.noiseAudio.spatialBlend = 1f;
					val5.noiseAudio.reverbZoneMix = 1f;
					val5.noiseAudio.dopplerLevel = 4f;
					val5.noiseAudio.spread = 26f;
					val5.noiseAudio.minDistance = 4f;
					val5.noiseAudio.maxDistance = 21f;
					val5.noiseAudio.rolloffMode = (AudioRolloffMode)1;
				}
				val5.noiseAudioFar = scrap.noiseAudioFar;
				if ((Object)(object)val5.noiseAudioFar == (Object)null)
				{
					val5.noiseAudioFar = scrap.prefab.AddComponent<AudioSource>();
					val5.noiseAudioFar.playOnAwake = true;
					val5.noiseAudioFar.priority = 128;
					val5.noiseAudioFar.pitch = 1f;
					val5.noiseAudioFar.panStereo = 0f;
					val5.noiseAudioFar.spatialBlend = 1f;
					val5.noiseAudioFar.reverbZoneMix = 1f;
					val5.noiseAudioFar.dopplerLevel = 1.4f;
					val5.noiseAudioFar.spread = 87f;
					val5.noiseAudioFar.maxDistance = 75f;
					val5.noiseAudioFar.rolloffMode = (AudioRolloffMode)2;
					val5.noiseAudioFar.SetCustomCurve((AudioSourceCurveType)0, new AnimationCurve((Keyframe[])(object)new Keyframe[3]
					{
						new Keyframe(18f, 0f, 0f, 0.065f),
						new Keyframe(25.59f, 0.866f, -0.01f, -0.01f),
						new Keyframe(87f, 0f, -0.018f, 0f)
					}));
				}
				val5.noiseRange = scrap.noiseRange;
				val5.maxLoudness = scrap.maxLoudness;
				val5.minLoudness = scrap.minLoudness;
				val5.minPitch = scrap.minPitch;
				val5.maxPitch = scrap.maxPitch;
				val5.triggerAnimator = scrap.triggerAnimator;
				item.syncUseFunction = true;
				return (GrabbableObject)(object)val5;
			}
			case 4:
			{
				WhoopieCushionItem val2 = scrap.prefab.AddComponent<WhoopieCushionItem>();
				val2.whoopieCushionAudio = scrap.whoopieCushionAudio ?? scrap.prefab.GetComponent<AudioSource>() ?? scrap.prefab.AddComponent<AudioSource>();
				return (GrabbableObject)(object)val2;
			}
			default:
				LethalExpansion.Log.LogWarning((object)$"Unknown scrap type '{(int)scrap.scrapType}' for scrap '{scrap.itemName}'");
				return (GrabbableObject)(object)scrap.prefab.AddComponent<PhysicsProp>();
			}
		}

		public static (bool, string) GetGrabAnimation(Scrap scrap)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Expected I4, but got Unknown
			GrabAnim handedAnimation = scrap.HandedAnimation;
			GrabAnim val = handedAnimation;
			return (int)val switch
			{
				0 => (false, string.Empty), 
				1 => (true, "HoldLung"), 
				2 => (true, "HoldShotgun"), 
				3 => (true, "HoldJetpack"), 
				4 => (false, "GrabClipboard"), 
				_ => (false, string.Empty), 
			};
		}
	}
}
namespace LethalExpansionCore.Patches
{
	[HarmonyPatch(typeof(AudioReverbTrigger))]
	internal class AudioReverbTrigger_Patch
	{
		[HarmonyPatch("ChangeAudioReverbForPlayer")]
		[HarmonyPostfix]
		public static void SChangeAudioReverbForPlayer_Postfix(AudioReverbTrigger __instance)
		{
			if ((Object)(object)LethalExpansion.currentWaterSurface != (Object)null)
			{
				((Component)LethalExpansion.currentWaterSurface).gameObject.SetActive(!__instance.disableAllWeather);
			}
		}
	}
	[HarmonyPatch(typeof(DungeonGenerator))]
	public class DungeonGenerator_Patch
	{
		[HarmonyPatch("Generate")]
		[HarmonyPrefix]
		public static void Generate_Prefix(DungeonGenerator __instance, out IntRange __state)
		{
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Expected O, but got Unknown
			if (!Terminal_Patch.newMoons.ContainsKey(RoundManager.Instance.currentLevel.levelID))
			{
				__state = null;
				return;
			}
			EntranceTeleport[] array = Object.FindObjectsOfType<EntranceTeleport>();
			EntranceTeleport[] array2 = array.OrderBy((EntranceTeleport entrance) => entrance.entranceId).ToArray();
			for (int i = 0; i < array2.Length; i++)
			{
				EntranceTeleport val = array2[i];
				if (val.entranceId != i)
				{
					LethalExpansion.Log.LogWarning((object)$"Entrance '{((Component)val).gameObject}' has an unexpected id, updating id from '{val.entranceId}' to '{i}'");
				}
				val.entranceId = i;
			}
			IntRange val2 = SetFireExitAmount(__instance.DungeonFlow, new IntRange(array.Length - 1, array.Length - 1));
			__state = val2;
		}

		[HarmonyPatch("Generate")]
		[HarmonyPostfix]
		public static void Generate_Postfix(DungeonGenerator __instance, IntRange __state)
		{
			if (__state != null)
			{
				SetFireExitAmount(__instance.DungeonFlow, __state);
			}
		}

		public static IntRange SetFireExitAmount(DungeonFlow dungeonFlow, IntRange newRange)
		{
			GlobalPropSettings val = dungeonFlow.GlobalProps.Where((GlobalPropSettings props) => props.ID == 1231).First();
			LethalExpansion.Log.LogInfo((object)$"Updating fire exit count from ({val.Count}) to ({newRange})");
			IntRange count = val.Count;
			val.Count = newRange;
			return count;
		}
	}
	[HarmonyPatch(typeof(EntranceTeleport))]
	public class EntranceTeleport_Patch
	{
		[HarmonyPatch("SetAudioPreset")]
		[HarmonyPrefix]
		public static bool SetAudioPreset_Prefix(EntranceTeleport __instance, int playerObj)
		{
			if ((Object)(object)Object.FindObjectOfType<AudioReverbPresets>() == (Object)null)
			{
				__instance.PlayAudioAtTeleportPositions();
				return false;
			}
			if (Object.FindObjectOfType<AudioReverbPresets>().audioPresets.Length <= __instance.audioReverbPreset)
			{
				__instance.PlayAudioAtTeleportPositions();
				return false;
			}
			return true;
		}

		[HarmonyPatch("TeleportPlayer")]
		[HarmonyPostfix]
		public static void TeleportPlayer_Postfix(EntranceTeleport __instance)
		{
			SI_WaterSurface val = Object.FindObjectOfType<SI_WaterSurface>();
			if (!((Object)(object)val == (Object)null))
			{
				if (__instance.isEntranceToBuilding)
				{
					((Behaviour)((Component)val).GetComponentInChildren<AudioSource>()).enabled = false;
				}
				else
				{
					((Behaviour)((Component)val).GetComponentInChildren<AudioSource>()).enabled = true;
				}
			}
		}
	}
	[HarmonyPatch(typeof(GameNetworkManager))]
	internal class GameNetworkManager_Patch
	{
		[HarmonyPatch("Start")]
		[HarmonyPrefix]
		private static void Start_Prefix(GameNetworkManager __instance)
		{
			AssetBundle mainAssetBundle = AssetBundlesManager.Instance.mainAssetBundle;
			ModManifest manifest = mainAssetBundle.LoadAsset<ModManifest>("Assets/Mods/LethalExpansion/modmanifest.asset");
			LoadNetworkPrefabs(__instance, mainAssetBundle, manifest, allowIllegalComponents: true);
			List<GameObject> usedPrefabs = new List<GameObject>();
			Sprite scrapSprite = mainAssetBundle.LoadAsset<Sprite>("Assets/Mods/LethalExpansion/Sprites/ScrapItemIcon2.png");
			foreach (KeyValuePair<string, (AssetBundle, ModManifest)> assetBundle in AssetBundlesManager.Instance.assetBundles)
			{
				var (val, val2) = AssetBundlesManager.Instance.Load(assetBundle.Key);
				if (!((Object)(object)val == (Object)null) && !((Object)(object)val2 == (Object)null))
				{
					try
					{
						LoadScrapPrefabs(__instance, val, val2, scrapSprite, usedPrefabs);
						LoadNetworkPrefabs(__instance, val, val2);
						LoadMoonPrefabs(__instance, val, val2);
					}
					catch (Exception ex)
					{
						LethalExpansion.Log.LogError((object)("Failed to register AssetBundle prefabs for '" + val2.modName + "', this may cause issues. " + ex.Message));
					}
				}
			}
		}

		private static void LoadScrapPrefabs(GameNetworkManager networkManager, AssetBundle assetBundle, ModManifest manifest, Sprite scrapSprite, List<GameObject> usedPrefabs)
		{
			Scrap[] scraps = manifest.scraps;
			if (scraps == null || scraps.Length == 0)
			{
				return;
			}
			NetworkPrefabHandler prefabHandler = ((Component)networkManager).GetComponent<NetworkManager>().PrefabHandler;
			Scrap[] scraps2 = manifest.scraps;
			foreach (Scrap scrap in scraps2)
			{
				if (!AssetBundlesManager.Instance.IsScrapCompatible(scrap))
				{
					continue;
				}
				if (usedPrefabs.Any((GameObject prefab) => prefab == scrap.prefab))
				{
					LethalExpansion.Log.LogWarning((object)("Prefab used by scrap '" + scrap.itemName + "' from '" + manifest.modName + "' is already in use by another scrap"));
					continue;
				}
				usedPrefabs.Add(scrap.prefab);
				try
				{
					VanillaItemInstancier.AddItemToScrap(scrap, scrapSprite);
					prefabHandler.AddNetworkPrefab(scrap.prefab);
					LethalExpansion.Log.LogInfo((object)("Registered scrap '" + scrap.itemName + "' from '" + manifest.modName + "'"));
				}
				catch (Exception arg)
				{
					LethalExpansion.Log.LogError((object)$"Failed to register scrap '{scrap.itemName}' from '{manifest.modName}'. {arg}");
				}
			}
		}

		private static void LoadNetworkPrefabs(GameNetworkManager networkManager, AssetBundle assetBundle, ModManifest manifest, bool allowIllegalComponents = false)
		{
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: 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)
			AssetBank assetBank = manifest.assetBank;
			PrefabInfoPair[] array = ((assetBank != null) ? assetBank.NetworkPrefabs() : null);
			if (array == null || array.Length == 0)
			{
				return;
			}
			NetworkPrefabHandler prefabHandler = ((Component)networkManager).GetComponent<NetworkManager>().PrefabHandler;
			PrefabInfoPair[] array2 = array;
			foreach (PrefabInfoPair val in array2)
			{
				string prefabPath = val.PrefabPath;
				if (!string.IsNullOrEmpty(prefabPath))
				{
					GameObject val2 = assetBundle.LoadAsset<GameObject>(prefabPath);
					if (!allowIllegalComponents)
					{
						ComponentWhitelist.CheckAndRemoveIllegalComponents(val2.transform, ComponentWhitelist.ScrapPrefabComponentWhitelist);
					}
					prefabHandler.AddNetworkPrefab(val2);
					LethalExpansion.Log.LogInfo((object)("Registered prefab '" + val.PrefabName + "' from '" + manifest.modName + "'"));
				}
			}
		}

		private static void LoadMoonPrefabs(GameNetworkManager networkManager, AssetBundle assetBundle, ModManifest manifest)
		{
			Moon[] moons = manifest.moons;
			if (moons == null || moons.Length == 0)
			{
				return;
			}
			NetworkPrefabHandler prefabHandler = ((Component)networkManager).GetComponent<NetworkManager>().PrefabHandler;
			Moon[] moons2 = manifest.moons;
			foreach (Moon val in moons2)
			{
				if (!AssetBundlesManager.Instance.IsMoonCompatible(val))
				{
					continue;
				}
				if ((Object)(object)val.MainPrefab == (Object)null)
				{
					LethalExpansion.Log.LogWarning((object)("Moon '" + val.PlanetName + "' does not have a MainPrefab"));
					continue;
				}
				try
				{
					InitializeMoon(val, prefabHandler);
					LethalExpansion.Log.LogInfo((object)("Registered moon '" + val.MoonName + "' from '" + manifest.modName + "'"));
				}
				catch (Exception arg)
				{
					LethalExpansion.Log.LogError((object)$"Failed to register moon '{val.MoonName}' from '{manifest.modName}'. {arg}");
				}
			}
		}

		private static NetworkObject AddNetworkObject(GameObject gameObject)
		{
			List<NetworkPrefab> networkPrefabs = Traverse.Create((object)NetworkManager.Singleton.NetworkConfig.Prefabs).Field("m_Prefabs").GetValue<List<NetworkPrefab>>();
			uint id = networkPrefabs.First((NetworkPrefab i) => networkPrefabs.Any((NetworkPrefab x) => x.SourcePrefabGlobalObjectIdHash != i.SourcePrefabGlobalObjectIdHash + 1)).SourcePrefabGlobalObjectIdHash + 1;
			return AddNetworkObject(gameObject, id);
		}

		private static NetworkObject AddNetworkObject(GameObject gameObject, string uniqueIdentifier)
		{
			uint id = BitConverter.ToUInt32(MD5.Create().ComputeHash(Encoding.UTF8.GetBytes(uniqueIdentifier)), 0);
			return AddNetworkObject(gameObject, id);
		}

		private static NetworkObject AddNetworkObject(GameObject gameObject, uint id)
		{
			NetworkObject val = gameObject.AddComponent<NetworkObject>();
			Traverse.Create((object)val).Field("GlobalObjectIdHash").SetValue((object)id);
			LethalExpansion.Log.LogInfo((object)$"Added NetworkObject with id '{id}' to '{gameObject}'");
			return val;
		}

		private static void InitializeMoon(Moon moon, NetworkPrefabHandler prefabHandler)
		{
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Expected O, but got Unknown
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_012e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			SI_EntranceTeleport[] componentsInChildren = moon.MainPrefab.GetComponentsInChildren<SI_EntranceTeleport>();
			foreach (SI_EntranceTeleport val in componentsInChildren)
			{
				NetworkObject val2 = ((Component)val).GetComponent<NetworkObject>();
				if (!Object.op_Implicit((Object)(object)val2))
				{
					if (Object.op_Implicit((Object)(object)((Component)val).GetComponentInParent<NetworkObject>()))
					{
						continue;
					}
					LethalExpansion.Log.LogInfo((object)$"Adding missing NetworkObject to EntranceTeleport '{((Component)val).gameObject}' to fix desync issue");
					val2 = AddNetworkObject(((Component)val).gameObject, $"{moon.MoonName}_{((Object)((Component)val).gameObject).name}_{val.EntranceID}_{val.EntrancePoint.position}");
				}
				GameObject gameObject = ((Component)val2).gameObject;
				gameObject.AddComponent<NetworkTransform>();
				gameObject.SetActive(false);
				GameObject gameObject2 = ((Component)gameObject.transform.parent).gameObject;
				GameObject val3 = new GameObject("NetworkPrefabInstancier");
				val3.transform.parent = gameObject2.transform;
				val3.transform.position = gameObject.transform.position;
				val3.transform.rotation = gameObject.transform.rotation;
				val3.AddComponent<LECore_InactiveNetworkPrefabInstancier>().prefab = gameObject;
				prefabHandler.AddNetworkPrefab(gameObject);
				prefabHandler.AddHandler(gameObject, (INetworkPrefabInstanceHandler)(object)new InactiveNetworkPrefabInstanceHandler(gameObject));
			}
		}
	}
	[HarmonyPatch(typeof(InteractTrigger))]
	internal class InteractTrigger_Patch
	{
		[HarmonyPatch("Start")]
		[HarmonyPostfix]
		public static void Start_Postfix(AudioReverbTrigger __instance)
		{
			((Component)__instance).gameObject.AddComponent<InteractTrigger_Extension>();
		}
	}
	public class InteractTrigger_Extension : MonoBehaviour
	{
		private InteractTrigger trigger;

		private void Awake()
		{
			trigger = ((Component)this).GetComponent<InteractTrigger>();
		}

		private void OnTriggerExit(Collider other)
		{
			if (!((Object)(object)trigger == (Object)null) && trigger.touchTrigger)
			{
				PlayerControllerB component = ((Component)other).gameObject.GetComponent<PlayerControllerB>();
				if (((Component)other).gameObject.CompareTag("Player") && (Object)(object)component != (Object)null && ((NetworkBehaviour)component).IsOwner)
				{
					((UnityEvent<PlayerControllerB>)(object)trigger.onStopInteract).Invoke(component);
				}
			}
		}
	}
	[HarmonyPatch(typeof(MenuManager))]
	internal class MenuManager_Patch
	{
		[HarmonyPatch("Awake")]
		[HarmonyPostfix]
		public static void Awake_Postfix(MenuManager __instance)
		{
			if (LethalExpansion.Settings.ShowVersionNumberOnMainMenu.Value && (Object)(object)__instance.versionNumberText != (Object)null)
			{
				((TMP_Text)__instance.versionNumberText).enableWordWrapping = false;
				TextMeshProUGUI versionNumberText = __instance.versionNumberText;
				((TMP_Text)versionNumberText).text = ((TMP_Text)versionNumberText).text + $"     LE(core)patch v{LethalExpansion.ModVersion}";
			}
		}
	}
	[HarmonyPatch(typeof(RoundManager))]
	internal class RoundManager_Patch
	{
		[HarmonyPatch("SpawnMapObjects")]
		[HarmonyPrefix]
		public static bool SpawnMapObjects_Prefix(RoundManager __instance)
		{
			return __instance.currentLevel.spawnableMapObjects != null;
		}

		[HarmonyPatch("PlotOutEnemiesForNextHour")]
		[HarmonyPrefix]
		public static bool PlotOutEnemiesForNextHour_Prefix(RoundManager __instance)
		{
			return __instance.currentLevel.enemySpawnChanceThroughoutDay != null;
		}

		[HarmonyPatch("SpawnEnemiesOutside")]
		[HarmonyPrefix]
		public static bool SpawnEnemiesOutside_Prefix(RoundManager __instance)
		{
			return __instance.currentLevel.outsideEnemySpawnChanceThroughDay != null;
		}

		[HarmonyPatch("SpawnDaytimeEnemiesOutside")]
		[HarmonyPrefix]
		public static bool SpawnDaytimeEnemiesOutside_Prefix(RoundManager __instance)
		{
			return __instance.currentLevel.daytimeEnemySpawnChanceThroughDay != null;
		}
	}
	[HarmonyPatch(typeof(StartOfRound))]
	internal class StartOfRound_Patch
	{
		[HarmonyPatch("StartGame")]
		[HarmonyPostfix]
		public static void StartGame_Postfix(StartOfRound __instance)
		{
			if (((Object)__instance.currentLevel).name.StartsWith("Assets/Mods/"))
			{
				SceneManager.LoadScene(((Object)__instance.currentLevel).name, (LoadSceneMode)1);
			}
			LethalExpansion.Log.LogInfo((object)"Game started.");
		}

		[HarmonyPatch("SetMapScreenInfoToCurrentLevel")]
		[HarmonyPostfix]
		private static void SetMapScreenInfoToCurrentLevel_Postfix(StartOfRound __instance)
		{
			AutoScrollText component = ((Component)__instance.screenLevelDescription).GetComponent<AutoScrollText>();
			if ((Object)(object)component != (Object)null)
			{
				component.ResetScrolling();
			}
		}

		[HarmonyPatch("ChangeLevel")]
		[HarmonyPrefix]
		private static void ChangeLevel_Prefix(StartOfRound __instance, ref int levelID)
		{
			if (levelID >= __instance.levels.Length)
			{
				levelID = 0;
				LethalExpansion.Log.LogError((object)$"Error loading moon ID {levelID}.");
			}
		}
	}
	internal class Terminal_Patch
	{
		private static TerminalKeyword[] defaultTerminalKeywords;

		public static bool scrapsPatched = false;

		public static bool moonsPatched = false;

		public static bool moonsTerminalPatched = false;

		public static bool assetsGotten = false;

		public static TerminalKeyword routeKeyword;

		public static TerminalKeyword infoKeyword;

		public static List<string> newScrapsNames = new List<string>();

		public static List<string> newMoonsNames = new List<string>();

		public static Dictionary<int, Moon> newMoons = new Dictionary<int, Moon>();

		[HarmonyPatch(typeof(StartOfRound), "Awake")]
		[HarmonyPostfix]
		public static void StartOfRound_Awake()
		{
			AddContent();
		}

		[HarmonyPatch(typeof(Terminal), "Start")]
		[HarmonyPrefix]
		public static void Terminal_Start(Terminal __instance)
		{
			UpdateTerminal(__instance);
		}

		public static void AddContent()
		{
			scrapsPatched = false;
			moonsPatched = false;
			GatherAssets();
			AddScraps();
			AddMoons();
			UpdateAllScrapSpawnRate();
			LethalExpansion.Log.LogInfo((object)"Finished adding moons and scrap");
		}

		public static void UpdateTerminal(Terminal terminal)
		{
			moonsTerminalPatched = false;
			routeKeyword = terminal.terminalNodes.allKeywords.First((TerminalKeyword k) => k.word == "route");
			infoKeyword = terminal.terminalNodes.allKeywords.First((TerminalKeyword k) => k.word == "info");
			Hotfix_DoubleRoutes();
			ResetTerminalKeywords(terminal);
			AddMoonTerminalEntries(terminal);
			UpdateMoonsCatalogue(terminal);
			StartOfRound.Instance.SetPlanetsWeather(0);
			LethalExpansion.Log.LogInfo((object)"Finished updating terminal");
		}

		private static void GatherAssets()
		{
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			if (assetsGotten)
			{
				return;
			}
			VanillaAssetGatherer.GatherAssets();
			foreach (KeyValuePair<string, (AssetBundle, ModManifest)> contentAssetBundle in AssetBundlesManager.Instance.contentAssetBundles)
			{
				var (val, val2) = AssetBundlesManager.Instance.Load(contentAssetBundle.Key);
				if ((Object)(object)val2.assetBank == (Object)null)
				{
					continue;
				}
				try
				{
					AudioClipInfoPair[] array = val2.assetBank.AudioClips();
					foreach (AudioClipInfoPair val3 in array)
					{
						AssetGather.Instance.AddAudioClip(val3.AudioClipName, val.LoadAsset<AudioClip>(val3.AudioClipPath));
					}
					PlanetPrefabInfoPair[] array2 = val2.assetBank.PlanetPrefabs();
					foreach (PlanetPrefabInfoPair val4 in array2)
					{
						GameObject val5 = val.LoadAsset<GameObject>(val4.PlanetPrefabPath);
						if (!((Object)(object)val5 == (Object)null))
						{
							Animator val6;
							if ((Object)(object)val5.GetComponent<Animator>() == (Object)null)
							{
								val6 = val5.AddComponent<Animator>();
							}
							val6 = AssetGather.Instance.planetPrefabs.First().Value.GetComponent<Animator>();
							AssetGather.Instance.AddPlanetPrefabs(val5);
						}
					}
				}
				catch (Exception ex)
				{
					LethalExpansion.Log.LogError((object)("Failed to collect prefabs from AssetBundle '" + val2.modName + "'. " + ex.Message));
				}
			}
			AssetGatherDialog.audioClips = AssetGather.Instance.audioClips;
			AssetGatherDialog.audioMixers = AssetGather.Instance.audioMixers;
			AssetGatherDialog.sprites = AssetGather.Instance.sprites;
			assetsGotten = true;
		}

		public static void AddScraps()
		{
			if (scrapsPatched)
			{
				return;
			}
			List<string> list = (from excludedScrap in LethalExpansion.Settings.ExcludedScrap.Value.Split(new char[1] { ',' })
				select excludedScrap.ToLower()).ToList();
			foreach (KeyValuePair<string, (AssetBundle, ModManifest)> contentAssetBundle in AssetBundlesManager.Instance.contentAssetBundles)
			{
				var (val, val2) = AssetBundlesManager.Instance.Load(contentAssetBundle.Key);
				if ((Object)(object)val == (Object)null || (Object)(object)val2 == (Object)null || val2.scraps == null)
				{
					continue;
				}
				Scrap[] scraps = val2.scraps;
				foreach (Scrap val3 in scraps)
				{
					if (!AssetBundlesManager.Instance.IsScrapCompatible(val3))
					{
						continue;
					}
					if (newScrapsNames.Contains(val3.itemName))
					{
						LethalExpansion.Log.LogWarning((object)("Scrap '" + val3.itemName + "' has already been added"));
						continue;
					}
					if (list.Contains(val3.itemName?.ToLower()))
					{
						LethalExpansion.Log.LogWarning((object)("Scrap '" + val3.itemName + "' was excluded in the config"));
						continue;
					}
					try
					{
						VanillaItemInstancier.UpdateAudio(val3);
						AddScrap(val3);
						LethalExpansion.Log.LogInfo((object)("Added scrap '" + val3.itemName + "'"));
					}
					catch (Exception ex)
					{
						LethalExpansion.Log.LogError((object)("Failed to add scrap '" + val3.itemName + "'. " + ex.Message));
					}
				}
			}
			scrapsPatched = true;
		}

		public static void UpdateAllScrapSpawnRate()
		{
			foreach (KeyValuePair<string, (AssetBundle, ModManifest)> contentAssetBundle in AssetBundlesManager.Instance.contentAssetBundles)
			{
				var (val, val2) = AssetBundlesManager.Instance.Load(contentAssetBundle.Key);
				if ((Object)(object)val == (Object)null || (Object)(object)val2 == (Object)null || val2.scraps == null)
				{
					continue;
				}
				Scrap[] scraps = val2.scraps;
				foreach (Scrap val3 in scraps)
				{
					if (AssetBundlesManager.Instance.IsScrapCompatible(val3))
					{
						try
						{
							UpdateScrapSpawnRate(val3);
						}
						catch (Exception arg)
						{
							LethalExpansion.Log.LogError((object)$"Failed to update scrap '{val3.itemName}' spawn rate. {arg}");
						}
					}
				}
			}
		}

		public static void UpdateScrapSpawnRate(Scrap scrap)
		{
			Item item = VanillaItemInstancier.GetItem(scrap);
			if ((Object)(object)item == (Object)null)
			{
				return;
			}
			SelectableLevel[] levels = StartOfRound.Instance.levels;
			foreach (SelectableLevel val in levels)
			{
				try
				{
					int? num = GetSpawnableItemRarity(val);
					if (num.HasValue)
					{
						UpdateOrAddItemSpawnRate(val, item, num.Value);
					}
				}
				catch (Exception ex)
				{
					LethalExpansion.Log.LogError((object)("Failed to add scrap '" + scrap.itemName + "' spawn chance to moon '" + val.PlanetName + "'. " + ex.Message));
				}
			}
			int? GetSpawnableItemRarity(SelectableLevel level)
			{
				//IL_01a1: Unknown result type (might be due to invalid IL or missing references)
				//IL_01a6: Unknown result type (might be due to invalid IL or missing references)
				//IL_01c7: Unknown result type (might be due to invalid IL or missing references)
				//IL_01dd: Unknown result type (might be due to invalid IL or missing references)
				//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f0: 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_0129: Unknown result type (might be due to invalid IL or missing references)
				if (scrap.useGlobalSpawnWeight)
				{
					LethalExpansion.Log.LogDebug((object)$"Using global spawn rate for '{scrap.itemName}' on '{level.PlanetName}': {scrap.globalSpawnWeight}.");
					return scrap.globalSpawnWeight;
				}
				ScrapSpawnChancePerScene[] source = scrap.perPlanetSpawnWeight();
				if (!source.Any((ScrapSpawnChancePerScene l) => l.SceneName == level.PlanetName))
				{
					if (source.Any((ScrapSpawnChancePerScene l) => l.SceneName == "Others"))
					{
						ScrapSpawnChancePerScene val2 = source.First((ScrapSpawnChancePerScene l) => l.SceneName == "Others");
						LethalExpansion.Log.LogDebug((object)$"Spawn rate for '{scrap.itemName}' on '{level.PlanetName}': {val2.SpawnWeight} (Others).");
						return val2.SpawnWeight;
					}
					LethalExpansion.Log.LogWarning((object)("No spawn rate for '" + scrap.itemName + "' on '" + level.PlanetName + "', scrap will not spawn."));
					return null;
				}
				ScrapSpawnChancePerScene val3 = source.First((ScrapSpawnChancePerScene l) => l.SceneName == level.PlanetName);
				LethalExpansion.Log.LogDebug((object)$"Spawn rate for '{scrap.itemName}' on '{level.PlanetName}': {val3.SpawnWeight}.");
				return val3.SpawnWeight;
			}
		}

		public static void UpdateOrAddItemSpawnRate(SelectableLevel level, Item item, int rarity)
		{
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Expected O, but got Unknown
			//IL_00f6: 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_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Expected O, but got Unknown
			int num = level.spawnableScrap.FindIndex((SpawnableItemWithRarity spawnableScrap) => (Object)(object)spawnableScrap.spawnableItem == (Object)(object)item);
			if (num == -1)
			{
				LethalExpansion.DebugLog.LogInfo((object)$"Added new spawn rate '{rarity}' for scrap '{item.itemName}' on moon '{level.PlanetName}'");
				level.spawnableScrap.Add(new SpawnableItemWithRarity
				{
					spawnableItem = item,
					rarity = rarity
				});
				return;
			}
			SpawnableItemWithRarity val = level.spawnableScrap[num];
			if (val.rarity != rarity)
			{
				LethalExpansion.DebugLog.LogInfo((object)$"Updated spawn rate from '{val.rarity}' to '{rarity}' for scrap '{item.itemName}' on moon '{level.PlanetName}'");
				level.spawnableScrap[num] = new SpawnableItemWithRarity
				{
					spawnableItem = item,
					rarity = rarity
				};
			}
		}

		public static void AddScrap(Scrap scrap)
		{
			Item item = VanillaItemInstancier.GetItem(scrap);
			StartOfRound.Instance.allItemsList.itemsList.Add(item);
			newScrapsNames.Add(item.itemName);
			AssetGather.Instance.AddScrap(item);
		}

		public static void RemoveMoonTerminalEntry(Terminal terminal, string moonName)
		{
			if (moonName == null)
			{
				return;
			}
			try
			{
				int num = countEntries();
				terminal.moonsCatalogueList = terminal.moonsCatalogueList.Where((SelectableLevel moon) => !((Object)moon).name.Contains(moonName)).ToArray();
				routeKeyword.compatibleNouns = routeKeyword.compatibleNouns.Where((CompatibleNoun noun) => !((Object)noun.noun).name.Contains(moonName)).ToArray();
				infoKeyword.compatibleNouns = infoKeyword.compatibleNouns.Where((CompatibleNoun noun) => !((Object)noun.noun).name.Contains(moonName)).ToArray();
				if (num - countEntries() != 0)
				{
					LethalExpansion.Log.LogInfo((object)("Removed terminal entry for moon '" + moonName + "'"));
				}
				else
				{
					LethalExpansion.Log.LogInfo((object)("Terminal entry for moon '" + moonName + "' does not exist"));
				}
			}
			catch (Exception ex)
			{
				LethalExpansion.Log.LogError((object)("Failed to remove terminal entry for moon '" + moonName + "'. " + ex.Message));
			}
			int countEntries()
			{
				return terminal.moonsCatalogueList.Length + routeKeyword.compatibleNouns.Length + infoKeyword.compatibleNouns.Length;
			}
		}

		public static void AddMoons()
		{
			if (moonsPatched)
			{
				return;
			}
			newMoonsNames.Clear();
			newMoons.Clear();
			List<string> list = (from excludedMoon in LethalExpansion.Settings.ExcludedMoons.Value.Split(new char[1] { ',' })
				select excludedMoon.ToLower()).ToList();
			bool flag = list.Contains("hidden");
			foreach (KeyValuePair<string, (AssetBundle, ModManifest)> contentAssetBundle in AssetBundlesManager.Instance.contentAssetBundles)
			{
				var (val, val2) = AssetBundlesManager.Instance.Load(contentAssetBundle.Key);
				if ((Object)(object)val == (Object)null || (Object)(object)val2 == (Object)null || val2.moons == null)
				{
					continue;
				}
				Moon[] moons = val2.moons;
				foreach (Moon val3 in moons)
				{
					if (!AssetBundlesManager.Instance.IsMoonCompatible(val3))
					{
						continue;
					}
					if (newMoonsNames.Contains(val3.MoonName))
					{
						LethalExpansion.Log.LogWarning((object)("Moon '" + val3.MoonName + "' has already been added"));
						continue;
					}
					if (flag && val3.IsHidden)
					{
						LethalExpansion.Log.LogWarning((object)("Hidden moon '" + val3.MoonName + "' was excluded in the config"));
						continue;
					}
					if (list.Contains(val3.MoonName?.ToLower()) || list.Contains(val3.PlanetName?.ToLower()))
					{
						LethalExpansion.Log.LogWarning((object)("Moon '" + val3.MoonName + "' was excluded in the config"));
						continue;
					}
					try
					{
						SelectableLevel val4 = CreateMoon(val3);
						StartOfRound.Instance.levels = CollectionExtensions.AddItem<SelectableLevel>((IEnumerable<SelectableLevel>)StartOfRound.Instance.levels, val4).ToArray();
						newMoons.Add(val4.levelID, val3);
						newMoonsNames.Add(val3.MoonName);
						LethalExpansion.Log.LogInfo((object)("Added moon '" + val3.MoonName + "'"));
					}
					catch (Exception ex)
					{
						LethalExpansion.Log.LogError((object)("Failed to add moon '" + val3.MoonName + "'. " + ex.Message));
					}
				}
			}
			moonsPatched = true;
		}

		public static void AddMoonTerminalEntries(Terminal __instance)
		{
			if (moonsTerminalPatched)
			{
				return;
			}
			foreach (KeyValuePair<int, Moon> moonEntry in newMoons)
			{
				SelectableLevel val = ((IEnumerable<SelectableLevel>)StartOfRound.Instance.levels).FirstOrDefault((Func<SelectableLevel, bool>)((SelectableLevel level) => level.levelID == moonEntry.Key));
				if ((Object)(object)val == (Object)null)
				{
					LethalExpansion.Log.LogWarning((object)("Unable to add terminal entry for moon '" + moonEntry.Value.MoonName + "', it does not exist"));
					continue;
				}
				AddMoonTerminalEntry(__instance, moonEntry.Value, val);
				LethalExpansion.Log.LogInfo((object)("Added terminal entry for moon '" + moonEntry.Value.MoonName + "'"));
			}
			moonsTerminalPatched = true;
		}

		public static SelectableLevel CreateMoon(Moon moon)
		{
			//IL_016a: Unknown result type (might be due to invalid IL or missing references)
			//IL_016f: 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_0205: Unknown result type (might be due to invalid IL or missing references)
			//IL_020a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0217: Unknown result type (might be due to invalid IL or missing references)
			//IL_0275: Unknown result type (might be due to invalid IL or missing references)
			//IL_0244: Unknown result type (might be due to invalid IL or missing references)
			SelectableLevel val = ScriptableObject.CreateInstance<SelectableLevel>();
			((Object)val).name = moon.PlanetName;
			val.PlanetName = moon.PlanetName;
			val.sceneName = "InitSceneLaunchOptions";
			val.levelID = StartOfRound.Instance.levels.Length;
			if (!string.IsNullOrEmpty(moon.OrbitPrefabName) && AssetGather.Instance.planetPrefabs.ContainsKey(moon.OrbitPrefabName))
			{
				val.planetPrefab = AssetGather.Instance.planetPrefabs[moon.OrbitPrefabName];
			}
			else
			{
				val.planetPrefab = AssetGather.Instance.planetPrefabs.First().Value;
			}
			val.lockedForDemo = true;
			val.spawnEnemiesAndScrap = moon.SpawnEnemiesAndScrap;
			if (!string.IsNullOrWhiteSpace(moon.PlanetDescription))
			{
				val.LevelDescription = moon.PlanetDescription;
			}
			else
			{
				val.LevelDescription = string.Empty;
			}
			val.videoReel = moon.PlanetVideo;
			if (!string.IsNullOrEmpty(moon.RiskLevel))
			{
				val.riskLevel = moon.RiskLevel ?? string.Empty;
			}
			else
			{
				val.riskLevel = string.Empty;
			}
			val.timeToArrive = moon.TimeToArrive;
			val.DaySpeedMultiplier = moon.DaySpeedMultiplier;
			val.planetHasTime = moon.PlanetHasTime;
			val.factorySizeMultiplier = moon.FactorySizeMultiplier;
			val.overrideWeather = moon.OverwriteWeather;
			val.overrideWeatherType = (LevelWeatherType)moon.OverwriteWeatherType;
			val.currentWeather = (LevelWeatherType)(-1);
			val.randomWeathers = ((IEnumerable<RandomWeatherPair>)moon.RandomWeatherTypes()).Select((Func<RandomWeatherPair, RandomWeatherWithVariables>)((RandomWeatherPair weather) => new RandomWeatherWithVariables
			{
				weatherType = (LevelWeatherType)weather.Weather,
				weatherVariable = weather.WeatherVariable1,
				weatherVariable2 = weather.WeatherVariable2
			})).ToArray();
			val.dungeonFlowTypes = ((IEnumerable<DungeonFlowPair>)moon.DungeonFlowTypes()).Select((Func<DungeonFlowPair, IntWithRarity>)((DungeonFlowPair dungeonFlow) => new IntWithRarity
			{
				id = dungeonFlow.ID,
				rarity = dungeonFlow.Rarity
			})).ToArray();
			val.spawnableScrap = new List<SpawnableItemWithRarity>();
			SpawnableScrapPair[] array = moon.SpawnableScrap();
			foreach (SpawnableScrapPair val2 in array)
			{
				if (!AssetGather.Instance.scraps.TryGetValue(val2.ObjectName, out var value))
				{
					LethalExpansion.Log.LogWarning((object)("Scrap '" + val2.ObjectName + "' on moon '" + moon.MoonName + "' could not be found, it has not been registered"));
				}
				else
				{
					UpdateOrAddItemSpawnRate(val, value, val2.SpawnWeight);
				}
			}
			val.minScrap = moon.MinScrap;
			val.maxScrap = moon.MaxScrap;
			if (!string.IsNullOrEmpty(moon.LevelAmbienceClips) && AssetGather.Instance.levelAmbiances.ContainsKey(moon.LevelAmbienceClips))
			{
				val.levelAmbienceClips = AssetGather.Instance.levelAmbiances[moon.LevelAmbienceClips];
			}
			else
			{
				val.levelAmbienceClips = AssetGather.Instance.levelAmbiances.First().Value;
			}
			val.maxEnemyPowerCount = moon.MaxEnemyPowerCount;
			val.Enemies = ((IEnumerable<SpawnableEnemiesPair>)moon.Enemies()).Select((Func<SpawnableEnemiesPair, SpawnableEnemyWithRarity>)((SpawnableEnemiesPair enemy) => new SpawnableEnemyWithRarity
			{
				enemyType = AssetGather.Instance.enemies[enemy.EnemyName],
				rarity = enemy.SpawnWeight
			})).ToList();
			val.enemySpawnChanceThroughoutDay = moon.EnemySpawnChanceThroughoutDay;
			val.spawnProbabilityRange = moon.SpawnProbabilityRange;
			val.spawnableMapObjects = ((IEnumerable<SpawnableMapObjectPair>)moon.SpawnableMapObjects()).Select((Func<SpawnableMapObjectPair, SpawnableMapObject>)((SpawnableMapObjectPair item) => new SpawnableMapObject
			{
				prefabToSpawn = AssetGather.Instance.mapObjects[item.ObjectName],
				spawnFacingAwayFromWall = item.SpawnFacingAwayFromWall,
				numberToSpawn = item.SpawnRate
			})).ToArray();
			val.spawnableOutsideObjects = ((IEnumerable<SpawnableOutsideObjectPair>)moon.SpawnableOutsideObjects()).Select((Func<SpawnableOutsideObjectPair, SpawnableOutsideObjectWithRarity>)((SpawnableOutsideObjectPair item) => new SpawnableOutsideObjectWithRarity
			{
				spawnableObject = AssetGather.Instance.outsideObjects[item.ObjectName],
				randomAmount = item.SpawnRate
			})).ToArray();
			val.maxOutsideEnemyPowerCount = moon.MaxOutsideEnemyPowerCount;
			val.maxDaytimeEnemyPowerCount = moon.MaxDaytimeEnemyPowerCount;
			val.OutsideEnemies = ((IEnumerable<SpawnableEnemiesPair>)moon.OutsideEnemies()).Select((Func<SpawnableEnemiesPair, SpawnableEnemyWithRarity>)((SpawnableEnemiesPair enemy) => new SpawnableEnemyWithRarity
			{
				enemyType = AssetGather.Instance.enemies[enemy.EnemyName],
				rarity = enemy.SpawnWeight
			})).ToList();
			val.DaytimeEnemies = ((IEnumerable<SpawnableEnemiesPair>)moon.DaytimeEnemies()).Select((Func<SpawnableEnemiesPair, SpawnableEnemyWithRarity>)((SpawnableEnemiesPair enemy) => new SpawnableEnemyWithRarity
			{
				enemyType = AssetGather.Instance.enemies[enemy.EnemyName],
				rarity = enemy.SpawnWeight
			})).ToList();
			val.outsideEnemySpawnChanceThroughDay = moon.OutsideEnemySpawnChanceThroughDay;
			val.daytimeEnemySpawnChanceThroughDay = moon.DaytimeEnemySpawnChanceThroughDay;
			val.daytimeEnemiesProbabilityRange = moon.DaytimeEnemiesProbabilityRange;
			val.levelIncludesSnowFootprints = moon.LevelIncludesSnowFootprints;
			return val;
		}

		public static void AddMoonTerminalEntry(Terminal terminal, Moon newMoon, SelectableLevel newLevel)
		{
			//IL_0267: Unknown result type (might be due to invalid IL or missing references)
			//IL_026c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0273: Unknown result type (might be due to invalid IL or missing references)
			//IL_027d: Unknown result type (might be due to invalid IL or missing references)
			//IL_028b: Expected O, but got Unknown
			//IL_028d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0292: Unknown result type (might be due to invalid IL or missing references)
			//IL_0299: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a2: Expected O, but got Unknown
			//IL_02a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ac: 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_02bd: Expected O, but got Unknown
			//IL_0377: Unknown result type (might be due to invalid IL or missing references)
			//IL_037c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0383: Unknown result type (might be due to invalid IL or missing references)
			//IL_038d: Expected O, but got Unknown
			TerminalKeyword noun = terminal.terminalNodes.allKeywords.First((TerminalKeyword k) => k.word == "confirm");
			TerminalKeyword noun2 = terminal.terminalNodes.allKeywords.First((TerminalKeyword k) => k.word == "deny");
			TerminalNode val = null;
			CompatibleNoun[] terminalOptions = routeKeyword.compatibleNouns[0].result.terminalOptions;
			foreach (Com