using System;
using System.CodeDom.Compiler;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using System.Threading.Tasks;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using Dawn;
using Dawn.Interfaces;
using Dawn.Internal;
using Dawn.Utils;
using DunGen;
using DunGen.Graph;
using GameNetcodeStuff;
using GoodItemScan;
using HarmonyLib;
using IL;
using LethalConfig.AutoConfig;
using LethalConfig.ConfigItems;
using LethalLevelLoader;
using LethalLib.Modules;
using LethalQuantities.Objects;
using LethalQuantities.Patches;
using Microsoft.CodeAnalysis;
using Mono.Cecil;
using Mono.Cecil.Cil;
using MonoMod.Cil;
using MonoMod.RuntimeDetour;
using MrovLib.Events;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using On;
using On.BepInEx.Configuration;
using On.DunGen;
using On.TMPro;
using On.Unity.Netcode;
using PathfindingLib.API.SmartPathfinding;
using Steamworks;
using TMPro;
using TerminalFormatter.Nodes;
using Unity.Netcode;
using Unity.Netcode.Components;
using UnityEngine;
using UnityEngine.AI;
using UnityEngine.Audio;
using UnityEngine.Events;
using UnityEngine.InputSystem.Utilities;
using UnityEngine.UI;
using WeatherRegistry;
using com.github.teamxiaolan.dawnlib.NetcodePatcher;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: InternalsVisibleTo("com.github.teamxiaolan.dawnlib.dusk")]
[assembly: IgnoresAccessChecksTo("AmazingAssets.TerrainToMesh")]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp-firstpass")]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp")]
[assembly: IgnoresAccessChecksTo("ClientNetworkTransform")]
[assembly: IgnoresAccessChecksTo("com.olegknyazev.softmask")]
[assembly: IgnoresAccessChecksTo("DissonanceVoip")]
[assembly: IgnoresAccessChecksTo("EasyTextEffects")]
[assembly: IgnoresAccessChecksTo("Facepunch Transport for Netcode for GameObjects")]
[assembly: IgnoresAccessChecksTo("Facepunch.Steamworks.Win64")]
[assembly: IgnoresAccessChecksTo("GoodItemScan")]
[assembly: IgnoresAccessChecksTo("LethalConfig")]
[assembly: IgnoresAccessChecksTo("LethalLevelLoader")]
[assembly: IgnoresAccessChecksTo("LethalLib")]
[assembly: IgnoresAccessChecksTo("LethalQuantities")]
[assembly: IgnoresAccessChecksTo("MMHOOK_Unity.TextMeshPro")]
[assembly: IgnoresAccessChecksTo("MrovLib")]
[assembly: IgnoresAccessChecksTo("StarlancerAI")]
[assembly: IgnoresAccessChecksTo("Unity.AI.Navigation")]
[assembly: IgnoresAccessChecksTo("Unity.Animation.Rigging")]
[assembly: IgnoresAccessChecksTo("Unity.Animation.Rigging.DocCodeExamples")]
[assembly: IgnoresAccessChecksTo("Unity.Burst")]
[assembly: IgnoresAccessChecksTo("Unity.Burst.Unsafe")]
[assembly: IgnoresAccessChecksTo("Unity.Collections")]
[assembly: IgnoresAccessChecksTo("Unity.Collections.LowLevel.ILSupport")]
[assembly: IgnoresAccessChecksTo("Unity.InputSystem")]
[assembly: IgnoresAccessChecksTo("Unity.InputSystem.ForUI")]
[assembly: IgnoresAccessChecksTo("Unity.Jobs")]
[assembly: IgnoresAccessChecksTo("Unity.Mathematics")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.Common")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.MetricTypes")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.NetStats")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.NetStatsMonitor.Component")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.NetStatsMonitor.Configuration")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.NetStatsMonitor.Implementation")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.NetStatsReporting")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.NetworkProfiler.Runtime")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.NetworkSolutionInterface")]
[assembly: IgnoresAccessChecksTo("Unity.Netcode.Components")]
[assembly: IgnoresAccessChecksTo("Unity.Netcode.Runtime")]
[assembly: IgnoresAccessChecksTo("Unity.Networking.Transport")]
[assembly: IgnoresAccessChecksTo("Unity.ProBuilder.Csg")]
[assembly: IgnoresAccessChecksTo("Unity.ProBuilder")]
[assembly: IgnoresAccessChecksTo("Unity.ProBuilder.KdTree")]
[assembly: IgnoresAccessChecksTo("Unity.ProBuilder.Poly2Tri")]
[assembly: IgnoresAccessChecksTo("Unity.ProBuilder.Stl")]
[assembly: IgnoresAccessChecksTo("Unity.Profiling.Core")]
[assembly: IgnoresAccessChecksTo("Unity.RenderPipelines.Core.Runtime")]
[assembly: IgnoresAccessChecksTo("Unity.RenderPipelines.Core.ShaderLibrary")]
[assembly: IgnoresAccessChecksTo("Unity.RenderPipelines.HighDefinition.Config.Runtime")]
[assembly: IgnoresAccessChecksTo("Unity.RenderPipelines.HighDefinition.Runtime")]
[assembly: IgnoresAccessChecksTo("Unity.RenderPipelines.ShaderGraph.ShaderGraphLibrary")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Authentication")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Analytics")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Components")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Configuration")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Device")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Environments")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Environments.Internal")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Internal")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Networking")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Registration")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Scheduler")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Telemetry")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Threading")]
[assembly: IgnoresAccessChecksTo("Unity.Services.QoS")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Relay")]
[assembly: IgnoresAccessChecksTo("Unity.TextMeshPro")]
[assembly: IgnoresAccessChecksTo("Unity.Timeline")]
[assembly: IgnoresAccessChecksTo("Unity.VisualEffectGraph.Runtime")]
[assembly: IgnoresAccessChecksTo("UnityEngine.ARModule")]
[assembly: IgnoresAccessChecksTo("UnityEngine.NVIDIAModule")]
[assembly: IgnoresAccessChecksTo("UnityEngine.UI")]
[assembly: IgnoresAccessChecksTo("WeatherRegistry")]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("XuXiaolan,loaforc")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyDescription("A modern API for Lethal Company content and all sizes of mods.")]
[assembly: AssemblyFileVersion("0.4.3.0")]
[assembly: AssemblyInformationalVersion("0.4.3+beec3bd066ed9e9cf3d67aa86121d7c5e60c8b43")]
[assembly: AssemblyProduct("DawnLib")]
[assembly: AssemblyTitle("com.github.teamxiaolan.dawnlib")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.4.3.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
[module: NetcodePatchedAssembly]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[CompilerGenerated]
	[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 sealed class Vector3Converter : JsonConverter<Vector3>
{
	public override void WriteJson(JsonWriter writer, Vector3 value, JsonSerializer serializer)
	{
		//IL_0012: Unknown result type (might be due to invalid IL or missing references)
		//IL_0029: Unknown result type (might be due to invalid IL or missing references)
		//IL_0040: Unknown result type (might be due to invalid IL or missing references)
		writer.WriteStartObject();
		writer.WritePropertyName("x");
		writer.WriteValue(value.x);
		writer.WritePropertyName("y");
		writer.WriteValue(value.y);
		writer.WritePropertyName("z");
		writer.WriteValue(value.z);
		writer.WriteEndObject();
	}

	public override Vector3 ReadJson(JsonReader reader, Type objectType, Vector3 existingValue, bool hasExistingValue, JsonSerializer serializer)
	{
		//IL_0013: Unknown result type (might be due to invalid IL or missing references)
		//IL_0019: Invalid comparison between Unknown and I4
		//IL_0020: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a8: 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_00a3: Invalid comparison between Unknown and I4
		//IL_0027: Unknown result type (might be due to invalid IL or missing references)
		//IL_002d: Invalid comparison between Unknown and I4
		float num = 0f;
		float num2 = 0f;
		float num3 = 0f;
		if ((int)reader.TokenType != 1)
		{
			throw new JsonSerializationException("Expected StartObject for Vector3");
		}
		while (reader.Read() && (int)reader.TokenType != 13)
		{
			if ((int)reader.TokenType == 4)
			{
				string text = (string)reader.Value;
				reader.Read();
				switch (text)
				{
				case "x":
					num = Convert.ToSingle(reader.Value);
					break;
				case "y":
					num2 = Convert.ToSingle(reader.Value);
					break;
				case "z":
					num3 = Convert.ToSingle(reader.Value);
					break;
				}
			}
		}
		return new Vector3(num, num2, num3);
	}
}
public class DawnMapObjectInfoContainer : DawnInfoContainer<DawnMapObjectInfo>
{
}
public class DawnMapObjectNamespacedKeyContainer : MonoBehaviour
{
	[field: SerializeField]
	public NamespacedKey Value { get; internal set; }
}
namespace Dawn
{
	public abstract class BaseInfoBuilder
	{
		internal abstract void SoloAddTags(IEnumerable<NamespacedKey> newTags);
	}
	public abstract class BaseInfoBuilder<TInfo, T, TBuilder> : BaseInfoBuilder where TInfo : INamespaced<TInfo> where TBuilder : BaseInfoBuilder<TInfo, T, TBuilder>
	{
		protected HashSet<NamespacedKey> tags = new HashSet<NamespacedKey>();

		protected IDataContainer? customData;

		protected NamespacedKey<TInfo> key { get; private set; }

		protected T value { get; private set; }

		internal BaseInfoBuilder(NamespacedKey<TInfo> key, T value)
		{
			this.key = key;
			this.value = value;
		}

		public TBuilder AddTag(NamespacedKey tag)
		{
			tags.Add(tag);
			return (TBuilder)this;
		}

		public TBuilder AddTags(IEnumerable<NamespacedKey> newTags)
		{
			foreach (NamespacedKey newTag in newTags)
			{
				AddTag(newTag);
			}
			return (TBuilder)this;
		}

		internal override void SoloAddTags(IEnumerable<NamespacedKey> newTags)
		{
			AddTags(newTags);
		}

		public TBuilder EditCustomData(Action<IDataContainer> callback)
		{
			if (customData == null)
			{
				customData = new DataContainer();
			}
			callback(customData);
			return (TBuilder)this;
		}

		internal abstract TInfo Build();
	}
	[JsonObject(/*Could not decode attribute arguments.*/)]
	public class DataContainer : IDataContainer
	{
		private class NoOpDisposable : IDisposable
		{
			public void Dispose()
			{
			}
		}

		[JsonProperty]
		protected Dictionary<NamespacedKey, object> dictionary = new Dictionary<NamespacedKey, object>();

		public IEnumerable<NamespacedKey> Keys => dictionary.Keys;

		public int Count => dictionary.Count;

		public bool Has(NamespacedKey key)
		{
			return dictionary.ContainsKey(key);
		}

		public bool TryGet<T>(NamespacedKey key, [NotNullWhen(true)] out T? value)
		{
			if (dictionary.TryGetValue(key, out object value2))
			{
				JToken val = (JToken)((value2 is JToken) ? value2 : null);
				if (val != null)
				{
					value = val.ToObject<T>();
					return true;
				}
				if (value2 is T val2)
				{
					value = val2;
					return true;
				}
				if (typeof(T) == typeof(int) && value2 is long num)
				{
					value = (T)(object)(int)num;
					return true;
				}
				if (typeof(T) == typeof(long) && value2 is int num2)
				{
					value = (T)(object)(long)num2;
					return true;
				}
				throw new InvalidCastException($"type of '{key}' is {value2.GetType().Name} which can not be {typeof(T).Name}");
			}
			value = default(T);
			return false;
		}

		public T GetOrSetDefault<T>(NamespacedKey key, T defaultValue)
		{
			if (TryGet<T>(key, out T value))
			{
				return value;
			}
			Set(key, defaultValue);
			return defaultValue;
		}

		public T GetOrCreateDefault<T>(NamespacedKey key) where T : new()
		{
			if (TryGet<T>(key, out T value))
			{
				return value;
			}
			value = new T();
			Set(key, value);
			return value;
		}

		public virtual void Set<T>(NamespacedKey key, T value)
		{
			if (value == null)
			{
				throw new ArgumentNullException("value");
			}
			dictionary[key] = value;
		}

		public virtual void Remove(NamespacedKey key)
		{
			dictionary.Remove(key);
		}

		public virtual void Clear()
		{
			dictionary.Clear();
		}

		public virtual void MarkDirty()
		{
		}

		public virtual IDisposable CreateEditContext()
		{
			return new NoOpDisposable();
		}
	}
	public class FrozenEmptyDataContainer : IDataContainer
	{
		public static FrozenEmptyDataContainer Instance { get; private set; } = new FrozenEmptyDataContainer();


		public IEnumerable<NamespacedKey> Keys { get; } = Array.Empty<NamespacedKey>();


		public int Count => 0;

		private FrozenEmptyDataContainer()
		{
		}

		public bool TryGet<T>(NamespacedKey key, [NotNullWhen(true)] out T? value)
		{
			value = default(T);
			return false;
		}

		public T GetOrSetDefault<T>(NamespacedKey key, T defaultValue)
		{
			throw new RegistryFrozenException();
		}

		public T GetOrCreateDefault<T>(NamespacedKey key) where T : new()
		{
			throw new RegistryFrozenException();
		}

		public void Set<T>(NamespacedKey key, T value)
		{
			throw new RegistryFrozenException();
		}

		public void Remove(NamespacedKey key)
		{
			throw new RegistryFrozenException();
		}

		public void Clear()
		{
			throw new RegistryFrozenException();
		}

		public void MarkDirty()
		{
			throw new RegistryFrozenException();
		}

		public IDisposable CreateEditContext()
		{
			throw new RegistryFrozenException();
		}
	}
	public interface IDataContainer
	{
		IEnumerable<NamespacedKey> Keys { get; }

		int Count { get; }

		bool TryGet<T>(NamespacedKey key, [NotNullWhen(true)] out T? value);

		T GetOrSetDefault<T>(NamespacedKey key, T defaultValue);

		T GetOrCreateDefault<T>(NamespacedKey key) where T : new();

		void Set<T>(NamespacedKey key, T value);

		void Remove(NamespacedKey key);

		void Clear();

		void MarkDirty();

		IDisposable CreateEditContext();
	}
	public interface INamespaced
	{
		NamespacedKey Key { get; }
	}
	public interface INamespaced<T> : INamespaced where T : INamespaced<T>
	{
		NamespacedKey<T> TypedKey { get; }
	}
	public class JSONTagDefinition
	{
		public string Tag;

		public string[] Values;
	}
	[Serializable]
	public class NamespacedKey : INetworkSerializable
	{
		private static readonly Regex NamespacedKeyRegex = new Regex("[?!.\\n\\t\"`\\[\\]'-]");

		private static readonly Dictionary<char, string> NumberWords = new Dictionary<char, string>
		{
			{ '0', "Zero" },
			{ '1', "One" },
			{ '2', "Two" },
			{ '3', "Three" },
			{ '4', "Four" },
			{ '5', "Five" },
			{ '6', "Six" },
			{ '7', "Seven" },
			{ '8', "Eight" },
			{ '9', "Nine" }
		};

		public const char Separator = ':';

		public const string VanillaNamespace = "lethal_company";

		[SerializeField]
		private string _namespace;

		[SerializeField]
		private string _key;

		public string Namespace => _namespace;

		public string Key => _key;

		internal static string NormalizeStringForNamespacedKey(string input, bool CSharpName)
		{
			if (string.IsNullOrEmpty(input))
			{
				return string.Empty;
			}
			string text = NamespacedKeyRegex.Replace(input, string.Empty);
			StringBuilder stringBuilder = new StringBuilder(text.Length);
			bool flag = false;
			string text2 = text;
			foreach (char c in text2)
			{
				if (flag || (!char.IsDigit(c) && c != ' '))
				{
					flag = true;
					stringBuilder.Append(c);
				}
			}
			StringBuilder stringBuilder2 = new StringBuilder(stringBuilder.Length);
			string text3 = stringBuilder.ToString();
			foreach (char c2 in text3)
			{
				if (NumberWords.TryGetValue(c2, out string value))
				{
					stringBuilder2.Append(value);
				}
				else
				{
					stringBuilder2.Append(c2);
				}
			}
			string text4 = stringBuilder2.ToString();
			if (CSharpName)
			{
				text4 = text4.Replace(" ", "");
				text4 = text4.Replace("_", "");
				return text4.ToCapitalized();
			}
			return text4.ToLowerInvariant().Replace(" ", "_");
		}

		protected NamespacedKey(string @namespace, string key)
		{
			_namespace = @namespace;
			_key = key;
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public NamespacedKey()
		{
		}

		public static NamespacedKey From(string @namespace, string key)
		{
			return new NamespacedKey(@namespace, key);
		}

		public static NamespacedKey Vanilla(string key)
		{
			return From("lethal_company", key);
		}

		public static NamespacedKey Parse(string input)
		{
			string[] array = input.Split(':');
			return From(array[0], array[1]);
		}

		public static bool TryParse(string input, [NotNullWhen(true)] out NamespacedKey? result)
		{
			result = null;
			string[] array = input.Split(':');
			if (array.Length != 2)
			{
				return false;
			}
			result = From(array[0], array[1]);
			return true;
		}

		public static NamespacedKey ForceParse(string input)
		{
			string[] array = input.Split(':');
			if (array.Length == 1)
			{
				array = new string[2]
				{
					"lethal_company",
					array[0]
				};
			}
			return From(array[0], array[1]);
		}

		public override string ToString()
		{
			return $"{Namespace}{':'}{Key}";
		}

		public void NetworkSerialize<T>(BufferSerializer<T> serializer) where T : IReaderWriter
		{
			serializer.SerializeValue(ref _namespace, false);
			serializer.SerializeValue(ref _key, false);
		}

		public override bool Equals(object? obj)
		{
			if (obj == null)
			{
				return false;
			}
			NamespacedKey namespacedKey = (NamespacedKey)obj;
			if (Namespace == namespacedKey.Namespace)
			{
				return Key == namespacedKey.Key;
			}
			return false;
		}

		public override int GetHashCode()
		{
			int num = 13;
			num = num * 17 + Namespace.GetHashCode();
			return num * 17 + Key.GetHashCode();
		}

		public NamespacedKey<T> AsTyped<T>() where T : INamespaced
		{
			return NamespacedKey<T>.From(Namespace, Key);
		}

		public bool IsVanilla()
		{
			return Namespace == "lethal_company";
		}

		public bool IsModded()
		{
			return !IsVanilla();
		}
	}
	[Serializable]
	public class NamespacedKey<T> : NamespacedKey where T : INamespaced
	{
		protected NamespacedKey(string @namespace, string key)
			: base(@namespace, key)
		{
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public NamespacedKey()
		{
		}

		public new static NamespacedKey<T> From(string @namespace, string key)
		{
			return new NamespacedKey<T>(@namespace, key);
		}

		public new static NamespacedKey<T> Vanilla(string key)
		{
			return From("lethal_company", key);
		}

		public new static NamespacedKey<T> Parse(string input)
		{
			string[] array = input.Split(':');
			return From(array[0], array[1]);
		}
	}
	public class NamespacedKeyConverter : JsonConverter
	{
		public override void WriteJson(JsonWriter writer, object? value, JsonSerializer serializer)
		{
			if (value is NamespacedKey namespacedKey)
			{
				writer.WriteValue(namespacedKey.ToString());
			}
			else
			{
				writer.WriteNull();
			}
		}

		public override object? ReadJson(JsonReader reader, Type objectType, object? existingValue, JsonSerializer serializer)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Invalid comparison between Unknown and I4
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			if ((int)reader.TokenType == 11)
			{
				return null;
			}
			string text = reader.Value?.ToString();
			if (text == null)
			{
				return null;
			}
			NamespacedKey namespacedKey = NamespacedKey.ForceParse(text);
			if (objectType == typeof(NamespacedKey))
			{
				return namespacedKey;
			}
			if (objectType.IsGenericType && objectType.GetGenericTypeDefinition() == typeof(NamespacedKey<>))
			{
				MethodInfo method = typeof(NamespacedKey).GetMethod("AsTyped");
				MethodInfo methodInfo = method.MakeGenericMethod(objectType.GetGenericArguments()[0]);
				return methodInfo.Invoke(namespacedKey, null);
			}
			throw new JsonSerializationException($"Cannot deserialize {objectType}");
		}

		public override bool CanConvert(Type objectType)
		{
			if (objectType == typeof(NamespacedKey))
			{
				return true;
			}
			if (objectType.IsGenericType && objectType.GetGenericTypeDefinition() == typeof(NamespacedKey<>))
			{
				return true;
			}
			return false;
		}
	}
	public class NamespacedKeyDictionaryConverter : JsonConverter
	{
		public override bool CanConvert(Type objectType)
		{
			if (objectType.IsGenericType && objectType.GetGenericTypeDefinition() == typeof(Dictionary<, >))
			{
				return objectType.GetGenericArguments()[0] == typeof(NamespacedKey);
			}
			return false;
		}

		public override void WriteJson(JsonWriter writer, object? value, JsonSerializer serializer)
		{
			writer.WriteStartObject();
			IDictionary dictionary = (IDictionary)value;
			List<object> list = new List<object>();
			foreach (object key in dictionary.Keys)
			{
				list.Add(key);
			}
			foreach (object item in list)
			{
				NamespacedKey namespacedKey = (NamespacedKey)item;
				object obj = dictionary[item];
				writer.WritePropertyName(namespacedKey.ToString());
				serializer.Serialize(writer, obj);
			}
			writer.WriteEndObject();
		}

		public override object ReadJson(JsonReader reader, Type objectType, object? existingValue, JsonSerializer serializer)
		{
			Type type = objectType.GetGenericArguments()[1];
			Type type2 = typeof(Dictionary<, >).MakeGenericType(typeof(NamespacedKey), type);
			IDictionary dictionary = (IDictionary)Activator.CreateInstance(type2);
			JObject val = JObject.Load(reader);
			foreach (JProperty item in val.Properties())
			{
				NamespacedKey key = NamespacedKey.ForceParse(item.Name);
				object value = item.Value.ToObject(type, serializer);
				dictionary[key] = value;
			}
			return dictionary;
		}
	}
	public class PersistentDataContainer : DataContainer
	{
		public class EditContext : IDisposable
		{
			private PersistentDataContainer _container;

			private bool _prevAutoSave;

			public EditContext(PersistentDataContainer container)
			{
				_container = container;
				_prevAutoSave = _container.AutoSave;
				_container.AutoSave = false;
			}

			public void Dispose()
			{
				_container.AutoSave = _prevAutoSave;
				_container.MarkDirty();
			}
		}

		private string _filePath;

		private readonly SemaphoreSlim _saveLock = new SemaphoreSlim(1, 1);

		public bool AutoSave { get; private set; } = true;


		internal static List<PersistentDataContainer> HasCorruptedData { get; private set; } = new List<PersistentDataContainer>();


		public string FileName => Path.GetFileName(_filePath);

		public PersistentDataContainer(string filePath)
		{
			Debuggers.PersistentDataContainer?.Log("new PersistentDataContainer: " + Path.GetFileName(filePath));
			_filePath = filePath;
			if (!File.Exists(filePath))
			{
				return;
			}
			Debuggers.PersistentDataContainer?.Log("loading existing file");
			try
			{
				dictionary = JsonConvert.DeserializeObject<Dictionary<NamespacedKey, object>>(File.ReadAllText(_filePath), DawnLib.JSONSettings);
			}
			catch (Exception arg)
			{
				DawnPlugin.Logger.LogFatal((object)$"Exception when loading from persistent data container ({Path.GetFileName(_filePath)}):\n{arg}");
				HasCorruptedData.Add(this);
				return;
			}
			foreach (object value in dictionary.Values)
			{
				if (value is ChildPersistentDataContainer childPersistentDataContainer)
				{
					Debuggers.PersistentDataContainer?.Log(string.Format("updated parent for a loaded persistent data container. count = {0}: {1}", childPersistentDataContainer.Count, string.Join(", ", childPersistentDataContainer.Keys.Select((NamespacedKey it) => it.ToString()))));
					childPersistentDataContainer.Internal_SetParent(this);
				}
			}
			Debuggers.PersistentDataContainer?.Log($"loaded {dictionary.Count} entries.");
		}

		public override void Set<T>(NamespacedKey key, T value)
		{
			if (value is IDataContainer && !(value is ChildPersistentDataContainer))
			{
				throw new NotSupportedException($"{key} is a {value.GetType().Name}, which is not supported by persistent data container. Only ChildPersistentDataContainer is supported.");
			}
			if ((object)value is ChildPersistentDataContainer childPersistentDataContainer && childPersistentDataContainer.Parent != this)
			{
				throw new NotSupportedException($"{key} is a child persistent data container being added to '{FileName}' when it belongs to '{childPersistentDataContainer.Parent.FileName}'.");
			}
			base.Set(key, value);
			if (AutoSave)
			{
				Task.Run((Func<Task?>)SaveAsync);
			}
		}

		public override void Clear()
		{
			base.Clear();
			if (AutoSave)
			{
				MarkDirty();
			}
		}

		public override void Remove(NamespacedKey key)
		{
			base.Remove(key);
			if (AutoSave)
			{
				MarkDirty();
			}
		}

		[Obsolete("Use CreateEditContext()")]
		public IDisposable LargeEdit()
		{
			return CreateEditContext();
		}

		public override IDisposable CreateEditContext()
		{
			return new EditContext(this);
		}

		public override void MarkDirty()
		{
			Task.Run((Func<Task?>)SaveAsync);
		}

		private async Task SaveAsync()
		{
			Debuggers.PersistentDataContainer?.Log("saving (" + Path.GetFileName(_filePath) + ")");
			await _saveLock.WaitAsync().ConfigureAwait(continueOnCapturedContext: false);
			try
			{
				FileStream stream = new FileStream(_filePath, FileMode.Create, FileAccess.Write, FileShare.None, 4096, useAsync: true);
				try
				{
					using StreamWriter writer = new StreamWriter(stream, Encoding.UTF8);
					string value = JsonConvert.SerializeObject((object)dictionary, DawnLib.JSONSettings);
					await writer.WriteAsync(value).ConfigureAwait(continueOnCapturedContext: false);
					await writer.FlushAsync().ConfigureAwait(continueOnCapturedContext: false);
					await stream.FlushAsync().ConfigureAwait(continueOnCapturedContext: false);
					Debuggers.PersistentDataContainer?.Log("saved (" + Path.GetFileName(_filePath) + ")");
				}
				finally
				{
					if (stream != null)
					{
						await stream.DisposeAsync();
					}
				}
			}
			catch (Exception arg)
			{
				DawnPlugin.Logger.LogError((object)$"Error happened while trying to save PersistentDataContainer ({Path.GetFileName(_filePath)}):\n{arg}");
			}
			finally
			{
				_saveLock.Release();
			}
		}

		internal void DeleteFile()
		{
			File.Delete(_filePath);
		}
	}
	public class ChildPersistentDataContainer : DataContainer
	{
		public PersistentDataContainer Parent { get; private set; }

		internal ChildPersistentDataContainer()
		{
		}

		public ChildPersistentDataContainer(PersistentDataContainer parent)
		{
			Parent = parent;
		}

		public override void MarkDirty()
		{
			if (Parent.AutoSave)
			{
				Parent.MarkDirty();
			}
		}

		public override IDisposable CreateEditContext()
		{
			return Parent.CreateEditContext();
		}

		internal void Internal_SetParent(PersistentDataContainer parent)
		{
			Parent = parent;
		}
	}
	public abstract class DawnBaseInfo<T> : INamespaced<T>, INamespaced, ITaggable, IRegistryEvents where T : DawnBaseInfo<T>
	{
		private HashSet<NamespacedKey> _tags;

		private IDataContainer? _customData;

		public IDataContainer CustomData
		{
			get
			{
				if (_customData == null)
				{
					_customData = new DataContainer();
				}
				return _customData;
			}
		}

		public NamespacedKey Key => TypedKey;

		public NamespacedKey<T> TypedKey { get; }

		protected DawnBaseInfo(NamespacedKey<T> key, HashSet<NamespacedKey> tags, IDataContainer? customData)
		{
			TypedKey = key;
			_tags = tags;
			_customData = customData;
		}

		public bool HasTag(NamespacedKey tag)
		{
			return _tags.Contains(tag);
		}

		public IEnumerable<NamespacedKey> AllTags()
		{
			return _tags;
		}

		internal void Internal_AddTag(NamespacedKey tag)
		{
			Debuggers.Tags?.Log($"Internal_AddTag: {tag} !!!");
			_tags.Add(tag);
		}

		public void OnFrozen()
		{
			if (_customData == null)
			{
				_customData = FrozenEmptyDataContainer.Instance;
			}
		}

		internal bool ShouldSkipIgnoreOverride()
		{
			if (!Key.IsVanilla() && !HasTag(DawnLibTags.IsExternal))
			{
				return HasTag(Tags.Unimplemented);
			}
			return true;
		}

		internal bool ShouldSkipRespectOverride()
		{
			if (ShouldSkipIgnoreOverride())
			{
				return !HasTag(DawnLibTags.LunarConfig);
			}
			return false;
		}
	}
	public class DawnInfoContainer<T> : MonoBehaviour where T : DawnBaseInfo<T>
	{
		public T Value { get; internal set; }
	}
	public static class DawnLib
	{
		public const string PLUGIN_GUID = "com.github.teamxiaolan.dawnlib";

		internal static readonly JsonSerializerSettings JSONSettings = new JsonSerializerSettings
		{
			ReferenceLoopHandling = (ReferenceLoopHandling)1,
			PreserveReferencesHandling = (PreserveReferencesHandling)0,
			TypeNameHandling = (TypeNameHandling)3,
			Formatting = (Formatting)1,
			Converters = new List<JsonConverter>(3)
			{
				(JsonConverter)(object)new NamespacedKeyConverter(),
				(JsonConverter)(object)new NamespacedKeyDictionaryConverter(),
				(JsonConverter)(object)new Vector3Converter()
			}
		};

		private static PersistentDataContainer? _profileContainer;

		public static PersistentDataContainer? GetCurrentSave()
		{
			return NetworkSingleton<DawnNetworker>.Instance?.SaveContainer;
		}

		public static PersistentDataContainer? GetCurrentContract()
		{
			return NetworkSingleton<DawnNetworker>.Instance?.ContractContainer;
		}

		public static PersistentDataContainer GetCurrentInstallSave()
		{
			if (_profileContainer == null)
			{
				_profileContainer = new PersistentDataContainer(Path.Combine(Paths.BepInExRootPath, "DawnLib.dawndata"));
			}
			return _profileContainer;
		}

		public static void RegisterNetworkPrefab(GameObject prefab)
		{
			if (!Object.op_Implicit((Object)(object)prefab))
			{
				throw new ArgumentNullException("prefab");
			}
			MiscFixesPatch.networkPrefabsToAdd.Add(prefab);
		}

		public static void RegisterNetworkScene(string scenePath)
		{
			DawnNetworkSceneManager.AddScenePath(scenePath);
		}

		public static void FixMixerGroups(GameObject prefab)
		{
			if (!Object.op_Implicit((Object)(object)prefab))
			{
				throw new ArgumentNullException("prefab");
			}
			MiscFixesPatch.soundPrefabsToFix.Add(prefab);
		}

		public static void FixDoorwaySockets(GameObject prefab)
		{
			if (!Object.op_Implicit((Object)(object)prefab))
			{
				throw new ArgumentNullException("prefab");
			}
			MiscFixesPatch.tilesToFixSockets.Add(prefab);
		}

		public static DawnDungeonInfo DefineDungeon(NamespacedKey<DawnDungeonInfo> key, DungeonFlow dungeonFlow, Action<DungeonFlowInfoBuilder> callback)
		{
			DungeonFlowInfoBuilder dungeonFlowInfoBuilder = new DungeonFlowInfoBuilder(key, dungeonFlow);
			callback(dungeonFlowInfoBuilder);
			DawnDungeonInfo dawnDungeonInfo = dungeonFlowInfoBuilder.Build();
			dungeonFlow.SetDawnInfo(dawnDungeonInfo);
			LethalContent.Dungeons.Register(dawnDungeonInfo);
			return dawnDungeonInfo;
		}

		public static DawnTileSetInfo DefineTileSet(NamespacedKey<DawnTileSetInfo> key, TileSet tileSet, Action<TilesetInfoBuilder> callback)
		{
			TilesetInfoBuilder tilesetInfoBuilder = new TilesetInfoBuilder(key, tileSet);
			callback(tilesetInfoBuilder);
			DawnTileSetInfo dawnTileSetInfo = tilesetInfoBuilder.Build();
			tileSet.SetDawnInfo(dawnTileSetInfo);
			LethalContent.TileSets.Register(dawnTileSetInfo);
			return dawnTileSetInfo;
		}

		public static DawnMapObjectInfo DefineMapObject(NamespacedKey<DawnMapObjectInfo> key, GameObject mapObject, Action<MapObjectInfoBuilder> callback)
		{
			MapObjectInfoBuilder mapObjectInfoBuilder = new MapObjectInfoBuilder(key, mapObject);
			callback(mapObjectInfoBuilder);
			DawnMapObjectInfo dawnMapObjectInfo = mapObjectInfoBuilder.Build();
			DawnMapObjectNamespacedKeyContainer dawnMapObjectNamespacedKeyContainer = mapObject.AddComponent<DawnMapObjectNamespacedKeyContainer>();
			dawnMapObjectNamespacedKeyContainer.Value = dawnMapObjectInfo.TypedKey;
			LethalContent.MapObjects.Register(dawnMapObjectInfo);
			return dawnMapObjectInfo;
		}

		public static DawnUnlockableItemInfo DefineUnlockable(NamespacedKey<DawnUnlockableItemInfo> key, UnlockableItem unlockableItem, Action<UnlockableInfoBuilder> callback)
		{
			UnlockableInfoBuilder unlockableInfoBuilder = new UnlockableInfoBuilder(key, unlockableItem);
			callback(unlockableInfoBuilder);
			DawnUnlockableItemInfo dawnUnlockableItemInfo = unlockableInfoBuilder.Build();
			unlockableItem.SetDawnInfo(dawnUnlockableItemInfo);
			LethalContent.Unlockables.Register(dawnUnlockableItemInfo);
			return dawnUnlockableItemInfo;
		}

		public static DawnItemInfo DefineItem(NamespacedKey<DawnItemInfo> key, Item item, Action<ItemInfoBuilder> callback)
		{
			ItemInfoBuilder itemInfoBuilder = new ItemInfoBuilder(key, item);
			callback(itemInfoBuilder);
			DawnItemInfo dawnItemInfo = itemInfoBuilder.Build();
			item.SetDawnInfo(dawnItemInfo);
			LethalContent.Items.Register(dawnItemInfo);
			return dawnItemInfo;
		}

		public static DawnEnemyInfo DefineEnemy(NamespacedKey<DawnEnemyInfo> key, EnemyType enemy, Action<EnemyInfoBuilder> callback)
		{
			EnemyInfoBuilder enemyInfoBuilder = new EnemyInfoBuilder(key, enemy);
			callback(enemyInfoBuilder);
			DawnEnemyInfo dawnEnemyInfo = enemyInfoBuilder.Build();
			enemy.SetDawnInfo(dawnEnemyInfo);
			LethalContent.Enemies.Register(dawnEnemyInfo);
			return dawnEnemyInfo;
		}

		public static DawnMoonInfo DefineMoon(NamespacedKey<DawnMoonInfo> key, SelectableLevel level, Action<MoonInfoBuilder> callback)
		{
			MoonInfoBuilder moonInfoBuilder = new MoonInfoBuilder(key, level);
			callback(moonInfoBuilder);
			DawnMoonInfo dawnMoonInfo = moonInfoBuilder.Build();
			level.SetDawnInfo(dawnMoonInfo);
			LethalContent.Moons.Register(dawnMoonInfo);
			return dawnMoonInfo;
		}

		public static void ApplyTag(JSONTagDefinition definition)
		{
			JSONTagDefinition definition2 = definition;
			NamespacedKey namespacedKey2 = NamespacedKey.Parse(definition2.Tag);
			ListenToRegistry<DawnMoonInfo>(LethalContent.Moons, namespacedKey2);
			ListenToRegistry<DawnMapObjectInfo>(LethalContent.MapObjects, namespacedKey2);
			ListenToRegistry<DawnEnemyInfo>(LethalContent.Enemies, namespacedKey2);
			ListenToRegistry<DawnItemInfo>(LethalContent.Items, namespacedKey2);
			ListenToRegistry<DawnWeatherEffectInfo>(LethalContent.Weathers, namespacedKey2);
			ListenToRegistry<DawnDungeonInfo>(LethalContent.Dungeons, namespacedKey2);
			ListenToRegistry<DawnUnlockableItemInfo>(LethalContent.Unlockables, namespacedKey2);
			Debuggers.Tags?.Log($"Scheduled applying tag: {namespacedKey2}");
			void ListenToRegistry<T>(TaggedRegistry<T> registry, NamespacedKey namespacedKey) where T : notnull, DawnBaseInfo<T>
			{
				TaggedRegistry<T> registry2 = registry;
				NamespacedKey namespacedKey3 = namespacedKey;
				registry2.OnFreeze += delegate
				{
					string[] values = definition2.Values;
					foreach (string input in values)
					{
						if (registry2.TryGetValue(NamespacedKey.Parse(input), out var value))
						{
							value.Internal_AddTag(namespacedKey3);
						}
					}
				};
			}
		}

		public static void ApplyAllTagsInFolder(string path)
		{
			string[] files = Directory.GetFiles(path, "*.tag.json", SearchOption.AllDirectories);
			foreach (string path2 in files)
			{
				JSONTagDefinition definition = JsonConvert.DeserializeObject<JSONTagDefinition>(File.ReadAllText(path2));
				ApplyTag(definition);
			}
		}
	}
	public class DawnNamespacedKeyContainer<T> : MonoBehaviour where T : NamespacedKey
	{
		public T Value { get; internal set; }
	}
	internal static class DungeonRegistrationHandler
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static hook_Awake <0>__RegisterDawnDungeons;

			public static Action <1>__AddDawnDungeonsToMoons;

			public static Action <2>__CollectNonDawnDungeons;

			public static hook_SetPlanetsWeather <3>__UpdateAllDungeonWeights;
		}

		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static hook_Start <>9__0_0;

			public static hook_Generate <>9__0_1;

			public static Func<IndoorMapType, DungeonFlow> <>9__3_0;

			internal void <Init>b__0_0(orig_Start orig, RuntimeDungeon self)
			{
				self.GenerateOnStart = false;
				orig.Invoke(self);
			}

			internal void <Init>b__0_1(orig_Generate orig, RuntimeDungeon self)
			{
				TryInjectTileSets(self.Generator.DungeonFlow);
				orig.Invoke(self);
			}

			internal DungeonFlow <AddDawnDungeonsToMoons>b__3_0(IndoorMapType t)
			{
				return t.dungeonFlow;
			}
		}

		private static readonly Dictionary<string, string> _internalToHumanDungeonNames = new Dictionary<string, string>
		{
			{ "LevelOne", "Facility" },
			{ "LevelTwo", "Mansion" },
			{ "LevelThree", "Mineshaft" }
		};

		internal static void Init()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Expected O, but got Unknown
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Expected O, but got Unknown
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Expected O, but got Unknown
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Expected O, but got Unknown
			//IL_00d9: 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)
			//IL_00e4: Expected O, but got Unknown
			DetourContext val = new DetourContext(int.MaxValue);
			try
			{
				object obj = <>O.<0>__RegisterDawnDungeons;
				if (obj == null)
				{
					hook_Awake val2 = RegisterDawnDungeons;
					<>O.<0>__RegisterDawnDungeons = val2;
					obj = (object)val2;
				}
				StartOfRound.Awake += (hook_Awake)obj;
			}
			finally
			{
				((IDisposable)val)?.Dispose();
			}
			LethalContent.Moons.OnFreeze += AddDawnDungeonsToMoons;
			LethalContent.Moons.OnFreeze += CollectNonDawnDungeons;
			object obj2 = <>O.<3>__UpdateAllDungeonWeights;
			if (obj2 == null)
			{
				hook_SetPlanetsWeather val3 = UpdateAllDungeonWeights;
				<>O.<3>__UpdateAllDungeonWeights = val3;
				obj2 = (object)val3;
			}
			StartOfRound.SetPlanetsWeather += (hook_SetPlanetsWeather)obj2;
			object obj3 = <>c.<>9__0_0;
			if (obj3 == null)
			{
				hook_Start val4 = delegate(orig_Start orig, RuntimeDungeon self)
				{
					self.GenerateOnStart = false;
					orig.Invoke(self);
				};
				<>c.<>9__0_0 = val4;
				obj3 = (object)val4;
			}
			RuntimeDungeon.Start += (hook_Start)obj3;
			object obj4 = <>c.<>9__0_1;
			if (obj4 == null)
			{
				hook_Generate val5 = delegate(orig_Generate orig, RuntimeDungeon self)
				{
					TryInjectTileSets(self.Generator.DungeonFlow);
					orig.Invoke(self);
				};
				<>c.<>9__0_1 = val5;
				obj4 = (object)val5;
			}
			RuntimeDungeon.Generate += (hook_Generate)obj4;
		}

		private static void UpdateAllDungeonWeights(orig_SetPlanetsWeather orig, StartOfRound self, int connectedPlayersOnServer)
		{
			orig.Invoke(self, connectedPlayersOnServer);
			UpdateDungeonWeightOnLevel(self.currentLevel);
		}

		internal static void UpdateDungeonWeightOnLevel(SelectableLevel level)
		{
			if (!LethalContent.Weathers.IsFrozen || !LethalContent.Dungeons.IsFrozen || (Object)(object)StartOfRound.Instance == (Object)null || (WeatherRegistryCompat.Enabled && !WeatherRegistryCompat.IsWeatherManagerReady()))
			{
				return;
			}
			IntWithRarity[] dungeonFlowTypes = level.dungeonFlowTypes;
			foreach (IntWithRarity val in dungeonFlowTypes)
			{
				DawnDungeonInfo dawnInfo = RoundManagerRefs.Instance.dungeonFlowTypes[val.id].dungeonFlow.GetDawnInfo();
				if (!dawnInfo.ShouldSkipRespectOverride())
				{
					val.rarity = (dawnInfo.Weights?.GetFor(level.GetDawnInfo())).GetValueOrDefault();
				}
			}
		}

		private static void AddDawnDungeonsToMoons()
		{
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Expected O, but got Unknown
			foreach (DawnMoonInfo value in LethalContent.Moons.Values)
			{
				List<IntWithRarity> list = value.Level.dungeonFlowTypes.ToList();
				foreach (DawnDungeonInfo value2 in LethalContent.Dungeons.Values)
				{
					if (!value2.ShouldSkipIgnoreOverride())
					{
						int id = Array.IndexOf(RoundManagerRefs.Instance.dungeonFlowTypes.Select((IndoorMapType t) => t.dungeonFlow).ToArray(), value2.DungeonFlow);
						IntWithRarity item = new IntWithRarity
						{
							id = id,
							rarity = 0
						};
						list.Add(item);
					}
				}
				value.Level.dungeonFlowTypes = list.ToArray();
			}
		}

		private static void RegisterDawnDungeons(orig_Awake orig, StartOfRound self)
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Expected O, but got Unknown
			List<IndoorMapType> list = RoundManagerRefs.Instance.dungeonFlowTypes.ToList();
			foreach (DawnDungeonInfo value in LethalContent.Dungeons.Values)
			{
				if (!value.ShouldSkipIgnoreOverride())
				{
					IndoorMapType item = new IndoorMapType
					{
						dungeonFlow = value.DungeonFlow,
						MapTileSize = value.MapTileSize,
						firstTimeAudio = value.FirstTimeAudio
					};
					list.Add(item);
				}
			}
			RoundManagerRefs.Instance.dungeonFlowTypes = list.ToArray();
			orig.Invoke(self);
		}

		private static void CollectNonDawnDungeons()
		{
			Dictionary<string, WeightTableBuilder<DawnMoonInfo>> dictionary = new Dictionary<string, WeightTableBuilder<DawnMoonInfo>>();
			foreach (DawnMoonInfo value3 in LethalContent.Moons.Values)
			{
				SelectableLevel level = value3.Level;
				IntWithRarity[] dungeonFlowTypes = level.dungeonFlowTypes;
				foreach (IntWithRarity val in dungeonFlowTypes)
				{
					DungeonFlow dungeonFlow = RoundManagerRefs.Instance.dungeonFlowTypes[val.id].dungeonFlow;
					if (!dictionary.TryGetValue(((Object)dungeonFlow).name, out var value))
					{
						value = new WeightTableBuilder<DawnMoonInfo>();
						dictionary[((Object)dungeonFlow).name] = value;
					}
					Debuggers.Dungeons?.Log($"Grabbing weight {val.rarity} to {((Object)dungeonFlow).name} on level {level.PlanetName}");
					value.AddWeight(value3.TypedKey, val.rarity);
				}
			}
			IndoorMapType[] dungeonFlowTypes2 = RoundManagerRefs.Instance.dungeonFlowTypes;
			foreach (IndoorMapType val2 in dungeonFlowTypes2)
			{
				if (val2 == null || (Object)(object)val2.dungeonFlow == (Object)null || val2.dungeonFlow.HasDawnInfo())
				{
					continue;
				}
				string name = FormatFlowName(val2.dungeonFlow);
				NamespacedKey<DawnDungeonInfo> namespacedKey = DungeonKeys.GetByReflection(name);
				if (namespacedKey == null && LethalLevelLoaderCompat.Enabled && LethalLevelLoaderCompat.TryGetExtendedDungeonModName(val2.dungeonFlow, out string modName))
				{
					namespacedKey = NamespacedKey<DawnDungeonInfo>.From(NamespacedKey.NormalizeStringForNamespacedKey(modName, CSharpName: false), NamespacedKey.NormalizeStringForNamespacedKey(((Object)val2.dungeonFlow).name, CSharpName: false));
				}
				else if (namespacedKey == null)
				{
					namespacedKey = NamespacedKey<DawnDungeonInfo>.From("unknown_modded", NamespacedKey.NormalizeStringForNamespacedKey(((Object)val2.dungeonFlow).name, CSharpName: false));
				}
				if (LethalContent.Dungeons.ContainsKey(namespacedKey))
				{
					Debuggers.Dungeons?.Log($"LethalContent.Dungeons already contains {namespacedKey}");
					val2.dungeonFlow.SetDawnInfo(LethalContent.Dungeons[namespacedKey]);
					continue;
				}
				HashSet<NamespacedKey> tags = new HashSet<NamespacedKey> { DawnLibTags.IsExternal };
				CollectLLLTags(val2.dungeonFlow, tags);
				dictionary.TryGetValue(((Object)val2.dungeonFlow).name, out var value2);
				if (value2 == null)
				{
					value2 = new WeightTableBuilder<DawnMoonInfo>();
				}
				DawnDungeonInfo dawnDungeonInfo = new DawnDungeonInfo(namespacedKey, tags, val2.dungeonFlow, value2.Build(), val2.MapTileSize, val2.firstTimeAudio, null);
				val2.dungeonFlow.SetDawnInfo(dawnDungeonInfo);
				LethalContent.Dungeons.Register(dawnDungeonInfo);
			}
			CollectArchetypesAndTileSets();
			LethalContent.Dungeons.Freeze();
		}

		private static void CollectArchetypesAndTileSets()
		{
			foreach (DawnDungeonInfo value in LethalContent.Dungeons.Values)
			{
				DungeonArchetype[] usedArchetypes = value.DungeonFlow.GetUsedArchetypes();
				foreach (DungeonArchetype val in usedArchetypes)
				{
					Debuggers.Dungeons?.Log("dungeonArchetype.name: " + ((Object)val).name);
					NamespacedKey<DawnArchetypeInfo> namespacedKey;
					if (value.Key.IsVanilla())
					{
						string name = FormatArchetypeName(val);
						namespacedKey = DungeonArchetypeKeys.GetByReflection(name);
						if (namespacedKey == null)
						{
							DawnPlugin.Logger.LogWarning((object)$"archetype: '{((Object)val).name}' (part of {value.Key}) is vanilla, but DawnLib couldn't get a corresponding NamespacedKey!");
							continue;
						}
					}
					else
					{
						namespacedKey = NamespacedKey<DawnArchetypeInfo>.From(value.Key.Namespace, NamespacedKey.NormalizeStringForNamespacedKey(((Object)val).name, CSharpName: false));
					}
					if (LethalContent.Archetypes.ContainsKey(namespacedKey))
					{
						Debuggers.Dungeons?.Log($"LethalContent.Archetypes already contains {namespacedKey}");
						val.SetDawnInfo(LethalContent.Archetypes[namespacedKey]);
						continue;
					}
					DawnArchetypeInfo dawnArchetypeInfo = new DawnArchetypeInfo(namespacedKey, new HashSet<NamespacedKey> { DawnLibTags.IsExternal }, val, null);
					val.SetDawnInfo(dawnArchetypeInfo);
					dawnArchetypeInfo.ParentInfo = value;
					LethalContent.Archetypes.Register(dawnArchetypeInfo);
					List<TileSet> tileSets = val.TileSets;
					List<TileSet> branchCapTileSets = val.BranchCapTileSets;
					int num = 0;
					TileSet[] array = (TileSet[])(object)new TileSet[tileSets.Count + branchCapTileSets.Count];
					foreach (TileSet item in tileSets)
					{
						array[num] = item;
						num++;
					}
					foreach (TileSet item2 in branchCapTileSets)
					{
						array[num] = item2;
						num++;
					}
					IEnumerable<TileSet> enumerable = new <>z__ReadOnlyArray<TileSet>(array);
					foreach (TileSet item3 in enumerable)
					{
						Debuggers.Dungeons?.Log("tileSet.name: " + ((Object)item3).name);
						NamespacedKey<DawnTileSetInfo> namespacedKey2;
						if (value.Key.IsVanilla())
						{
							string name2 = FormatTileSetName(item3);
							namespacedKey2 = DungeonTileSetKeys.GetByReflection(name2);
							if (namespacedKey2 == null)
							{
								DawnPlugin.Logger.LogWarning((object)$"tileset: '{((Object)item3).name}' (part of {namespacedKey}) is vanilla, but DawnLib couldn't get a corresponding NamespacedKey!");
								continue;
							}
						}
						else
						{
							namespacedKey2 = NamespacedKey<DawnTileSetInfo>.From(value.Key.Namespace, NamespacedKey.NormalizeStringForNamespacedKey(((Object)val).name, CSharpName: false));
						}
						if (LethalContent.TileSets.ContainsKey(namespacedKey2))
						{
							Debuggers.Dungeons?.Log($"LethalContent.TileSets already contains {namespacedKey2}");
							item3.SetDawnInfo(LethalContent.TileSets[namespacedKey2]);
							continue;
						}
						DawnTileSetInfo dawnTileSetInfo = new DawnTileSetInfo(namespacedKey2, new HashSet<NamespacedKey> { DawnLibTags.IsExternal }, ConstantPredicate.True, item3, val.BranchCapTileSets.Contains(item3), val.TileSets.Contains(item3), null);
						dawnArchetypeInfo.AddTileSet(dawnTileSetInfo);
						item3.SetDawnInfo(dawnTileSetInfo);
						LethalContent.TileSets.Register(dawnTileSetInfo);
					}
				}
			}
			LethalContent.Archetypes.Freeze();
			LethalContent.TileSets.Freeze();
		}

		private static string FormatTileSetName(TileSet tileSet)
		{
			string input = NamespacedKey.NormalizeStringForNamespacedKey(((Object)tileSet).name, CSharpName: true);
			return ReplaceInternalLevelNames(input).Replace("Tiles", string.Empty);
		}

		private static string FormatArchetypeName(DungeonArchetype dungeonArchetype)
		{
			string input = NamespacedKey.NormalizeStringForNamespacedKey(((Object)dungeonArchetype).name, CSharpName: true);
			return ReplaceInternalLevelNames(input).Replace("Archetype", string.Empty);
		}

		private static string FormatFlowName(DungeonFlow dungeonFlow)
		{
			string input = NamespacedKey.NormalizeStringForNamespacedKey(((Object)dungeonFlow).name, CSharpName: true);
			return ReplaceInternalLevelNames(input);
		}

		private static string ReplaceInternalLevelNames(string input)
		{
			foreach (KeyValuePair<string, string> internalToHumanDungeonName in _internalToHumanDungeonNames)
			{
				internalToHumanDungeonName.Deconstruct(out var key, out var value);
				string oldValue = key;
				string newValue = value;
				input = input.Replace(oldValue, newValue);
			}
			return input;
		}

		private static void CollectLLLTags(DungeonFlow dungeonFlow, HashSet<NamespacedKey> tags)
		{
			if (LethalLevelLoaderCompat.Enabled && LethalLevelLoaderCompat.TryGetAllTagsWithModNames(dungeonFlow, out List<(string, string)> allTagsWithModNames))
			{
				tags.AddToList(allTagsWithModNames, Debuggers.Dungeons, ((Object)dungeonFlow).name);
			}
		}

		internal static void TryInjectTileSets(DungeonFlow dungeonFlow)
		{
			DungeonArchetype[] usedArchetypes = dungeonFlow.GetUsedArchetypes();
			foreach (DungeonArchetype val in usedArchetypes)
			{
				foreach (DawnTileSetInfo tileSet in val.GetDawnInfo().TileSets)
				{
					if (tileSet.ShouldSkipIgnoreOverride())
					{
						continue;
					}
					if (val.BranchCapTileSets.Contains(tileSet.TileSet))
					{
						val.BranchCapTileSets.Remove(tileSet.TileSet);
					}
					if (val.TileSets.Contains(tileSet.TileSet))
					{
						val.TileSets.Remove(tileSet.TileSet);
					}
					if (tileSet.InjectionPredicate.Evaluate())
					{
						if (tileSet.IsBranchCap)
						{
							val.BranchCapTileSets.Add(tileSet.TileSet);
						}
						if (tileSet.IsRegular)
						{
							val.TileSets.Add(tileSet.TileSet);
						}
					}
				}
			}
		}
	}
	public class DawnArchetypeInfo : DawnBaseInfo<DawnArchetypeInfo>
	{
		private List<DawnTileSetInfo> _tileSets = new List<DawnTileSetInfo>();

		public DungeonArchetype DungeonArchetype { get; }

		public IReadOnlyList<DawnTileSetInfo> TileSets => _tileSets.AsReadOnly();

		public DawnDungeonInfo ParentInfo { get; internal set; }

		internal DawnArchetypeInfo(NamespacedKey<DawnArchetypeInfo> key, HashSet<NamespacedKey> tags, DungeonArchetype archetype, IDataContainer? customData)
			: base(key, tags, customData)
		{
			DungeonArchetype = archetype;
		}

		public void AddTileSet(DawnTileSetInfo info)
		{
			if (LethalContent.Dungeons.IsFrozen)
			{
				throw new RegistryFrozenException();
			}
			_tileSets.Add(info);
		}
	}
	public class DawnDungeonInfo : DawnBaseInfo<DawnDungeonInfo>
	{
		private List<DoorwaySocket> _sockets;

		public DungeonFlow DungeonFlow { get; }

		public ProviderTable<int?, DawnMoonInfo>? Weights { get; }

		public float MapTileSize { get; }

		public AudioClip? FirstTimeAudio { get; }

		public IReadOnlyList<DoorwaySocket> Sockets => _sockets.AsReadOnly();

		internal DawnDungeonInfo(NamespacedKey<DawnDungeonInfo> key, HashSet<NamespacedKey> tags, DungeonFlow dungeonFlow, ProviderTable<int?, DawnMoonInfo>? weights, float mapTileSize, AudioClip? firstTimeAudio, IDataContainer? customData)
			: base(key, tags, customData)
		{
			DungeonFlow = dungeonFlow;
			Weights = weights;
			MapTileSize = mapTileSize;
			firstTimeAudio = FirstTimeAudio;
			_sockets = new List<DoorwaySocket>();
			foreach (GameObjectChance item in (from it in DungeonFlow.GetUsedTileSets()
				select it.TileWeights.Weights).SelectMany((List<GameObjectChance> it) => it))
			{
				Doorway[] componentsInChildren = item.Value.GetComponentsInChildren<Doorway>();
				Doorway[] array = componentsInChildren;
				foreach (Doorway val in array)
				{
					if (!Sockets.Contains(val.socket))
					{
						_sockets.Add(val.socket);
					}
				}
			}
		}
	}
	public class DawnTileSetInfo : DawnBaseInfo<DawnTileSetInfo>
	{
		public TileSet TileSet { get; }

		public bool IsBranchCap { get; }

		public bool IsRegular { get; }

		public IPredicate InjectionPredicate { get; }

		internal DawnTileSetInfo(NamespacedKey<DawnTileSetInfo> key, HashSet<NamespacedKey> tags, IPredicate injectionRule, TileSet tileSet, bool isBranchCap, bool isRegular, IDataContainer? customData)
			: base(key, tags, customData)
		{
			TileSet = tileSet;
			IsBranchCap = isBranchCap;
			IsRegular = isRegular;
			InjectionPredicate = injectionRule;
		}
	}
	public static class DungeonArchetypeExtensions
	{
		public static DawnArchetypeInfo GetDawnInfo(this DungeonArchetype archetype)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			return (DawnArchetypeInfo)((IDawnObject)archetype).DawnInfo;
		}

		internal static bool HasDawnInfo(this DungeonArchetype archetype)
		{
			return archetype.GetDawnInfo() != null;
		}

		internal static void SetDawnInfo(this DungeonArchetype archetype, DawnArchetypeInfo archetypeInfo)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			((IDawnObject)archetype).DawnInfo = archetypeInfo;
		}
	}
	public static class DungeonFlowExtensions
	{
		public static DawnDungeonInfo GetDawnInfo(this DungeonFlow dungeonFlow)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			return (DawnDungeonInfo)((IDawnObject)dungeonFlow).DawnInfo;
		}

		internal static bool HasDawnInfo(this DungeonFlow dungeonFlow)
		{
			return dungeonFlow.GetDawnInfo() != null;
		}

		internal static void SetDawnInfo(this DungeonFlow dungeonFlow, DawnDungeonInfo dungeonInfo)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			((IDawnObject)dungeonFlow).DawnInfo = dungeonInfo;
		}
	}
	public class DungeonFlowInfoBuilder : BaseInfoBuilder<DawnDungeonInfo, DungeonFlow, DungeonFlowInfoBuilder>
	{
		private float _mapTileSize;

		private AudioClip? _firstTimeAudio;

		private ProviderTable<int?, DawnMoonInfo>? _weights;

		internal DungeonFlowInfoBuilder(NamespacedKey<DawnDungeonInfo> key, DungeonFlow value)
			: base(key, value)
		{
		}

		public DungeonFlowInfoBuilder SetMapTileSize(float mapTileSize)
		{
			_mapTileSize = mapTileSize;
			return this;
		}

		public DungeonFlowInfoBuilder SetFirstTimeAudio(AudioClip firstTimeAudio)
		{
			_firstTimeAudio = firstTimeAudio;
			return this;
		}

		public DungeonFlowInfoBuilder SetWeights(Action<WeightTableBuilder<DawnMoonInfo>> callback)
		{
			WeightTableBuilder<DawnMoonInfo> weightTableBuilder = new WeightTableBuilder<DawnMoonInfo>();
			callback(weightTableBuilder);
			_weights = weightTableBuilder.Build();
			return this;
		}

		internal override DawnDungeonInfo Build()
		{
			return new DawnDungeonInfo(base.key, new HashSet<NamespacedKey>(), base.value, _weights, _mapTileSize, _firstTimeAudio, customData);
		}
	}
	public static class TileSetExtensions
	{
		public static DawnTileSetInfo GetDawnInfo(this TileSet tileSet)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			return (DawnTileSetInfo)((IDawnObject)tileSet).DawnInfo;
		}

		internal static bool HasDawnInfo(this TileSet tileSet)
		{
			return tileSet.GetDawnInfo() != null;
		}

		internal static void SetDawnInfo(this TileSet tileSet, DawnTileSetInfo tileSetInfo)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			((IDawnObject)tileSet).DawnInfo = tileSetInfo;
		}
	}
	public class TilesetInfoBuilder : BaseInfoBuilder<DawnTileSetInfo, TileSet, TilesetInfoBuilder>
	{
		private bool _branchCap;

		private bool _regular = true;

		private IPredicate? _predicate;

		internal TilesetInfoBuilder(NamespacedKey<DawnTileSetInfo> key, TileSet value)
			: base(key, value)
		{
		}

		public TilesetInfoBuilder SetIsBranchCap(bool value)
		{
			_branchCap = value;
			return this;
		}

		public TilesetInfoBuilder SetIsRegular(bool value)
		{
			_regular = value;
			return this;
		}

		public TilesetInfoBuilder SetInjectionPredicate(IPredicate predicate)
		{
			_predicate = predicate;
			return this;
		}

		internal override DawnTileSetInfo Build()
		{
			if (_predicate == null)
			{
				_predicate = ConstantPredicate.True;
			}
			return new DawnTileSetInfo(base.key, new HashSet<NamespacedKey>(), _predicate, base.value, _branchCap, _regular, customData);
		}
	}
	internal static class EnemyRegistrationHandler
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static hook_RefreshEnemiesList <0>__UpdateEnemyWeights;

			public static hook_SetPlanetsWeather <1>__UpdateEnemyWeights;

			public static hook_Start <2>__EnsureCorrectEnemyVariables;

			public static hook_Start <3>__AddEnemiesToDebugList;

			public static hook_Awake <4>__AddBestiaryNodes;

			public static hook_Start <5>__CollectAllEnemyTypes;

			public static Action <6>__RegisterEnemies;

			public static Action <7>__RedoEnemiesDebugMenu;
		}

		private static List<EnemyType> _networkPrefabEnemyTypes = new List<EnemyType>();

		internal static void Init()
		{
			//IL_00d0: 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_00db: Expected O, but got Unknown
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Expected O, but got Unknown
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Expected O, but got Unknown
			//IL_0145: Unknown result type (might be due to invalid IL or missing references)
			//IL_014b: Expected O, but got Unknown
			//IL_0130: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: Expected O, but got Unknown
			//IL_015b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0160: Unknown result type (might be due to invalid IL or missing references)
			//IL_0166: Expected O, but got Unknown
			//IL_017b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0180: Unknown result type (might be due to invalid IL or missing references)
			//IL_0186: Expected O, but got Unknown
			LethalContent.Enemies.AddAutoTaggers(new SimpleAutoTagger<DawnEnemyInfo>(Tags.Killable, (DawnEnemyInfo info) => info.EnemyType.canDie), new SimpleAutoTagger<DawnEnemyInfo>(Tags.Small, (DawnEnemyInfo info) => (int)info.EnemyType.EnemySize == 0), new SimpleAutoTagger<DawnEnemyInfo>(Tags.Medium, (DawnEnemyInfo info) => (int)info.EnemyType.EnemySize == 2), new SimpleAutoTagger<DawnEnemyInfo>(Tags.Large, (DawnEnemyInfo info) => (int)info.EnemyType.EnemySize == 1));
			object obj = <>O.<0>__UpdateEnemyWeights;
			if (obj == null)
			{
				hook_RefreshEnemiesList val = UpdateEnemyWeights;
				<>O.<0>__UpdateEnemyWeights = val;
				obj = (object)val;
			}
			RoundManager.RefreshEnemiesList += (hook_RefreshEnemiesList)obj;
			object obj2 = <>O.<1>__UpdateEnemyWeights;
			if (obj2 == null)
			{
				hook_SetPlanetsWeather val2 = UpdateEnemyWeights;
				<>O.<1>__UpdateEnemyWeights = val2;
				obj2 = (object)val2;
			}
			StartOfRound.SetPlanetsWeather += (hook_SetPlanetsWeather)obj2;
			object obj3 = <>O.<2>__EnsureCorrectEnemyVariables;
			if (obj3 == null)
			{
				hook_Start val3 = EnsureCorrectEnemyVariables;
				<>O.<2>__EnsureCorrectEnemyVariables = val3;
				obj3 = (object)val3;
			}
			EnemyAI.Start += (hook_Start)obj3;
			object obj4 = <>O.<3>__AddEnemiesToDebugList;
			if (obj4 == null)
			{
				hook_Start val4 = AddEnemiesToDebugList;
				<>O.<3>__AddEnemiesToDebugList = val4;
				obj4 = (object)val4;
			}
			QuickMenuManager.Start += (hook_Start)obj4;
			DetourContext val5 = new DetourContext(int.MaxValue);
			try
			{
				object obj5 = <>O.<4>__AddBestiaryNodes;
				if (obj5 == null)
				{
					hook_Awake val6 = AddBestiaryNodes;
					<>O.<4>__AddBestiaryNodes = val6;
					obj5 = (object)val6;
				}
				Terminal.Awake += (hook_Awake)obj5;
				object obj6 = <>O.<5>__CollectAllEnemyTypes;
				if (obj6 == null)
				{
					hook_Start val7 = CollectAllEnemyTypes;
					<>O.<5>__CollectAllEnemyTypes = val7;
					obj6 = (object)val7;
				}
				GameNetworkManager.Start += (hook_Start)obj6;
			}
			finally
			{
				((IDisposable)val5)?.Dispose();
			}
			LethalContent.Moons.OnFreeze += RegisterEnemies;
			LethalContent.Enemies.OnFreeze += RedoEnemiesDebugMenu;
		}

		private static void RedoEnemiesDebugMenu()
		{
			QuickMenuManagerRefs.Instance.Debug_SetEnemyDropdownOptions();
		}

		private static void CollectAllEnemyTypes(orig_Start orig, GameNetworkManager self)
		{
			orig.Invoke(self);
			EnemyAI val = default(EnemyAI);
			foreach (NetworkPrefab prefab in NetworkManager.Singleton.NetworkConfig.Prefabs.Prefabs)
			{
				if (prefab.Prefab.TryGetComponent<EnemyAI>(ref val) && !((Object)(object)val.enemyType == (Object)null) && !_networkPrefabEnemyTypes.Contains(val.enemyType))
				{
					_networkPrefabEnemyTypes.Add(val.enemyType);
				}
			}
		}

		private static void AddBestiaryNodes(orig_Awake orig, Terminal self)
		{
			foreach (DawnEnemyInfo value in LethalContent.Enemies.Values)
			{
				if (!value.ShouldSkipIgnoreOverride() && Object.op_Implicit((Object)(object)value.BestiaryNode) && Object.op_Implicit((Object)(object)value.NameKeyword))
				{
					AddScanNodeToBestiaryEvent(value.EnemyType.enemyPrefab, value.BestiaryNode, value.NameKeyword);
				}
			}
			orig.Invoke(self);
		}

		private static void AddScanNodeToBestiaryEvent(GameObject gameObjectWithScanNodes, TerminalNode bestiaryNode, TerminalKeyword nameKeyword)
		{
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Expected O, but got Unknown
			List<TerminalKeyword> list = TerminalRefs.Instance.terminalNodes.allKeywords.ToList();
			List<CompatibleNoun> list2 = TerminalRefs.InfoKeyword.compatibleNouns.ToList();
			bestiaryNode.creatureFileID = TerminalRefs.Instance.enemyFiles.Count;
			TerminalRefs.Instance.enemyFiles.Add(bestiaryNode);
			ScanNodeProperties[] componentsInChildren = gameObjectWithScanNodes.GetComponentsInChildren<ScanNodeProperties>();
			ScanNodeProperties[] array = componentsInChildren;
			foreach (ScanNodeProperties val in array)
			{
				val.creatureScanID = bestiaryNode.creatureFileID;
			}
			if (!list.Contains(nameKeyword))
			{
				nameKeyword.defaultVerb = TerminalRefs.InfoKeyword;
				list.Add(nameKeyword);
				list2.Add(new CompatibleNoun
				{
					noun = nameKeyword,
					result = bestiaryNode
				});
				TerminalRefs.InfoKeyword.compatibleNouns = list2.ToArray();
				TerminalRefs.Instance.terminalNodes.allKeywords = list.ToArray();
			}
		}

		private static void AddEnemiesToDebugList(orig_Start orig, QuickMenuManager self)
		{
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Expected O, but got Unknown
			SelectableLevel level = LethalContent.Moons[MoonKeys.Test].Level;
			foreach (DawnEnemyInfo enemyInfo in LethalContent.Enemies.Values)
			{
				if (!enemyInfo.ShouldSkipIgnoreOverride())
				{
					SpawnableEnemyWithRarity item = new SpawnableEnemyWithRarity
					{
						enemyType = enemyInfo.EnemyType,
						rarity = 0
					};
					if (enemyInfo.Inside != null && level.Enemies.All((SpawnableEnemyWithRarity enemy) => (Object)(object)enemy.enemyType != (Object)(object)enemyInfo.EnemyType))
					{
						Debuggers.Enemies?.Log($"Adding {enemyInfo.EnemyType} to test level {((Object)level).name} inside.");
						level.Enemies.Add(item);
					}
					if (enemyInfo.Outside != null && level.OutsideEnemies.All((SpawnableEnemyWithRarity enemy) => (Object)(object)enemy.enemyType != (Object)(object)enemyInfo.EnemyType))
					{
						Debuggers.Enemies?.Log($"Adding {enemyInfo.EnemyType} to test level {((Object)level).name} outside.");
						level.OutsideEnemies.Add(item);
					}
					if (enemyInfo.Daytime != null && level.DaytimeEnemies.All((SpawnableEnemyWithRarity enemy) => (Object)(object)enemy.enemyType != (Object)(object)enemyInfo.EnemyType))
					{
						Debuggers.Enemies?.Log($"Adding {enemyInfo.EnemyType} to test level {((Object)level).name} daytime.");
						level.DaytimeEnemies.Add(item);
					}
				}
			}
			orig.Invoke(self);
		}

		private static void EnsureCorrectEnemyVariables(orig_Start orig, EnemyAI self)
		{
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			if (!self.enemyType.HasDawnInfo())
			{
				DawnPlugin.Logger.LogError((object)("Enemy with names " + ((Object)self.enemyType).name + " and " + self.enemyType.enemyName + " has no DawnEnemyInfo, this means this enemy is not properly registered."));
				orig.Invoke(self);
				return;
			}
			DawnEnemyInfo dawnInfo = self.enemyType.GetDawnInfo();
			if (dawnInfo.ShouldSkipRespectOverride() || StarlancerAIFixCompat.Enabled)
			{
				orig.Invoke(self);
				return;
			}
			if (dawnInfo.Daytime != null)
			{
				self.enemyType.isDaytimeEnemy = true;
			}
			GameObject[] insideAINodes = RoundManager.Instance.insideAINodes;
			GameObject[] outsideAINodes = RoundManager.Instance.outsideAINodes;
			bool flag = true;
			float num = float.MaxValue;
			if (insideAINodes != null)
			{
				GameObject[] array = insideAINodes;
				foreach (GameObject val in array)
				{
					float num2 = Vector3.Distance(val.transform.position, ((Component)self).transform.position);
					if (!(num2 >= num))
					{
						num = num2;
					}
				}
			}
			if (outsideAINodes != null)
			{
				GameObject[] array2 = outsideAINodes;
				foreach (GameObject val2 in array2)
				{
					float num3 = Vector3.Distance(val2.transform.position, ((Component)self).transform.position);
					if (num3 < num)
					{
						num = num3;
						flag = false;
						break;
					}
				}
			}
			bool isOutsideEnemy = self.enemyType.isOutsideEnemy;
			if (flag)
			{
				self.enemyType.isOutsideEnemy = false;
			}
			else
			{
				self.enemyType.isOutsideEnemy = true;
			}
			orig.Invoke(self);
			if (isOutsideEnemy != self.enemyType.isOutsideEnemy)
			{
				self.enemyType.isOutsideEnemy = isOutsideEnemy;
			}
		}

		private static void UpdateEnemyWeights(orig_RefreshEnemiesList orig, RoundManager self)
		{
			UpdateEnemyWeightsOnLevel(self.currentLevel);
			orig.Invoke(self);
		}

		private static void UpdateEnemyWeights(orig_SetPlanetsWeather orig, StartOfRound self, int connectedPlayersOnServer)
		{
			orig.Invoke(self, connectedPlayersOnServer);
			UpdateEnemyWeightsOnLevel(self.currentLevel);
		}

		internal static void UpdateEnemyWeightsOnLevel(SelectableLevel level)
		{
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Expected O, but got Unknown
			//IL_013b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0140: Unknown result type (might be due to invalid IL or missing references)
			//IL_0151: Unknown result type (might be due to invalid IL or missing references)
			//IL_015a: Expected O, but got Unknown
			//IL_01bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01de: Expected O, but got Unknown
			if (!LethalContent.Weathers.IsFrozen || !LethalContent.Enemies.IsFrozen || (Object)(object)StartOfRound.Instance == (Object)null || (WeatherRegistryCompat.Enabled && !WeatherRegistryCompat.IsWeatherManagerReady()))
			{
				return;
			}
			foreach (DawnEnemyInfo enemyInfo in LethalContent.Enemies.Values)
			{
				if (enemyInfo.ShouldSkipRespectOverride())
				{
					continue;
				}
				Debuggers.Enemies?.Log($"Updating weights for {enemyInfo.EnemyType} on level {level.PlanetName}");
				if (enemyInfo.Outside != null)
				{
					SpawnableEnemyWithRarity val = ((IEnumerable<SpawnableEnemyWithRarity>)level.OutsideEnemies).FirstOrDefault((Func<SpawnableEnemyWithRarity, bool>)((SpawnableEnemyWithRarity x) => (Object)(object)x.enemyType == (Object)(object)enemyInfo.EnemyType));
					if (val == null)
					{
						val = new SpawnableEnemyWithRarity
						{
							enemyType = enemyInfo.EnemyType,
							rarity = 0
						};
						level.OutsideEnemies.Add(val);
					}
					val.rarity = enemyInfo.Outside.Weights.GetFor(level.GetDawnInfo()).GetValueOrDefault();
				}
				if (enemyInfo.Inside != null)
				{
					SpawnableEnemyWithRarity val2 = ((IEnumerable<SpawnableEnemyWithRarity>)level.Enemies).FirstOrDefault((Func<SpawnableEnemyWithRarity, bool>)((SpawnableEnemyWithRarity x) => (Object)(object)x.enemyType == (Object)(object)enemyInfo.EnemyType));
					if (val2 == null)
					{
						val2 = new SpawnableEnemyWithRarity
						{
							enemyType = enemyInfo.EnemyType,
							rarity = 0
						};
						level.Enemies.Add(val2);
					}
					int valueOrDefault = enemyInfo.Inside.Weights.GetFor(level.GetDawnInfo()).GetValueOrDefault();
					val2.rarity = valueOrDefault;
				}
				if (enemyInfo.Daytime != null)
				{
					SpawnableEnemyWithRarity val3 = ((IEnumerable<SpawnableEnemyWithRarity>)level.DaytimeEnemies).FirstOrDefault((Func<SpawnableEnemyWithRarity, bool>)((SpawnableEnemyWithRarity x) => (Object)(object)x.enemyType == (Object)(object)enemyInfo.EnemyType));
					if (val3 == null)
					{
						val3 = new SpawnableEnemyWithRarity
						{
							enemyType = enemyInfo.EnemyType,
							rarity = 0
						};
						level.DaytimeEnemies.Add(val3);
					}
					val3.rarity = enemyInfo.Daytime.Weights.GetFor(level.GetDawnInfo()).GetValueOrDefault();
				}
			}
		}

		private static void RegisterEnemies()
		{
			Dictionary<string, WeightTableBuilder<DawnMoonInfo>> dictionary = new Dictionary<string, WeightTableBuilder<DawnMoonInfo>>();
			Dictionary<string, WeightTableBuilder<DawnMoonInfo>> dictionary2 = new Dictionary<string, WeightTableBuilder<DawnMoonInfo>>();
			Dictionary<string, WeightTableBuilder<DawnMoonInfo>> dictionary3 = new Dictionary<string, WeightTableBuilder<DawnMoonInfo>>();
			foreach (DawnMoonInfo value4 in LethalContent.Moons.Values)
			{
				SelectableLevel level = value4.Level;
				NamespacedKey<DawnMoonInfo> typedKey = value4.TypedKey;
				foreach (SpawnableEnemyWithRarity enemy in level.Enemies)
				{
					if (!((Object)(object)enemy.enemyType == (Object)null))
					{
						if (!dictionary.TryGetValue(((Object)enemy.enemyType).name, out var value))
						{
							value = new WeightTableBuilder<DawnMoonInfo>();
							dictionary[((Object)enemy.enemyType).name] = value;
						}
						Debuggers.Enemies?.Log($"Adding inside weight {enemy.rarity} for {enemy.enemyType} on level {level.PlanetName}");
						value.AddWeight(typedKey, enemy.rarity);
					}
				}
				foreach (SpawnableEnemyWithRarity outsideEnemy in level.OutsideEnemies)
				{
					if (!((Object)(object)outsideEnemy.enemyType == (Object)null))
					{
						if (!dictionary2.TryGetValue(((Object)outsideEnemy.enemyType).name, out var value2))
						{
							value2 = new WeightTableBuilder<DawnMoonInfo>();
							dictionary2[((Object)outsideEnemy.enemyType).name] = value2;
						}
						Debuggers.Enemies?.Log($"Adding outside weight {outsideEnemy.rarity} for {outsideEnemy.enemyType} on level {level.PlanetName}");
						value2.AddWeight(typedKey, outsideEnemy.rarity);
					}
				}
				foreach (SpawnableEnemyWithRarity daytimeEnemy in level.DaytimeEnemies)
				{
					if (!((Object)(object)daytimeEnemy.enemyType == (Object)null))
					{
						if (!dictionary3.TryGetValue(((Object)daytimeEnemy.enemyType).name, out var value3))
						{
							value3 = new WeightTableBuilder<DawnMoonInfo>();
							dictionary3[((Object)daytimeEnemy.enemyType).name] = value3;
						}
						Debuggers.Enemies?.Log($"Adding daytime weight {daytimeEnemy.rarity} for {daytimeEnemy.enemyType} on level {level.PlanetName}");
						value3.AddWeight(typedKey, daytimeEnemy.rarity);
					}
				}
			}
			TerminalKeyword infoKeyword = TerminalRefs.InfoKeyword;
			foreach (EnemyType networkPrefabEnemyType in _networkPrefabEnemyTypes)
			{
				if ((Object)(object)networkPrefabEnemyType == (Object)null || (Object)(object)networkPrefabEnemyType.enemyPrefab == (Object)null || networkPrefabEnemyType.HasDawnInfo())
				{
					continue;
				}
				string name = NamespacedKey.NormalizeStringForNamespacedKey(networkPrefabEnemyType.enemyName, CSharpName: true);
				NamespacedKey<DawnEnemyInfo> namespacedKey = EnemyKeys.GetByReflection(name);
				string modName2;
				if (namespacedKey == null && LethalLibCompat.Enabled && LethalLibCompat.TryGetEnemyTypeFromLethalLib(networkPrefabEnemyType, out string modName))
				{
					namespacedKey = NamespacedKey<DawnEnemyInfo>.From(NamespacedKey.NormalizeStringForNamespacedKey(modName, CSharpName: false), NamespacedKey.NormalizeStringForNamespacedKey(networkPrefabEnemyType.enemyName, CSharpName: false));
				}
				else if (namespacedKey == null && LethalLevelLoaderCompat.Enabled && LethalLevelLoaderCompat.TryGetExtendedEnemyTypeModName(networkPrefabEnemyType, out modName2))
				{
					namespacedKey = NamespacedKey<DawnEnemyInfo>.From(NamespacedKey.NormalizeStringForNamespacedKey(modName2, CSharpName: false), NamespacedKey.NormalizeStringForNamespacedKey(networkPrefabEnemyType.enemyName, CSharpName: false));
				}
				else if (namespacedKey == null)
				{
					namespacedKey = NamespacedKey<DawnEnemyInfo>.From("unknown_lib", NamespacedKey.NormalizeStringForNamespacedKey(networkPrefabEnemyType.enemyName, CSharpName: false));
				}
				if (LethalContent.Enemies.ContainsKey(namespacedKey))
				{
					DawnPlugin.Logger.LogWarning((object)("Enemy " + networkPrefabEnemyType.enemyName + " is already registered by the same creator to LethalContent. This is likely to cause issues."));
					networkPrefabEnemyType.SetDawnInfo(LethalContent.Enemies[namespacedKey]);
					continue;
				}
				if (!Object.op_Implicit((Object)(object)networkPrefabEnemyType.enemyPrefab))
				{
					DawnPlugin.Logger.LogWarning((object)(networkPrefabEnemyType.enemyName + " (" + ((Object)networkPrefabEnemyType).name + ") didn't have a spawn prefab?"));
					continue;
				}
				DawnEnemyLocationInfo inside = null;
				DawnEnemyLocationInfo outside = null;
				DawnEnemyLocationInfo daytime = null;
				if (dictionary.ContainsKey(((Object)networkPrefabEnemyType).name))
				{
					inside = new DawnEnemyLocationInfo(dictionary[((Object)networkPrefabEnemyType).name].Build());
				}
				if (dictionary2.ContainsKey(((Object)networkPrefabEnemyType).name))
				{
					outside = new DawnEnemyLocationInfo(dictionary2[((Object)networkPrefabEnemyType).name].Build());
				}
				if (dictionary3.ContainsKey(((Object)networkPrefabEnemyType).name))
				{
					daytime = new DawnEnemyLocationInfo(dictionary3[((Object)networkPrefabEnemyType).name].Build());
				}
				HashSet<NamespacedKey> tags = new HashSet<NamespacedKey> { DawnLibTags.IsExternal };
				CollectLLLTags(networkPrefabEnemyType, tags);
				TerminalNode bestiaryNode = null;
				TerminalKeyword nameKeyword = null;
				ScanNodeProperties componentInChildren = networkPrefabEnemyType.enemyPrefab.GetComponentInChildren<ScanNodeProperties>();
				if ((Object)(object)componentInChildren != (Object)null)
				{
					int creatureScanID = componentInChildren.creatureScanID;
					CompatibleNoun[] compatibleNouns = infoKeyword.compatibleNouns;
					foreach (CompatibleNoun val in compatibleNouns)
					{
						if (val.result.creatureFileID == creatureScanID)
						{
							bestiaryNode = val.result;
							nameKeyword = val.noun;
						}
					}
				}
				DawnEnemyInfo dawnEnemyInfo = new DawnEnemyInfo(namespacedKey, tags, networkPrefabEnemyType, outside, inside, daytime, bestiaryNode, nameKeyword, null);
				networkPrefabEnemyType.SetDawnInfo(dawnEnemyInfo);
				LethalContent.Enemies.Register(dawnEnemyInfo);
			}
			foreach (DawnMoonInfo value5 in LethalContent.Moons.Values)
			{
				SelectableLevel level2 = value5.Level;
				foreach (DawnEnemyInfo value6 in LethalContent.Enemies.Values)
				{
					if (!value6.ShouldSkipRespectOverride())
					{
						if (value6.Outside != null)
						{
							TryAddToEnemyList(value6, level2.OutsideEnemies);
						}
						if (value6.Daytime != null)
						{
							TryAddToEnemyList(value6, level2.DaytimeEnemies);
						}
						if (value6.Inside != null)
						{
							TryAddToEnemyList(value6, level2.Enemies);
						}
					}
				}
			}
			LethalContent.Enemies.Freeze();
		}

		private static void CollectLLLTags(EnemyType enemyType, HashSet<NamespacedKey> tags)
		{
			if (LethalLevelLoaderCompat.Enabled && LethalLevelLoaderCompat.TryGetAllTagsWithModNames(enemyType, out List<(string, string)> allTagsWithModNames))
			{
				tags.AddToList(allTagsWithModNames, Debuggers.Enemies, ((Object)enemyType).name);
			}
		}

		private static void TryAddToEnemyList(DawnEnemyInfo enemyInfo, List<SpawnableEnemyWithRarity> list)
		{
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Expected O, but got Unknown
			foreach (SpawnableEnemyWithRarity item2 in list)
			{
				if ((Object)(object)item2.enemyType == (Object)(object)enemyInfo.EnemyType)
				{
					return;
				}
			}
			SpawnableEnemyWithRarity item = new SpawnableEnemyWithRarity
			{
				enemyType = enemyInfo.EnemyType,
				rarity = 0
			};
			list.Add(item);
		}
	}
	public sealed class DawnEnemyInfo : DawnBaseInfo<DawnEnemyInfo>
	{
		[CompilerGenerated]
		private sealed class <GetAllSpawned>d__19<T> : IEnumerable<T>, IEnumerable, IEnumerator<T>, IEnumerator, IDisposable where T : EnemyAI
		{
			private int <>1__state;

			private T <>2__current;

			private int <>l__initialThreadId;

			public DawnEnemyInfo <>4__this;

			private List<EnemyAI>.Enumerator <>7__wrap1;

			T? IEnumerator<T>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object? IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <GetAllSpawned>d__19(int <>1__state)
			{
				this.<>1__state = <>1__state;
				<>l__initialThreadId = Environment.CurrentManagedThreadId;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 1)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<>7__wrap1 = default(List<EnemyAI>.Enumerator);
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				try
				{
					int num = <>1__state;
					DawnEnemyInfo dawnEnemyInfo = <>4__this;
					switch (num)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<>7__wrap1 = RoundManager.Instance.SpawnedEnemies.GetEnumerator();
						<>1__state = -3;
						break;
					case 1:
						<>1__state = -3;
						break;
					}
					while (<>7__wrap1.MoveNext())
					{
						EnemyAI current = <>7__wrap1.Current;
						if ((Object)(object)current.enemyType == (Object)(object)dawnEnemyInfo.EnemyType)
						{
							<>2__current = (T)(object)current;
							<>1__state = 1;
							return true;
						}
					}
					<>m__Finally1();
					<>7__wrap1 = default(List<EnemyAI>.Enumerator);
					return false;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			private void <>m__Finally1()
			{
				<>1__state = -1;
				((IDisposable)<>7__wrap1).Dispose();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}

			[DebuggerHidden]
			IEnumerator<T> IEnumerable<T>.GetEnumerator()
			{
				<GetAllSpawned>d__19<T> result;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					result = this;
				}
				else
				{
					result = new <GetAllSpawned>d__19<T>(0)
					{
						<>4__this = <>4__this
					};
				}
				return result;
			}

			[DebuggerHidden]
			IEnumerator IEnumerable.GetEnumerator()
			{
				return ((IEnumerable<T>)this).GetEnumerator();
			}
		}

		public EnemyType EnemyType { get; }

		public DawnEnemyLocationInfo? Outside { get; }

		public DawnEnemyLocationInfo? Inside { get; }

		public DawnEnemyLocationInfo? Daytime { get; }

		public TerminalNode? BestiaryNode { get; }

		public TerminalKeyword? NameKeyword { get; }

		internal DawnEnemyInfo(NamespacedKey<DawnEnemyInfo> key, HashSet<NamespacedKey> tags, EnemyType enemyType, DawnEnemyLocationInfo? outside, DawnEnemyLocationInfo? inside, DawnEnemyLocationInfo? daytime, TerminalNode? bestiaryNode, TerminalKeyword? nameKeyword, IDataContainer? customData)
			: base(key, tags, customData)
		{
			EnemyType = enemyType;
			Outside = outside;
			if (Outside != null)
			{
				Outside.ParentInfo = this;
			}
			Inside = inside;
			if (Inside != null)
			{
				Inside.ParentInfo = this;
			}
			Daytime = daytime;
			if (Daytime != null)
			{
				Daytime.ParentInfo = this;
			}
			BestiaryNode = bestiaryNode;
			NameKeyword = nameKeyword;
		}

		[IteratorStateMachine(typeof(<GetAllSpawned>d__19<>))]
		public IEnumerable<T> GetAllSpawned<T>() where T : EnemyAI
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <GetAllSpawned>d__19<T>(-2)
			{
				<>4__this = this
			};
		}
	}
	public sealed class DawnEnemyLocationInfo
	{
		public DawnEnemyInfo ParentInfo { get; internal set; }

		public ProviderTable<int?, DawnMoonInfo> Weights { get; private set; }

		internal DawnEnemyLocationInfo(ProviderTable<int?, DawnMoonInfo> weights)
		{
			Weights = weights;
		}
	}
	public class EnemyInfoBuilder : BaseInfoBuilder<DawnEnemyInfo, EnemyType, EnemyInfoBuilder>
	{
		public class EnemyLocationBuilder
		{
			private ProviderTable<int?, DawnMoonInfo>? _weights;

			private EnemyInfoBuilder _parent;

			public EnemyLocationBuilder SetWeights(Action<WeightTableBuilder<DawnMoonInfo>> callback)
			{
				WeightTableBuilder<DawnMoonInfo> weightTableBuilder = new WeightTableBuilder<DawnMoonInfo>();
				callback(weightTableBuilder);
				_weights = weightTableBuilder.Build();
				return this;
			}

			internal EnemyLocationBuilder(EnemyInfoBuilder parent)
			{
				_parent = parent;
			}

			internal DawnEnemyLocationInfo Build()
			{
				if (_weights == null)
				{
					DawnPlugin.Logger.LogWarning((object)$"Enemy '{_parent.key}' didn't set weights. If you intend to have no weights (doing something special), call .SetWeights(() => {{}})");
					_weights = ProviderTable<int?, DawnMoonInfo>.Empty();
				}
				return new DawnEnemyLocationInfo(_weights);
			}
		}

		private DawnEnemyLocationInfo? _inside;

		private DawnEnemyLocationInfo? _outside;

		private DawnEnemyLocationInfo? _daytime;

		private TerminalNode? _bestiaryNode;

		private TerminalKeyword? _nameKeyword;

		internal EnemyInfoBuilder(NamespacedKey<DawnEnemyInfo> key, EnemyType enemyType)
			: base(key, enemyType)
		{
		}

		public EnemyInfoBuilder DefineOutside(Action<EnemyLocationBuilder> callback)
		{
			EnemyLocationBuilder enemyLocationBuilder = new EnemyLocationBuilder(this);
			callback(enemyLocationBuilder);
			_outside = enemyLocationBuilder.Build();
			return this;
		}

		public EnemyInfoBuilder DefineInside(Action<EnemyLocationBuilder> callback)
		{
			EnemyLocationBuilder enemyLocationBuilder = new EnemyLocationBuilder(this);
			callback(enemyLocationBuilder);
			_inside = enemyLocationBuilder.Build();
			return this;
		}

		public EnemyInfoBuilder DefineDaytime(Action<EnemyLocationBuilder> callback)
		{
			EnemyLocationBuilder enemyLocationBuilder = new EnemyLocationBuilder(this);
			callback(enemyLocationBuilder);
			_daytime = enemyLocationBuilder.Build();
			return this;
		}

		public EnemyInfoBuilder CreateBestiaryNode(string bestiaryNodeText)
		{
			_bestiaryNode = new TerminalNodeBuilder(base.value.enemyName + "BestiaryNode").SetDisplayText(bestiaryNodeText).SetCreatureName(base.value.enemyName).SetClearPreviousText(clearPreviousText: true)
				.SetMaxCharactersToType(35)
				.Build();
			return this;
		}

		public EnemyInfoBuilder CreateNameKeyword(string wordOverride)
		{
			if (string.IsNullOrEmpty(wordOverride))
			{
				wordOverride = base.value.enemyName.ToLowerInvariant().Replace(' ', '-');
			}
			_nameKeyword = new TerminalKeywordBuilder(base.value.enemyName + "NameKeyword").SetWord(wordOverride).Build();
			return this;
		}

		internal override DawnEnemyInfo Build()
		{
			return new DawnEnemyInfo(base.key, tags, base.value, _outside, _inside, _daytime, _bestiaryNode, _nameKeyword, customData);
		}
	}
	public static class EnemyTypeExtensions
	{
		public static DawnEnemyInfo GetDawnInfo(this EnemyType enemyType)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return (DawnEnemyInfo)((IDawnObject)enemyType).DawnInfo;
		}

		internal static bool HasDawnInfo(this EnemyType enemyType)
		{
			return enemyType.GetDawnInfo() != null;
		}

		internal static void SetDawnInfo(this EnemyType enemyType, DawnEnemyInfo enemyInfo)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			((IDawnObject)enemyType).DawnInfo = enemyInfo;
		}
	}
	public class BundleException : Exception
	{
		public AssetBundle Bundle { get; }

		public BundleException(AssetBundle bundle, string message)
		{
			Bundle = bundle;
			base..ctor(message);
		}
	}
	public class MalformedAnimationCurveConfigException : Exception
	{
		public string Pair { get; }

		public MalformedAnimationCurveConfigException(string pair)
		{
			Pair = pair;
			base..ctor();
		}

		public void LogNicely(ManualLogSource? logger)
		{
			if (logger != null)
			{
				string[] array = (from s in Pair.Split(',')
					select s.Trim()).ToArray();
				logger.LogError((object)("Invalid key,value pair format: '" + Pair + "'! More details:"));
				logger.LogError((object)$"   Found '{array.Length}' parts");
				if (array.Length != 2)
				{
					logger.LogError((object)"   FAIL -> Should have only 2 parts!");
					return;
				}
				LogNicelyFloatParse(logger, "first", array[0]);
				LogNicelyFloatParse(logger, "second", array[1]);
			}
		}

		private void LogNicelyFloatParse(ManualLogSource logger, string context, string value)
		{
			logger.LogError((object)("   Attempting to parse " + context + " value: '" + value + "'"));
			if (float.TryParse(value, NumberStyles.Float, CultureInfo.InvariantCulture, out var result))
			{
				logger.LogError((object)$"   Parsed {context} value! Parsed Value is {result}");
			}
			else
			{
				logger.LogError((object)$"   FAIL -> Couldn't parse {context} value! Parsed Value is {result}");
			}
		}
	}
	public interface IPredicate
	{
		bool Evaluate();
	}
	public class ConstantPredicate : IPredicate
	{
		public static readonly ConstantPredicate True = new ConstantPredicate(value: true);

		public static readonly ConstantPredicate False = new ConstantPredicate(value: false);

		private bool _value;

		private ConstantPredicate(bool value)
		{
			_value = value;
		}

		public bool Evaluate()
		{
			return _value;
		}
	}
	public interface IProvider<out T>
	{
		T Provide();
	}
	public class SimpleProvider<T> : IProvider<T>
	{
		[CompilerGenerated]
		private T <value>P;

		public SimpleProvider(T value)
		{
			<value>P = value;
			base..ctor();
		}

		public T Provide()
		{
			return <value>P;
		}
	}
	internal static class ItemRegistrationHandler
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static hook_Awake <0>__RegisterScrapItems;

			public static hook_Awake <1>__RegisterShopItemsToTerminal;

			public static hook_SpawnScrapInLevel <2>__UpdateItemWeights;

			public static hook_SetPlanetsWeather <3>__UpdateItemWeights;

			public static Action <4>__FreezeItemContent;

			public static Action <5>__RedoItemsDebugMenu;
		}

		internal static void Init()
		{
			//IL_02a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ab: Expected O, but got Unknown
			//IL_02bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c6: Expected O, but got Unknown
			//IL_02db: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e6: Expected O, but got Unknown
			//IL_02fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0302: Expected O, but got Unknown
			//IL_0312: Unknown result type (might be due to invalid IL or missing references)
			//IL_0317: Unknown result type (might be due to invalid IL or missing references)
			//IL_031d: Expected O, but got Unknown
			//IL_033e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0343: Unknown result type (might be due to invalid IL or missing references)
			//IL_0349: Expected O, but got Unknown
			LethalContent.Items.AddAutoTaggers(new AutoNonInteractableTagger(), new SimpleAutoTagger<DawnItemInfo>(Tags.Conductive, (DawnItemInfo itemInfo) => itemInfo.Item.isConductiveMetal), new SimpleAutoTagger<DawnItemInfo>(Tags.Noisy, (DawnItemInfo itemInfo) => (Object)(object)itemInfo.Item.spawnPrefab.GetComponent<NoisemakerProp>() != (Object)null), new SimpleAutoTagger<DawnItemInfo>(Tags.Interactable, (DawnItemInfo itemInfo) => !itemInfo.HasTag(Tags.NonInteractable) && !itemInfo.HasTag(Tags.Noisy)), new SimpleAutoTagger<DawnItemInfo>(Tags.Paid, (DawnItemInfo itemInfo) => itemInfo.ShopInfo != null), new SimpleAutoTagger<DawnItemInfo>(Tags.Scrap, (DawnItemInfo itemInfo) => itemInfo.ScrapInfo != null), new SimpleAutoTagger<DawnItemInfo>(Tags.Chargeable, (DawnItemInfo itemInfo) => itemInfo.Item.requiresBattery), new SimpleAutoTagger<DawnItemInfo>(Tags.TwoHanded, (DawnItemInfo itemInfo) => itemInfo.Item.twoHanded), new SimpleAutoTagger<DawnItemInfo>(Tags.OneHanded, (DawnItemInfo itemInfo) => !itemInfo.Item.twoHanded), new SimpleAutoTagger<DawnItemInfo>(Tags.Weapon, (DawnItemInfo itemInfo) => itemInfo.Item.isDefensiveWeapon), new AutoItemGroupTagger(Tags.GeneralItemClassGroup, "GeneralItemClass"), new AutoItemGroupTagger(Tags.SmallItemsGroup, "SmallItems"), new AutoItemGroupTagger(Tags.TabletopItemsGroup, "TabletopItems"), new AutoItemGroupTagger(Tags.TestItemGroup, "TestItem"), new AutoValueTagger(Tags.LowValue, new BoundedRange(0f, 100f)), new AutoValueTagger(Tags.MediumValue, new BoundedRange(100f, 200f)), new AutoValueTagger(Tags.HighValue, new BoundedRange(200f, 2.1474836E+09f)), new AutoWeightTagger(Tags.LightWeight, new BoundedRange(0f, 1.2f)), new AutoWeightTagger(Tags.MediumWeight, new BoundedRange(1.2f, 1.4f)), new AutoWeightTagger(Tags.HeavyWeight, new BoundedRange(1.4f, 2.1474836E+09f)));
			DetourContext val = new DetourContext(2147483638);
			try
			{
				object obj = <>O.<0>__RegisterScrapItems;
				if (obj == null)
				{
					hook_Awake val2 = RegisterScrapItems;
					<>O.<0>__RegisterScrapItems = val2;
					obj = (object)val2;
				}
				StartOfRound.Awake += (hook_Awake)obj;
				object obj2 = <>O.<1>__RegisterShopItemsToTerminal;
				if (obj2 == null)
				{
					hook_Awake val3 = RegisterShopItemsToTerminal;
					<>O.<1>__RegisterShopItemsToTerminal = val3;
					obj2 = (object)val3;
				}
				Terminal.Awake += (hook_Awake)obj2;
			}
			finally
			{
				((IDisposable)val)?.Dispose();
			}
			DetourContext val4 = new DetourContext(int.MinValue);
			try
			{
				object obj3 = <>O.<2>__UpdateItemWeights;
				if (obj3 == null)
				{
					hook_SpawnScrapInLevel val5 = UpdateItemWeights;
					<>O.<2>__UpdateItemWeights = val5;
					obj3 = (object)val5;
				}
				RoundManager.SpawnScrapInLevel += (hook_SpawnScrapInLevel)obj3;
			}
			finally
			{
				((IDisposable)val4)?.Dispose();
			}
			object obj4 = <>O.<3>__UpdateItemWeights;
			if (obj4 == null)
			{
				hook_SetPlanetsWeather val6 = UpdateItemWeights;
				<>O.<3>__UpdateItemWeights = val6;
				obj4 = (object)val6;
			}
			StartOfRound.SetPlanetsWeather += (hook_SetPlanetsWeather)obj4;
			LethalContent.Moons.OnFreeze += FreezeItemContent;
			LethalContent.Items.OnFreeze += RedoItemsDebugMenu;
		}

		private static void RegisterScrapItems(orig_Awake orig, StartOfRound self)
		{
			if (LethalContent.Items.IsFrozen)
			{
				orig.Invoke(self);
				return;
			}
			foreach (DawnItemInfo value in LethalContent.Items.Values)
			{
				if (!value.ShouldSkipIgnoreOverride() && !self.allItemsList.itemsList.Contains(value.Item))
				{
					self.allItemsList.itemsList.Add(value.Item);
				}
			}
			orig.Invoke(self);
		}

		private static void RedoItemsDebugMenu()
		{
			QuickMenuManagerRefs.Instance.Debug_SetAllItemsDropdownOptions();
		}

		internal static void UpdateAllShopItemPrices()
		{
			foreach (DawnItemInfo value in LethalContent.Items.Values)
			{
				DawnShopItemInfo shopInfo = value.ShopInfo;
				if (shopInfo != null && !value.ShouldSkipRespectOverride())
				{
					UpdateShopItemPrices(shopInfo);
				}
			}
		}

		private static void UpdateShopItemPrices(DawnShopItemInfo shopInfo)
		{
			int num = shopInfo.DawnPurchaseInfo.Cost.Provide();
			shopInfo.ParentInfo.Item.creditsWorth = num;
			shopInfo.ReceiptNode.itemCost = num;
			shopInfo.RequestNode.itemCost = num;
		}

		private static void UpdateItemWeights(orig_SpawnScrapInLevel orig, RoundManager self)
		{
			UpdateItemWeightsOnLevel(self.currentLevel);
			List<SpawnableItemWithRarity> list = new List<SpawnableItemWithRarity>();
			SpawnableItemWithRarity[] array = self.currentLevel.spawnableScrap.ToArray();
			foreach (SpawnableItemWithRarity val in array)
			{
				if (val.rarity <= 0)
				{
					list.Add(val);
					self.currentLevel.spawnableScrap.Remove(val);
				}
			}
			orig.Invoke(self);
			foreach (SpawnableItemWithRarity item in list)
			{
				self.currentLevel.spawnableScrap.Add(item);
			}
		}

		private static void UpdateItemWeights(orig_SetPlanetsWeather orig, StartOfRound self, int connectedPlayersOnServer)
		{
			orig.Invoke(self, connectedPlayersOnServer);
			UpdateItemWeightsOnLevel(self.currentLevel);
		}

		internal static void UpdateItemWeightsOnLevel(SelectableLevel level)
		{
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Expected O, but got Unknown
			if (!LethalContent.Weathers.IsFrozen || !LethalContent.Items.IsFrozen || (Object)(object)StartOfRound.Instance == (Object)null || (WeatherRegistryCompat.Enabled && !WeatherRegistryCompat.IsWeatherManagerReady()))
			{
				return;
			}
			foreach (DawnItemInfo itemInfo in LethalContent.Items.Values)
			{
				DawnScrapItemInfo scrapInfo = itemInfo.ScrapInfo;
				if (scrapInfo != null && !itemInfo.ShouldSkipRespectOverride())
				{
					Debuggers.Items?.Log("Updating " + itemInfo.Item.itemName + "'s weights on level " + level.PlanetName + ".");
					SpawnableItemWithRarity val = ((IEnumerable<SpawnableItemWithRarity>)level.spawnableScrap).FirstOrDefault((Func<SpawnableItemWithRarity, bool>)((SpawnableItemWithRarity x) => (Object)(object)x.spawnableItem == (Object)(object)itemInfo.Item));
					if (val == null)
					{
						val = new SpawnableItemWithRarity
						{
							spawnableItem = itemInfo.Item,
							rarity = 0
						};
						level.spawnableScrap.Add(val);
					}
					val.rarity = scrapInfo.Weights.GetFor(level.GetDawnInfo()).GetValueOrDefault();
				}
			}
		}

		private static void FreezeItemContent()
		{
			//IL_038f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0394: Unknown result type (might be due to invalid IL or missing references)
			//IL_039c: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a6: Expected O, but got Unknown
			Dictionary<string, WeightTableBuilder<DawnMoonInfo>> dictionary = new Dictionary<string, WeightTableBuilder<DawnMoonInfo>>();
			Dictionary<string, DawnShopItemInfo> dictionary2 = new Dictionary<string, DawnShopItemInfo>();
			foreach (DawnMoonInfo value5 in LethalContent.Moons.Values)
			{
				SelectableLevel level = value5.Level;
				foreach (SpawnableItemWithRarity item2 in level.spawnableScrap)
				{
					if (!dictionary.TryGetValue(((Object)item2.spawnableItem).name, out var value))
					{
						value = new WeightTableBuilder<DawnMoonInfo>();
						dictionary[((Object)item2.spawnableItem).name] = value;
					}
					Debuggers.Items?.Log($"Adding weight {item2.rarity} to {((Object)item2.spawnableItem).name} on level {level.PlanetName}");
					value.AddWeight(value5.TypedKey, item2.rarity);
				}
			}
			Terminal instance = TerminalRefs.Instance;
			TerminalKeyword buyKeyword = TerminalRefs.BuyKeyword;
			TerminalKeyword infoKeyword = TerminalRefs.InfoKeyword;
			List<CompatibleNoun> list = buyKeyword.compatibleNouns.ToList();
			List<CompatibleNoun> list2 = infoKeyword.compatibleNouns.ToList();
			List<TerminalKeyword> list3 = instance.terminalNodes.allKeywords.ToList();
			foreach (TerminalKeyword item3 in list3)
			{
				item3.word = item3.word.Replace(" ", "-").ToLowerInvariant();
			}
			int i;
			for (i = 0; i < instance.buyableItemsList.Length; i++)
			{
				Item val = instance.buyableItemsList[i];
				TerminalNode val2 = null;
				TerminalNode requestNode = null;
				TerminalNode val3 = null;
				string simplifiedItemName = val.itemName.Replace(" ", "-").ToLowerInvariant();
				requestNode = (from noun in TerminalRefs.BuyKeyword.compatibleNouns
					where noun.result.buyItemIndex == i
					select noun.result).FirstOrDefault();
				if ((Object)(object)requestNode == (Object)null)
				{
					DawnPlugin.Logger.LogWarning((object)("No request Node found for " + val.itemName + " despite it being a buyable item, this is likely the result of an item being removed from the shop items list by LethalLib, i.e. Night Vision Goggles from MoreShipUpgrades"));
					continue;
				}
				val3 = requestNode.terminalOptions[0].result;
				TerminalKeyword val4 = (from noun in TerminalRefs.BuyKeyword.compatibleNouns
					where (Object)(object)noun.result == (Object)(object)requestNode
					select noun.noun).FirstOrDefault() ?? ((IEnumerable<TerminalKeyword>)list3).FirstOrDefaul