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.Internal;
using Dawn.Preloader.Interfaces;
using Dawn.Utils;
using DunGen;
using DunGen.Graph;
using GameNetcodeStuff;
using GoodItemScan;
using IL;
using IL.TerminalFormatter.Nodes;
using LethalConfig.ConfigItems;
using LethalLevelLoader;
using LethalLib.Modules;
using LethalQuantities.Objects;
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.LethalConfig.AutoConfig;
using On.LethalLevelLoader;
using On.LethalQuantities.Patches;
using PathfindingLib.API.SmartPathfinding;
using TMPro;
using Unity.Netcode;
using Unity.Netcode.Components;
using UnityEngine;
using UnityEngine.AI;
using UnityEngine.Audio;
using UnityEngine.Events;
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("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.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.1.9.0")]
[assembly: AssemblyInformationalVersion("0.1.9+09cb71a636e1df245dcd8b6809da4e52cfd9ebcf")]
[assembly: AssemblyProduct("DawnLib")]
[assembly: AssemblyTitle("com.github.teamxiaolan.dawnlib")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.1.9.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
[module: NetcodePatchedAssembly]
internal class <Module>
{
	static <Module>()
	{
		NetworkVariableSerializationTypes.InitializeSerializer_UnmanagedINetworkSerializable<NetworkTransformState>();
		NetworkVariableSerializationTypes.InitializeEqualityChecker_UnmanagedValueEquals<NetworkTransformState>();
	}
}
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 class DawnMapObjectInfoContainer : DawnInfoContainer<DawnMapObjectInfo>
{
}
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();
	}
	public class DataContainer : IDataContainer
	{
		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 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 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();
	}
	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;
			foreach (object key in dictionary.Keys)
			{
				NamespacedKey namespacedKey = (NamespacedKey)key;
				object obj = dictionary[key];
				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;

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

			public void Dispose()
			{
				_container._autoSave = true;
				Task.Run((Func<Task?>)_container.SaveAsync);
			}
		}

		private string _filePath;

		private bool _autoSave = true;

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

		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))
			{
				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);
				}
				Debuggers.PersistentDataContainer?.Log($"loaded {dictionary.Count} entries.");
			}
		}

		public override void Set<T>(NamespacedKey key, T value)
		{
			base.Set(key, value);
			if (_autoSave)
			{
				Task.Run((Func<Task?>)SaveAsync);
			}
		}

		public override void Clear()
		{
			base.Clear();
			if (_autoSave)
			{
				Task.Run((Func<Task?>)SaveAsync);
			}
		}

		public override void Remove(NamespacedKey key)
		{
			base.Remove(key);
			if (_autoSave)
			{
				Task.Run((Func<Task?>)SaveAsync);
			}
		}

		public IDisposable LargeEdit()
		{
			return new EditContext(this);
		}

		private async Task SaveAsync()
		{
			Debuggers.PersistentDataContainer?.Log("saving (" + Path.GetFileName(_filePath) + ")");
			await _saveLock.WaitAsync().ConfigureAwait(continueOnCapturedContext: false);
			try
			{
				await using FileStream stream = new FileStream(_filePath, FileMode.Create, FileAccess.Write, FileShare.None, 4096, useAsync: true);
				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) + ")");
			}
			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 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;
			}
		}
	}
	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
		{
			TypeNameHandling = (TypeNameHandling)3,
			Formatting = (Formatting)1,
			Converters = new List<JsonConverter>(2)
			{
				(JsonConverter)(object)new NamespacedKeyConverter(),
				(JsonConverter)(object)new NamespacedKeyDictionaryConverter()
			}
		};

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

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

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

		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 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();
			DawnMapObjectInfoContainer dawnMapObjectInfoContainer = mapObject.AddComponent<DawnMapObjectInfoContainer>();
			dawnMapObjectInfoContainer.Value = dawnMapObjectInfo;
			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 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);
			}
		}
	}
	internal static class AdditionalTilesRegistrationHandler
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static hook_Awake <0>__CollectVanillaDungeons;

			public static hook_Start <1>__CollectModdedDungeons;
		}

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

			public static hook_Generate <>9__0_0;

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

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

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

			internal DungeonFlow <CollectVanillaDungeons>b__1_0(IndoorMapType it)
			{
				return it.dungeonFlow;
			}

			internal DungeonFlow <CollectModdedDungeons>b__2_0(IndoorMapType it)
			{
				return it.dungeonFlow;
			}
		}

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

		internal static void Init()
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected O, but got Unknown
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Expected O, but got Unknown
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Expected O, but got Unknown
			object obj = <>O.<0>__CollectVanillaDungeons;
			if (obj == null)
			{
				hook_Awake val = CollectVanillaDungeons;
				<>O.<0>__CollectVanillaDungeons = val;
				obj = (object)val;
			}
			StartOfRound.Awake += (hook_Awake)obj;
			object obj2 = <>O.<1>__CollectModdedDungeons;
			if (obj2 == null)
			{
				hook_Start val2 = CollectModdedDungeons;
				<>O.<1>__CollectModdedDungeons = val2;
				obj2 = (object)val2;
			}
			RoundManager.Start += (hook_Start)obj2;
			object obj3 = <>c.<>9__0_0;
			if (obj3 == null)
			{
				hook_Generate val3 = delegate(orig_Generate orig, RuntimeDungeon self)
				{
					TryInjectTileSets(self.Generator.DungeonFlow);
					orig.Invoke(self);
				};
				<>c.<>9__0_0 = val3;
				obj3 = (object)val3;
			}
			RuntimeDungeon.Generate += (hook_Generate)obj3;
		}

		private static void CollectVanillaDungeons(orig_Awake orig, StartOfRound self)
		{
			if (LethalContent.Dungeons.IsFrozen)
			{
				orig.Invoke(self);
				return;
			}
			foreach (DungeonFlow item in ((Component)((Component)self).transform.parent).GetComponentInChildren<RoundManager>().dungeonFlowTypes.Select((IndoorMapType it) => it.dungeonFlow))
			{
				if (!((Object)(object)item == (Object)null))
				{
					string name = FormatFlowName(item);
					NamespacedKey<DawnDungeonInfo> byReflection = DungeonKeys.GetByReflection(name);
					if (byReflection == null)
					{
						DawnPlugin.Logger.LogWarning((object)(((Object)item).name + " is vanilla, but DawnLib couldn't get a corresponding NamespacedKey!"));
						continue;
					}
					HashSet<NamespacedKey> tags = new HashSet<NamespacedKey> { DawnLibTags.IsExternal };
					CollectLLLTags(item, tags);
					DawnDungeonInfo dawnDungeonInfo = new DawnDungeonInfo(byReflection, tags, item, null);
					item.SetDawnInfo(dawnDungeonInfo);
					LethalContent.Dungeons.Register(dawnDungeonInfo);
				}
			}
			orig.Invoke(self);
		}

		private static void CollectModdedDungeons(orig_Start orig, RoundManager self)
		{
			if (LethalContent.Dungeons.IsFrozen)
			{
				orig.Invoke(self);
				return;
			}
			orig.Invoke(self);
			foreach (DungeonFlow item in self.dungeonFlowTypes.Select((IndoorMapType it) => it.dungeonFlow))
			{
				if (!((Object)(object)item == (Object)null) && !item.HasDawnInfo())
				{
					Debuggers.Dungeons?.Log("Registering potentially modded dungeon: " + ((Object)item).name);
					string modName;
					NamespacedKey<DawnDungeonInfo> key = ((!LethalLevelLoaderCompat.Enabled || !LethalLevelLoaderCompat.TryGetExtendedDungeonModName(item, out modName)) ? NamespacedKey<DawnDungeonInfo>.From("unknown_modded", NamespacedKey.NormalizeStringForNamespacedKey(((Object)item).name, CSharpName: false)) : NamespacedKey<DawnDungeonInfo>.From(NamespacedKey.NormalizeStringForNamespacedKey(modName, CSharpName: false), NamespacedKey.NormalizeStringForNamespacedKey(((Object)item).name, CSharpName: false)));
					HashSet<NamespacedKey> tags = new HashSet<NamespacedKey> { DawnLibTags.IsExternal };
					CollectLLLTags(item, tags);
					DawnDungeonInfo dawnDungeonInfo = new DawnDungeonInfo(key, tags, item, null);
					item.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}");
						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}");
							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.HasTag(DawnLibTags.IsExternal))
					{
						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 IReadOnlyList<DoorwaySocket> Sockets => _sockets.AsReadOnly();

		internal DawnDungeonInfo(NamespacedKey<DawnDungeonInfo> key, HashSet<NamespacedKey> tags, DungeonFlow dungeonFlow, IDataContainer? customData)
			: base(key, tags, customData)
		{
			DungeonFlow = dungeonFlow;
			_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 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 Action <3>__RegisterEnemies;

			public static hook_Start <4>__AddEnemiesToDebugList;

			public static hook_Awake <5>__AddBestiaryNodes;
		}

		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_0155: Unknown result type (might be due to invalid IL or missing references)
			//IL_015a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0160: Expected O, but got Unknown
			//IL_0175: Unknown result type (might be due to invalid IL or missing references)
			//IL_017a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0180: 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;
			LethalContent.Moons.OnFreeze += RegisterEnemies;
			object obj4 = <>O.<4>__AddEnemiesToDebugList;
			if (obj4 == null)
			{
				hook_Start val4 = AddEnemiesToDebugList;
				<>O.<4>__AddEnemiesToDebugList = val4;
				obj4 = (object)val4;
			}
			QuickMenuManager.Start += (hook_Start)obj4;
			object obj5 = <>O.<5>__AddBestiaryNodes;
			if (obj5 == null)
			{
				hook_Awake val5 = AddBestiaryNodes;
				<>O.<5>__AddBestiaryNodes = val5;
				obj5 = (object)val5;
			}
			Terminal.Awake += (hook_Awake)obj5;
		}

		private static void AddBestiaryNodes(orig_Awake orig, Terminal self)
		{
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			//IL_0146: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: Expected O, but got Unknown
			TerminalKeyword val = self.terminalNodes.allKeywords.First((TerminalKeyword it) => it.word == "info");
			List<TerminalKeyword> list = self.terminalNodes.allKeywords.ToList();
			List<CompatibleNoun> list2 = val.compatibleNouns.ToList();
			foreach (DawnEnemyInfo value in LethalContent.Enemies.Values)
			{
				if (!value.HasTag(DawnLibTags.IsExternal) && Object.op_Implicit((Object)(object)value.BestiaryNode) && Object.op_Implicit((Object)(object)value.NameKeyword))
				{
					value.BestiaryNode.creatureFileID = self.enemyFiles.Count;
					self.enemyFiles.Add(value.BestiaryNode);
					ScanNodeProperties[] componentsInChildren = value.EnemyType.enemyPrefab.GetComponentsInChildren<ScanNodeProperties>();
					ScanNodeProperties[] array = componentsInChildren;
					foreach (ScanNodeProperties val2 in array)
					{
						val2.creatureScanID = value.BestiaryNode.creatureFileID;
					}
					if (!list.Contains(value.NameKeyword))
					{
						value.NameKeyword.defaultVerb = val;
						list.Add(value.NameKeyword);
						list2.Add(new CompatibleNoun
						{
							noun = value.NameKeyword,
							result = value.BestiaryNode
						});
					}
				}
			}
			val.compatibleNouns = list2.ToArray();
			self.terminalNodes.allKeywords = list.ToArray();
			orig.Invoke(self);
		}

		private static void AddEnemiesToDebugList(orig_Start orig, QuickMenuManager self)
		{
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Expected O, but got Unknown
			SelectableLevel level = LethalContent.Moons[MoonKeys.Test].Level;
			foreach (DawnEnemyInfo enemyInfo in LethalContent.Enemies.Values)
			{
				if (!enemyInfo.HasTag(DawnLibTags.IsExternal))
				{
					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_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0125: 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.HasTag(DawnLibTags.IsExternal) || 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)
		{
			if (!LethalContent.Enemies.IsFrozen || (Object)(object)StartOfRound.Instance == (Object)null || (WeatherRegistryCompat.Enabled && WeatherRegistryCompat.IsWeatherManagerReady()))
			{
				return;
			}
			foreach (DawnEnemyInfo enemyInfo in LethalContent.Enemies.Values)
			{
				if (enemyInfo.HasTag(DawnLibTags.IsExternal))
				{
					continue;
				}
				Debuggers.Enemies?.Log($"Updating weights for {enemyInfo.EnemyType} on level {level.PlanetName}");
				if (enemyInfo.Outside != null)
				{
					level.OutsideEnemies.Where((SpawnableEnemyWithRarity x) => (Object)(object)x.enemyType == (Object)(object)enemyInfo.EnemyType).First().rarity = enemyInfo.Outside.Weights.GetFor(level.GetDawnInfo()).GetValueOrDefault();
				}
				if (enemyInfo.Inside != null)
				{
					level.Enemies.Where((SpawnableEnemyWithRarity x) => (Object)(object)x.enemyType == (Object)(object)enemyInfo.EnemyType).First().rarity = enemyInfo.Inside.Weights.GetFor(level.GetDawnInfo()).GetValueOrDefault();
				}
				if (enemyInfo.Daytime != null)
				{
					level.DaytimeEnemies.Where((SpawnableEnemyWithRarity x) => (Object)(object)x.enemyType == (Object)(object)enemyInfo.EnemyType).First().rarity = enemyInfo.Daytime.Weights.GetFor(level.GetDawnInfo()).GetValueOrDefault();
				}
			}
		}

		private static void RegisterEnemies()
		{
			Dictionary<EnemyType, WeightTableBuilder<DawnMoonInfo>> dictionary = new Dictionary<EnemyType, WeightTableBuilder<DawnMoonInfo>>();
			Dictionary<EnemyType, WeightTableBuilder<DawnMoonInfo>> dictionary2 = new Dictionary<EnemyType, WeightTableBuilder<DawnMoonInfo>>();
			Dictionary<EnemyType, WeightTableBuilder<DawnMoonInfo>> dictionary3 = new Dictionary<EnemyType, 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(enemy.enemyType, out var value))
						{
							value = new WeightTableBuilder<DawnMoonInfo>();
							dictionary[enemy.enemyType] = value;
						}
						value.AddWeight(typedKey, enemy.rarity);
					}
				}
				foreach (SpawnableEnemyWithRarity outsideEnemy in level.OutsideEnemies)
				{
					if (!((Object)(object)outsideEnemy.enemyType == (Object)null))
					{
						if (!dictionary2.TryGetValue(outsideEnemy.enemyType, out var value2))
						{
							value2 = new WeightTableBuilder<DawnMoonInfo>();
							dictionary2[outsideEnemy.enemyType] = value2;
						}
						value2.AddWeight(typedKey, outsideEnemy.rarity);
					}
				}
				foreach (SpawnableEnemyWithRarity daytimeEnemy in level.DaytimeEnemies)
				{
					if (!((Object)(object)daytimeEnemy.enemyType == (Object)null))
					{
						if (!dictionary3.TryGetValue(daytimeEnemy.enemyType, out var value3))
						{
							value3 = new WeightTableBuilder<DawnMoonInfo>();
							dictionary3[daytimeEnemy.enemyType] = value3;
						}
						value3.AddWeight(typedKey, daytimeEnemy.rarity);
					}
				}
			}
			TerminalKeyword infoKeyword = TerminalRefs.InfoKeyword;
			foreach (DawnMoonInfo value5 in LethalContent.Moons.Values)
			{
				SelectableLevel level2 = value5.Level;
				List<SpawnableEnemyWithRarity> enemies = level2.Enemies;
				List<SpawnableEnemyWithRarity> outsideEnemies = level2.OutsideEnemies;
				List<SpawnableEnemyWithRarity> daytimeEnemies = level2.DaytimeEnemies;
				List<SpawnableEnemyWithRarity> list = new List<SpawnableEnemyWithRarity>(enemies.Count + outsideEnemies.Count + daytimeEnemies.Count);
				foreach (SpawnableEnemyWithRarity item in enemies)
				{
					list.Add(item);
				}
				foreach (SpawnableEnemyWithRarity item2 in outsideEnemies)
				{
					list.Add(item2);
				}
				foreach (SpawnableEnemyWithRarity item3 in daytimeEnemies)
				{
					list.Add(item3);
				}
				List<SpawnableEnemyWithRarity> list2 = list;
				foreach (SpawnableEnemyWithRarity item4 in list2)
				{
					EnemyType enemyType = item4.enemyType;
					if ((Object)(object)enemyType == (Object)null || (Object)(object)enemyType.enemyPrefab == (Object)null || enemyType.HasDawnInfo())
					{
						continue;
					}
					string name = NamespacedKey.NormalizeStringForNamespacedKey(enemyType.enemyName, CSharpName: true);
					NamespacedKey<DawnEnemyInfo> namespacedKey = EnemyKeys.GetByReflection(name);
					string modName2;
					if (namespacedKey == null && LethalLibCompat.Enabled && LethalLibCompat.TryGetEnemyTypeFromLethalLib(enemyType, out string modName))
					{
						namespacedKey = NamespacedKey<DawnEnemyInfo>.From(NamespacedKey.NormalizeStringForNamespacedKey(modName, CSharpName: false), NamespacedKey.NormalizeStringForNamespacedKey(enemyType.enemyName, CSharpName: false));
					}
					else if (namespacedKey == null && LethalLevelLoaderCompat.Enabled && LethalLevelLoaderCompat.TryGetExtendedEnemyTypeModName(enemyType, out modName2))
					{
						namespacedKey = NamespacedKey<DawnEnemyInfo>.From(NamespacedKey.NormalizeStringForNamespacedKey(modName2, CSharpName: false), NamespacedKey.NormalizeStringForNamespacedKey(enemyType.enemyName, CSharpName: false));
					}
					else if (namespacedKey == null)
					{
						namespacedKey = NamespacedKey<DawnEnemyInfo>.From("unknown_lib", NamespacedKey.NormalizeStringForNamespacedKey(enemyType.enemyName, CSharpName: false));
					}
					if (LethalContent.Enemies.ContainsKey(namespacedKey))
					{
						DawnPlugin.Logger.LogWarning((object)("Enemy " + enemyType.enemyName + " is already registered by the same creator to LethalContent. This is likely to cause issues."));
						enemyType.SetDawnInfo(LethalContent.Enemies[namespacedKey]);
						continue;
					}
					if (!Object.op_Implicit((Object)(object)enemyType.enemyPrefab))
					{
						DawnPlugin.Logger.LogWarning((object)(enemyType.enemyName + " (" + ((Object)enemyType).name + ") didn't have a spawn prefab?"));
						continue;
					}
					DawnEnemyLocationInfo inside = null;
					DawnEnemyLocationInfo outside = null;
					DawnEnemyLocationInfo daytime = null;
					if (dictionary.ContainsKey(enemyType))
					{
						inside = new DawnEnemyLocationInfo(dictionary[enemyType].Build());
					}
					if (dictionary2.ContainsKey(enemyType))
					{
						outside = new DawnEnemyLocationInfo(dictionary2[enemyType].Build());
					}
					if (dictionary3.ContainsKey(enemyType))
					{
						daytime = new DawnEnemyLocationInfo(dictionary3[enemyType].Build());
					}
					HashSet<NamespacedKey> tags = new HashSet<NamespacedKey> { DawnLibTags.IsExternal };
					CollectLLLTags(enemyType, tags);
					TerminalNode bestiaryNode = null;
					TerminalKeyword nameKeyword = null;
					ScanNodeProperties componentInChildren = enemyType.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, enemyType, outside, inside, daytime, bestiaryNode, nameKeyword, null);
					enemyType.SetDawnInfo(dawnEnemyInfo);
					LethalContent.Enemies.Register(dawnEnemyInfo);
				}
				foreach (DawnEnemyInfo value6 in LethalContent.Enemies.Values)
				{
					if (!value6.HasTag(DawnLibTags.IsExternal))
					{
						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_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Expected O, but got Unknown
			SpawnableEnemyWithRarity item = new SpawnableEnemyWithRarity
			{
				enemyType = enemyInfo.EnemyType,
				rarity = 0
			};
			list.Add(item);
		}
	}
	public sealed class DawnEnemyInfo : DawnBaseInfo<DawnEnemyInfo>
	{
		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;
		}

		public IEnumerable<T> GetAllSpawned<T>() where T : EnemyAI
		{
			foreach (EnemyAI spawnedEnemy in RoundManager.Instance.SpawnedEnemies)
			{
				if ((Object)(object)spawnedEnemy.enemyType == (Object)(object)EnemyType)
				{
					yield return (T)(object)spawnedEnemy;
				}
			}
		}
	}
	public class DawnEnemyLocationInfo
	{
		public DawnEnemyInfo ParentInfo { get; internal set; }

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

		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 SetBestiaryNode(TerminalNode node)
		{
			_bestiaryNode = node;
			return this;
		}

		public EnemyInfoBuilder OverrideNameKeyword(string word)
		{
			_nameKeyword = ScriptableObject.CreateInstance<TerminalKeyword>();
			((Object)_nameKeyword).name = word;
			_nameKeyword.word = word;
			return this;
		}

		public EnemyInfoBuilder OverrideNameKeyword(TerminalKeyword keyword)
		{
			_nameKeyword = keyword;
			return this;
		}

		internal override DawnEnemyInfo Build()
		{
			if ((Object)(object)_bestiaryNode == (Object)null)
			{
				_bestiaryNode = new TerminalNodeBuilder(base.value.enemyName + "BestiaryNode").SetDisplayText(base.value.enemyName + "\n\nDanger level: Unknown\n\n[No information about this creature was found.]\n\n").SetClearPreviousText(clearPreviousText: true).SetMaxCharactersToType(35)
					.Build();
			}
			if ((Object)(object)_nameKeyword == (Object)null)
			{
				string word = base.value.enemyName.ToLowerInvariant().Replace(' ', '-');
				OverrideNameKeyword(word);
			}
			_bestiaryNode.creatureName = base.value.enemyName;
			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_SpawnScrapInLevel <0>__UpdateItemWeights;

			public static hook_SetPlanetsWeather <1>__UpdateItemWeights;

			public static hook_Awake <2>__RegisterShopItemsToTerminal;

			public static Action <3>__FreezeItemContent;
		}

		internal static void Init()
		{
			//IL_02b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bb: Expected O, but got Unknown
			//IL_02d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02db: Expected O, but got Unknown
			//IL_02f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fb: 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)));
			object obj = <>O.<0>__UpdateItemWeights;
			if (obj == null)
			{
				hook_SpawnScrapInLevel val = UpdateItemWeights;
				<>O.<0>__UpdateItemWeights = val;
				obj = (object)val;
			}
			RoundManager.SpawnScrapInLevel += (hook_SpawnScrapInLevel)obj;
			object obj2 = <>O.<1>__UpdateItemWeights;
			if (obj2 == null)
			{
				hook_SetPlanetsWeather val2 = UpdateItemWeights;
				<>O.<1>__UpdateItemWeights = val2;
				obj2 = (object)val2;
			}
			StartOfRound.SetPlanetsWeather += (hook_SetPlanetsWeather)obj2;
			object obj3 = <>O.<2>__RegisterShopItemsToTerminal;
			if (obj3 == null)
			{
				hook_Awake val3 = RegisterShopItemsToTerminal;
				<>O.<2>__RegisterShopItemsToTerminal = val3;
				obj3 = (object)val3;
			}
			Terminal.Awake += (hook_Awake)obj3;
			LethalContent.Moons.OnFreeze += FreezeItemContent;
		}

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

		private static void UpdateShopItemPrices(DawnShopItemInfo shopInfo)
		{
			int num = shopInfo.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);
			orig.Invoke(self);
		}

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

		internal static void UpdateItemWeightsOnLevel(SelectableLevel level)
		{
			if (!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.HasTag(DawnLibTags.IsExternal))
				{
					Debuggers.Items?.Log("Updating " + itemInfo.Item.itemName + "'s weights on level " + level.PlanetName + ".");
					level.spawnableScrap.Where((SpawnableItemWithRarity x) => (Object)(object)x.spawnableItem == (Object)(object)itemInfo.Item).First().rarity = scrapInfo.Weights.GetFor(level.GetDawnInfo()).GetValueOrDefault();
				}
			}
		}

		private static void FreezeItemContent()
		{
			//IL_03c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_03cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_03de: Expected O, but got Unknown
			if (LethalContent.Items.IsFrozen)
			{
				return;
			}
			Dictionary<Item, WeightTableBuilder<DawnMoonInfo>> dictionary = new Dictionary<Item, WeightTableBuilder<DawnMoonInfo>>();
			Dictionary<Item, DawnShopItemInfo> dictionary2 = new Dictionary<Item, DawnShopItemInfo>();
			foreach (DawnMoonInfo value5 in LethalContent.Moons.Values)
			{
				SelectableLevel level = value5.Level;
				foreach (SpawnableItemWithRarity item2 in level.spawnableScrap)
				{
					if (!dictionary.TryGetValue(item2.spawnableItem, out var value))
					{
						value = new WeightTableBuilder<DawnMoonInfo>();
						dictionary[item2.spawnableItem] = value;
					}
					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)
			{
				Debuggers.Items?.Log("TerminalKeyword.word for " + ((Object)item3).name + ": " + item3.word);
				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;
				Debuggers.Items?.Log("Processing " + val.itemName);
				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).FirstOrDefault((Func<TerminalKeyword, bool>)((TerminalKeyword keyword) => keyword.word == simplifiedItemName));
				if ((Object)(object)val4 == (Object)null)
				{
					DawnPlugin.Logger.LogWarning((object)("No buy Keyword 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;
				}
				CompatibleNoun[] compatibleNouns = infoKeyword.compatibleNouns;
				foreach (CompatibleNoun val5 in compatibleNouns)
				{
					if ((Object)(object)val5.noun == (Object)(object)val4)
					{
						val2 = val5.result;
						break;
					}
					Debuggers.Items?.Log("Checking compatible nouns for info node: " + val5.noun.word);
				}
				if ((Object)(object)val2 == (Object)null)
				{
					val2 = new TerminalNodeBuilder(simplifiedItemName + "InfoNode").SetDisplayText("[No information about this object was found.]\n\n").SetClearPreviousText(clearPreviousText: true).SetMaxCharactersToType(25)
						.Build();
					CompatibleNoun item = new CompatibleNoun
					{
						noun = val4,
						result = val2
					};
					List<CompatibleNoun> list4 = infoKeyword.compatibleNouns.ToList();
					list4.Add(item);
					infoKeyword.compatibleNouns = list4.ToArray();
				}
				CompatibleNoun[] compatibleNouns2 = buyKeyword.compatibleNouns;
				foreach (CompatibleNoun val6 in compatibleNouns2)
				{
					if ((Object)(object)val6.noun == (Object)(object)val4)
					{
						requestNode = val6.result;
						break;
					}
					Debuggers.Items?.Log("Checking compatible nouns for request node: " + val6.noun.word);
				}
				DawnShopItemInfo value2 = new DawnShopItemInfo(ITerminalPurchasePredicate.AlwaysSuccess(), val2, requestNode, val3, new SimpleProvider<int>(val.creditsWorth));
				dictionary2[val] = value2;
			}
			foreach (Item items in StartOfRound.Instance.allItemsList.itemsList)
			{
				if (items.HasDawnInfo())
				{
					continue;
				}
				string name = NamespacedKey.NormalizeStringForNamespacedKey(items.itemName, CSharpName: true);
				NamespacedKey<DawnItemInfo> namespacedKey = ItemKeys.GetByReflection(name);
				string modName2;
				if (namespacedKey == null && LethalLibCompat.Enabled && LethalLibCompat.TryGetItemFromLethalLib(items, out string modName))
				{
					namespacedKey = NamespacedKey<DawnItemInfo>.From(NamespacedKey.NormalizeStringForNamespacedKey(modName, CSharpName: false), NamespacedKey.NormalizeStringForNamespacedKey(items.itemName, CSharpName: false));
				}
				else if (namespacedKey == null && LethalLevelLoaderCompat.Enabled && LethalLevelLoaderCompat.TryGetExtendedItemModName(items, out modName2))
				{
					namespacedKey = NamespacedKey<DawnItemInfo>.From(NamespacedKey.NormalizeStringForNamespacedKey(modName2, CSharpName: false), NamespacedKey.NormalizeStringForNamespacedKey(items.itemName, CSharpName: false));
				}
				else if (namespacedKey == null)
				{
					namespacedKey = NamespacedKey<DawnItemInfo>.From("unknown_lib", NamespacedKey.NormalizeStringForNamespacedKey(items.itemName, CSharpName: false));
				}
				if (LethalContent.Items.ContainsKey(namespacedKey))
				{
					DawnPlugin.Logger.LogWarning((object)("Item " + items.itemName + " is already registered by the same creator to LethalContent. This is likely to cause issues."));
					items.SetDawnInfo(LethalContent.Items[namespacedKey]);
					continue;
				}
				dictionary.TryGetValue(items, out var value3);
				DawnScrapItemInfo scrapItemInfo = null;
				dictionary2.TryGetValue(items, out var value4);
				if (value3 != null)
				{
					scrapItemInfo = new DawnScrapItemInfo(value3.Build());
				}
				if (!Object.op_Implicit((Object)(object)items.spawnPrefab))
				{
					DawnPlugin.Logger.LogWarning((object)(items.itemName + " (" + ((Object)items).name + ") didn't have a spawn prefab?"));
					continue;
				}
				HashSet<NamespacedKey> tags = new HashSet<NamespacedKey> { DawnLibTags.IsExternal };
				CollectLLLTags(items, tags);
				DawnItemInfo dawnItemInfo = new DawnItemInfo(namespacedKey, tags, items, scrapItemInfo, value4, null);
				items.SetDawnInfo(dawnItemInfo);
				LethalContent.Items.Register(dawnItemInfo);
			}
			RegisterScrapItemsToAllLevels();
			LethalContent.Items.Freeze();
		}

		private static void RegisterScrapItemsToAllLevels()
		{
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Expected O, but got Unknown
			foreach (DawnItemInfo value in LethalContent.Items.Values)
			{
				DawnScrapItemInfo scrapInfo = value.ScrapInfo;
				if (scrapInfo == null || value.HasTag(DawnLibTags.IsExternal))
				{
					continue;
				}
				foreach (DawnMoonInfo value2 in LethalContent.Moons.Values)
				{
					SelectableLevel level = value2.Level;
					SpawnableItemWithRarity item = new SpawnableItemWithRarity
					{
						spawnableItem = value.Item,
						rarity = 0
					};
					level.spawnableScrap.Add(item);
				}
				if (value.ShopInfo == null)
				{
					StartOfRound.Instance.allItemsList.itemsList.Add(value.Item);
				}
			}
		}

		private static void RegisterShopItemsToTerminal(orig_Awake orig, Terminal self)
		{
			//IL_01af: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c4: Expected O, but got Unknown
			//IL_01c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dc: Expected O, but got Unknown
			//IL_01e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fd: Expected O, but got Unknown
			//IL_01ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0204: Unknown result type (might be due to invalid IL or missing references)
			//IL_020c: Unknown result type (might be due to invalid IL or missing references)
			//IL_021e: Expected O, but got Unknown
			Terminal instance = TerminalRefs.Instance;
			TerminalKeyword buyKeyword = TerminalRefs.BuyKeyword;
			TerminalKeyword infoKeyword = TerminalRefs.InfoKeyword;
			TerminalKeyword confirmPurchaseKeyword = TerminalRefs.ConfirmPurchaseKeyword;
			TerminalKeyword denyKeyword = TerminalRefs.DenyKeyword;
			TerminalNode cancelPurchaseNode = TerminalRefs.CancelPurchaseNode;
			List<Item> list = self.buyableItemsList.ToList();
			List<CompatibleNoun> list2 = buyKeyword.compatibleNouns.ToList();
			List<CompatibleNoun> list3 = infoKeyword.compatibleNouns.ToList();
			List<TerminalKeyword> list4 = self.terminalNodes.allKeywords.ToList();
			StartOfRound instance2 = StartOfRoundRefs.Instance;
			foreach (DawnItemInfo value in LethalContent.Items.Values)
			{
				DawnShopItemInfo shopInfo = value.ShopInfo;
				if (shopInfo == null || value.HasTag(DawnLibTags.IsExternal))
				{
					continue;
				}
				string text = value.Item.itemName.Replace(" ", "-").ToLowerInvariant();
				list.Add(value.Item);
				foreach (TerminalKeyword item in list4)
				{
					_ = item.word == text;
				}
				TerminalKeyword val = ScriptableObject.CreateInstance<TerminalKeyword>();
				((Object)val).name = text;
				val.word = text;
				val.isVerb = false;
				val.compatibleNouns = null;
				val.specialKeywordResult = null;
				val.defaultVerb = buyKeyword;
				val.accessTerminalObjects = false;
				list4.Add(val);
				TerminalNode receiptNode = shopInfo.ReceiptNode;
				TerminalNode requestNode = shopInfo.RequestNode;
				UpdateShopItemPrices(shopInfo);
				receiptNode.buyItemIndex = list.Count - 1;
				requestNode.buyItemIndex = list.Count - 1;
				requestNode.isConfirmationNode = true;
				requestNode.overrideOptions = true;
				requestNode.terminalOptions = (CompatibleNoun[])(object)new CompatibleNoun[2]
				{
					new CompatibleNoun
					{
						noun = confirmPurchaseKeyword,
						result = receiptNode
					},
					new CompatibleNoun
					{
						noun = denyKeyword,
						result = cancelPurchaseNode
					}
				};
				list2.Add(new CompatibleNoun
				{
					noun = val,
					result = requestNode
				});
				list3.Add(new CompatibleNoun
				{
					noun = val,
					result = shopInfo.InfoNode
				});
				instance2.allItemsList.itemsList.Add(value.Item);
			}
			self.buyableItemsList = list.ToArray();
			infoKeyword.compatibleNouns = list3.ToArray();
			buyKeyword.compatibleNouns = list2.ToArray();
			self.terminalNodes.allKeywords = list4.ToArray();
			orig.Invoke(self);
		}

		private static void CollectLLLTags(Item item, HashSet<NamespacedKey> tags)
		{
			if (LethalLevelLoaderCompat.Enabled && LethalLevelLoaderCompat.TryGetAllTagsWithModNames(item, out List<(string, string)> allTagsWithModNames))
			{
				tags.AddToList(allTagsWithModNames, Debuggers.Items, ((Object)item).name);
			}
		}
	}
	public class AutoItemGroupTagger : IAutoTagger<DawnItemInfo>
	{
		[CompilerGenerated]
		private NamespacedKey <tag>P;

		[CompilerGenerated]
		private string <itemGroupName>P;

		public NamespacedKey Tag => <tag>P;

		public AutoItemGroupTagger(NamespacedKey tag, string itemGroupName)
		{
			<tag>P = tag;
			<itemGroupName>P = itemGroupName;
			base..ctor();
		}

		public bool ShouldApply(DawnItemInfo info)
		{
			if (info.Item.spawnPositionTypes == null)
			{
				return false;
			}
			foreach (ItemGroup spawnPositionType in info.Item.spawnPositionTypes)
			{
				if ((Object)(object)spawnPositionType == (Object)null)
				{
					DawnPlugin.Logger.LogWarning((object)$"Item: {info.Key} has a null ItemGroup, why!?!?");
				}
				else if (((Object)spawnPositionType).name == <itemGroupName>P)
				{
					return true;
				}
			}
			return false;
		}
	}
	public class AutoNonInteractableTagger : IAutoTagger<DawnItemInfo>
	{
		public NamespacedKey Tag => Tags.NonInteractable;

		public bool ShouldApply(DawnItemInfo info)
		{
			GrabbableObject val = default(GrabbableObject);
			if (info.Item.spawnPrefab.TryGetComponent<GrabbableObject>(ref val))
			{
				return ((object)val).GetType() == typeof(GrabbableObject);
			}
			return false;
		}
	}
	public class AutoValueTagger : IAutoTagger<DawnItemInfo>
	{
		[CompilerGenerated]
		private NamespacedKey <tag>P;

		[CompilerGenerated]
		private BoundedRange <range>P;

		public NamespacedKey Tag => <tag>P;

		public AutoValueTagger(NamespacedKey tag, BoundedRange range)
		{
			<tag>P = tag;
			<range>P = range;
			base..ctor();
		}

		public bool ShouldApply(DawnItemInfo info)
		{
			float value = (float)(info.Item.maxValue + info.Item.minValue) / 2f;
			return <range>P.IsInRange(value);
		}
	}
	public class AutoWeightTagger : IAutoTagger<DawnItemInfo>
	{
		[CompilerGenerated]
		private NamespacedKey <tag>P;

		[CompilerGenerated]
		private BoundedRange <range>P;

		public NamespacedKey Tag => <tag>P;

		public AutoWeightTagger(NamespacedKey tag, BoundedRange range)
		{
			<tag>P = tag;
			<range>P = range;
			base..ctor();
		}

		public bool ShouldApply(DawnItemInfo info)
		{
			return <range>P.IsInRange(info.Item.weight);
		}
	}
	public sealed class DawnItemInfo : DawnBaseInfo<DawnItemInfo>
	{
		public Item Item { get; }

		public DawnScrapItemInfo? ScrapInfo { get; }

		public DawnShopItemInfo? ShopInfo { get; }

		internal DawnItemInfo(NamespacedKey<DawnItemInfo> key, HashSet<NamespacedKey> tags, Item item, DawnScrapItemInfo? scrapItemInfo, DawnShopItemInfo? shopItemInfo, IDataContainer? customData)
			: base(key, tags, customData)
		{
			Item = item;
			ScrapInfo = scrapItemInfo;
			if (ScrapInfo != null)
			{
				ScrapInfo.ParentInfo = this;
			}
			ShopInfo = shopItemInfo;
			if (ShopInfo != null)
			{
				ShopInfo.ParentInfo = this;
			}
		}
	}
	public sealed class DawnScrapItemInfo
	{
		public DawnItemInfo ParentInfo { get; internal set; }

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

		internal DawnScrapItemInfo(ProviderTable<int?, DawnMoonInfo> weights)
		{
			Weights = weights;
		}
	}
	public sealed class DawnShopItemInfo : ITerminalPurchase
	{
		public DawnItemInfo ParentInfo { get; internal set; }

		public TerminalNode? InfoNode { get; }

		public TerminalNode RequestNode { get; }

		public TerminalNode ReceiptNode { get; }

		public IProvider<int> Cost { get; }

		public ITerminalPurchasePredicate PurchasePredicate { get; }

		internal DawnShopItemInfo(ITerminalPurchasePredicate predicate, TerminalNode? infoNode, TerminalNode requestNode, TerminalNode receiptNode, IProvider<int> cost)
		{
			PurchasePredicate = predicate;
			InfoNode = infoNode;
			RequestNode = requestNode;
			ReceiptNode = receiptNode;
			Cost = cost;
		}

		public void AddToDropship(bool ignoreMax = false, int count = 1)
		{
			Terminal instance = TerminalRefs.Instance;
			for (int i = 0; i < count; i++)
			{
				if (!ignoreMax && instance.orderedItemsFromTerminal.Count > 12)
				{
					break;
				}
				instance.orderedItemsFromTerminal.Add(RequestNode.buyItemIndex);
				instance.numberOfItemsInDropship++;
			}
		}

		public int GetSalePercentage()
		{
			Terminal instance = TerminalRefs.Instance;
			return instance.itemSalesPercentages[RequestNode.buyItemIndex];
		}
	}
	public static class ItemExtensions
	{
		public static DawnItemInfo GetDawnInfo(this Item item)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return (DawnItemInfo)((IDawnObject)item).DawnInfo;
		}

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

		internal static void SetDawnInfo(this Item item, DawnItemInfo itemInfo)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			((IDawnObject)item).DawnInfo = itemInfo;
		}
	}
	public class ItemInfoBuilder : BaseInfoBuilder<DawnItemInfo, Item, ItemInfoBuilder>
	{
		public class ScrapBuilder
		{
			private ItemInfoBuilder _parentBuilder;

			private ProviderTable<int?, DawnMoonInfo>? _weights;

			internal ScrapBuilder(ItemInfoBuilder parent)
			{
				_parentBuilder = parent;
			}

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

			internal DawnScrapItemInfo Build()
			{
				if (_weights == null)
				{
					DawnPlugin.Logger.LogWarning((object)("Scrap item '" + _parentBuilder.value.itemName + "' didn't set weights. If you intend to have no weights (doing something special), call .SetWeights(() => {})"));
					_weights = ProviderTable<int?, DawnMoonInfo>.Empty();
				}
				return new DawnScrapItemInfo(_weights);
			}
		}

		public class ShopBuilder
		{
			private ItemInfoBuilder _parentBuilder;

			private TerminalNode? _infoNode;

			private TerminalNode? _requestNode;

			private TerminalNode? _receiptNode;

			private IProvider<int>? _costOverride;

			private ITerminalPurchasePredicate? _purchasePredicate;

			internal ShopBuilder(ItemInfoBuilder parent)
			{
				_parentBuilder = parent;
			}

			public ShopBuilder OverrideCost(int cost)
			{
				return OverrideCost(new SimpleProvider<int>(cost));
			}

			public ShopBuilder OverrideCost(IProvider<int> cost)
			{
				_costOverride = cost;
				return this;
			}

			public ShopBuilder SetPurchasePredicate(ITerminalPurchasePredicate predicate)
			{
				_purchasePredicate = predicate;
				return this;
			}

			public ShopBuilder OverrideInfoNode(TerminalNode infoNode)
			{
				_infoNode = infoNode;
				return this;
			}

			public ShopBuilder OverrideRequestNode(TerminalNode requestNode)
			{
				_requestNode = requestNode;
				return this;
			}

			public ShopBuilder OverrideReceiptNode(TerminalNode receiptNode)
			{
				_receiptNode = receiptNode;
				return this;
			}

			internal DawnShopItemInfo Build()
			{
				if ((Object)(object)_receiptNode == (Object)null)
				{
					_receiptNode = new TerminalNodeBuilder(_parentBuilder.value.itemName + "ReceiptNode").SetDisplayText("Ordered [variableAmount] " + _parentBuilder.value.itemName + ". Your new balance is [playerCredits].\n\nOur contractors enjoy fast, free shipping while on the job! Any purchased items will arrive hourly at your approximate location.\r\n\r\n").SetClearPreviousText(clearPreviousText: true).SetMaxCharactersToType(15)
						.Build();
				}
				if ((Object)(object)_requestNode == (Object)null)
				{
					_requestNode = new TerminalNodeBuilder(_parentBuilder.value.itemName + "RequestNode").SetDisplayText("You have requested to order " + _parentBuilder.value.itemName + ". Amount: [variableAmount].\nTotal cost of items: [totalCost].\n\nPlease CONFIRM or DENY.\r\n\r\n").SetClearPreviousText(clearPreviousText: true).SetMaxCharactersToType(35)
						.Build();
				}
				if ((Object)(object)_infoNode == (Object)null)
				{
					_infoNode = new TerminalNodeBuilder(_parentBuilder.value.itemName + "InfoNode").SetDisplayText("[No information about this object was found.]\n\n").SetClearPreviousText(clearPreviousText: true).SetMaxCharactersToType(25)
						.Build();
				}
				if (_purchasePredicate == null)
				{
					_purchasePredicate = ITerminalPurchasePredicate.AlwaysSuccess();
				}
				if (_costOverride == null)
				{
					_costOverride = new SimpleProvider<int>(_parentBuilder.value.creditsWorth);
				}
				return new DawnShopItemInfo(_purchasePredicate, _infoNode, _requestNode, _receiptNode, _costOverride);
			}
		}

		private DawnScrapItemInfo? _scrapInfo;

		private DawnShopItemInfo? _shopInfo;

		internal ItemInfoBuilder(NamespacedKey<DawnItemInfo> key, Item item)
			: base(key, item)
		{
		}

		public ItemInfoBuilder DefineShop(Action<ShopBuilder> callback)
		{
			ShopBuilder shopBuilder = new ShopBuilder(this);
			callback(shopBuilder);
			_shopInfo = shopBuilder.Build();
			return this;
		}

		public ItemInfoBuilder DefineScrap(Action<ScrapBuilder> callback)
		{
			ScrapBuilder scrapBuilder = new ScrapBuilder(this);
			callback(scrapBuilder);
			_scrapInfo = scrapBuilder.Build();
			return this;
		}

		internal override DawnItemInfo Build()
		{
			return new DawnItemInfo(base.key, tags, base.value, _scrapInfo, _shopInfo, customData);
		}
	}
	public static class LethalContent
	{
		public static TaggedRegistry<DawnItemInfo> Items = new TaggedRegistry<DawnItemInfo>();

		public static TaggedRegistry<DawnEnemyInfo> Enemies = new TaggedRegistry<DawnEnemyInfo>();

		public static TaggedRegistry<DawnMapObjectInfo> MapObjects = new TaggedRegistry<DawnMapObjectInfo>();

		public static TaggedRegistry<DawnMoonInfo> Moons = new TaggedRegistry<DawnMoonInfo>();

		public static Registry<DawnTileSetInfo> TileSets = new Registry<DawnTileSetInfo>();

		public static TaggedRegistry<DawnDungeonInfo> Dungeons = new TaggedRegistry<DawnDungeonInfo>();

		public static TaggedRegistry<DawnUnlockableItemInfo> Unlockables = new TaggedRegistry<DawnUnlockableItemInfo>();

		public static TaggedRegistry<DawnWeatherEffectInfo> Weathers = new TaggedRegistry<DawnWeatherEffectInfo>();

		public static Registry<DawnArchetypeInfo> Archetypes = new Registry<DawnArchetypeInfo>();
	}
	public static class DawnLibTags
	{
		internal static readonly NamespacedKey IsExternal = NamespacedKey.From("dawn_lib", "is_external");
	}
	internal static class MapObjectRegistrationHandler
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static hook_SetPlanetsWeather <0>__UpdateMapObjectSpawnWeights;

			public static hook_SpawnOutsideHazards <1>__SpawnOutsideMapObjects;

			public static Manipulator <2>__RegenerateNavMeshTranspiler;

			public static hook_SpawnMapObjects <3>__UpdateMapObjectSpawnWeights;

			public static Action <4>__RegisterMapObjects;
		}

		private static int _spawnedObjects;

		internal static void Init()
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected O, but got Unknown
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Expected O, but got Unknown
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Expected O, but got Unknown
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Expected O, but got Unknown
			object obj = <>O.<0>__UpdateMapObjectSpawnWeights;
			if (obj == null)
			{
				hook_SetPlanetsWeather val = UpdateMapObjectSpawnWeights;
				<>O.<0>__UpdateMapObjectSpawnWeights = val;
				obj = (object)val;
			}
			StartOfRound.SetPlanetsWeather += (hook_SetPlanetsWeather)obj;
			object obj2 = <>O.<1>__SpawnOutsideMapObjects;
			if (obj2 == null)
			{
				hook_SpawnOutsideHazards val2 = SpawnOutsideMapObjects;
				<>O.<1>__SpawnOutsideMapObjects = val2;