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.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using System.Threading.Tasks;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using Dawn;
using Dawn.Interfaces;
using Dawn.Internal;
using Dawn.Utils;
using DunGen;
using DunGen.Graph;
using DunGenPlus;
using GameNetcodeStuff;
using GoodItemScan;
using HarmonyLib;
using IL;
using IL.GameNetcodeStuff;
using LethalConfig.AutoConfig;
using LethalConfig.ConfigItems;
using LethalLevelLoader;
using LethalLib.Modules;
using LethalQuantities.Objects;
using LethalQuantities.Patches;
using Microsoft.CodeAnalysis;
using Mono.Cecil;
using Mono.Cecil.Cil;
using MonoMod.Cil;
using MonoMod.RuntimeDetour;
using MrovLib.Events;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using On;
using On.BepInEx.Configuration;
using On.DunGen;
using On.GameNetcodeStuff;
using On.TMPro;
using On.Unity.Netcode;
using PathfindingLib.API.SmartPathfinding;
using Steamworks;
using Steamworks.Data;
using TMPro;
using TerminalFormatter.Nodes;
using Unity.Netcode;
using Unity.Netcode.Components;
using UnityEngine;
using UnityEngine.AI;
using UnityEngine.Audio;
using UnityEngine.Events;
using UnityEngine.InputSystem.Utilities;
using UnityEngine.Pool;
using UnityEngine.Rendering.HighDefinition;
using UnityEngine.SceneManagement;
using UnityEngine.Serialization;
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("DunGen")]
[assembly: IgnoresAccessChecksTo("DunGen.Integration.ASPP")]
[assembly: IgnoresAccessChecksTo("DunGen.Integration.UnityNav")]
[assembly: IgnoresAccessChecksTo("DunGenPlus")]
[assembly: IgnoresAccessChecksTo("EasyTextEffects")]
[assembly: IgnoresAccessChecksTo("Facepunch Transport for Netcode for GameObjects")]
[assembly: IgnoresAccessChecksTo("Facepunch.Steamworks.Win64")]
[assembly: IgnoresAccessChecksTo("GoodItemScan")]
[assembly: IgnoresAccessChecksTo("LethalConfig")]
[assembly: IgnoresAccessChecksTo("LethalLevelLoader")]
[assembly: IgnoresAccessChecksTo("LethalLib")]
[assembly: IgnoresAccessChecksTo("LethalQuantities")]
[assembly: IgnoresAccessChecksTo("MMHOOK_Assembly-CSharp")]
[assembly: IgnoresAccessChecksTo("MMHOOK_BepInEx")]
[assembly: IgnoresAccessChecksTo("MMHOOK_BepInEx.Preloader")]
[assembly: IgnoresAccessChecksTo("MMHOOK_DunGen")]
[assembly: IgnoresAccessChecksTo("MMHOOK_Unity.Netcode.Runtime")]
[assembly: IgnoresAccessChecksTo("MMHOOK_Unity.TextMeshPro")]
[assembly: IgnoresAccessChecksTo("MMHOOK_UnityEngine.CoreModule")]
[assembly: IgnoresAccessChecksTo("MrovLib")]
[assembly: IgnoresAccessChecksTo("StarlancerAI")]
[assembly: IgnoresAccessChecksTo("Unity.AI.Navigation")]
[assembly: IgnoresAccessChecksTo("Unity.Animation.Rigging")]
[assembly: IgnoresAccessChecksTo("Unity.Animation.Rigging.DocCodeExamples")]
[assembly: IgnoresAccessChecksTo("Unity.Burst")]
[assembly: IgnoresAccessChecksTo("Unity.Burst.Unsafe")]
[assembly: IgnoresAccessChecksTo("Unity.Collections")]
[assembly: IgnoresAccessChecksTo("Unity.Collections.LowLevel.ILSupport")]
[assembly: IgnoresAccessChecksTo("Unity.InputSystem")]
[assembly: IgnoresAccessChecksTo("Unity.InputSystem.ForUI")]
[assembly: IgnoresAccessChecksTo("Unity.Jobs")]
[assembly: IgnoresAccessChecksTo("Unity.Mathematics")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.Common")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.MetricTypes")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.NetStats")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.NetStatsMonitor.Component")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.NetStatsMonitor.Configuration")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.NetStatsMonitor.Implementation")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.NetStatsReporting")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.NetworkProfiler.Runtime")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.NetworkSolutionInterface")]
[assembly: IgnoresAccessChecksTo("Unity.Netcode.Components")]
[assembly: IgnoresAccessChecksTo("Unity.Netcode.Runtime")]
[assembly: IgnoresAccessChecksTo("Unity.Networking.Transport")]
[assembly: IgnoresAccessChecksTo("Unity.ProBuilder.Csg")]
[assembly: IgnoresAccessChecksTo("Unity.ProBuilder")]
[assembly: IgnoresAccessChecksTo("Unity.ProBuilder.KdTree")]
[assembly: IgnoresAccessChecksTo("Unity.ProBuilder.Poly2Tri")]
[assembly: IgnoresAccessChecksTo("Unity.ProBuilder.Stl")]
[assembly: IgnoresAccessChecksTo("Unity.Profiling.Core")]
[assembly: IgnoresAccessChecksTo("Unity.RenderPipelines.Core.Runtime")]
[assembly: IgnoresAccessChecksTo("Unity.RenderPipelines.Core.ShaderLibrary")]
[assembly: IgnoresAccessChecksTo("Unity.RenderPipelines.HighDefinition.Config.Runtime")]
[assembly: IgnoresAccessChecksTo("Unity.RenderPipelines.HighDefinition.Runtime")]
[assembly: IgnoresAccessChecksTo("Unity.RenderPipelines.ShaderGraph.ShaderGraphLibrary")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Authentication")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Analytics")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Components")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Configuration")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Device")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Environments")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Environments.Internal")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Internal")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Networking")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Registration")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Scheduler")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Telemetry")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Threading")]
[assembly: IgnoresAccessChecksTo("Unity.Services.QoS")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Relay")]
[assembly: IgnoresAccessChecksTo("Unity.TextMeshPro")]
[assembly: IgnoresAccessChecksTo("Unity.Timeline")]
[assembly: IgnoresAccessChecksTo("Unity.VisualEffectGraph.Runtime")]
[assembly: IgnoresAccessChecksTo("Unity.XR.CoreUtils")]
[assembly: IgnoresAccessChecksTo("Unity.XR.Management")]
[assembly: IgnoresAccessChecksTo("Unity.XR.OpenXR")]
[assembly: IgnoresAccessChecksTo("Unity.XR.OpenXR.Features.ConformanceAutomation")]
[assembly: IgnoresAccessChecksTo("Unity.XR.OpenXR.Features.MetaQuestSupport")]
[assembly: IgnoresAccessChecksTo("Unity.XR.OpenXR.Features.MockRuntime")]
[assembly: IgnoresAccessChecksTo("Unity.XR.OpenXR.Features.OculusQuestSupport")]
[assembly: IgnoresAccessChecksTo("Unity.XR.OpenXR.Features.RuntimeDebugger")]
[assembly: IgnoresAccessChecksTo("UnityEngine.ARModule")]
[assembly: IgnoresAccessChecksTo("UnityEngine.NVIDIAModule")]
[assembly: IgnoresAccessChecksTo("UnityEngine.SpatialTracking")]
[assembly: IgnoresAccessChecksTo("UnityEngine.UI")]
[assembly: IgnoresAccessChecksTo("UnityEngine.XR.LegacyInputHelpers")]
[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.9.21.0")]
[assembly: AssemblyInformationalVersion("0.9.21+78d07c774d74f29674974668e8e7aca2a1029d4a")]
[assembly: AssemblyProduct("DawnLib")]
[assembly: AssemblyTitle("com.github.teamxiaolan.dawnlib")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.9.21.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
[module: NetcodePatchedAssembly]
[CompilerGenerated]
internal sealed class <>z__ReadOnlyArray<T> : IEnumerable, ICollection, IList, IEnumerable<T>, IReadOnlyCollection<T>, IReadOnlyList<T>, ICollection<T>, IList<T>
{
	int ICollection.Count => _items.Length;

	bool ICollection.IsSynchronized => false;

	object ICollection.SyncRoot => this;

	object IList.this[int index]
	{
		get
		{
			return _items[index];
		}
		set
		{
			throw new NotSupportedException();
		}
	}

	bool IList.IsFixedSize => true;

	bool IList.IsReadOnly => true;

	int IReadOnlyCollection<T>.Count => _items.Length;

	T IReadOnlyList<T>.this[int index] => _items[index];

	int ICollection<T>.Count => _items.Length;

	bool ICollection<T>.IsReadOnly => true;

	T IList<T>.this[int index]
	{
		get
		{
			return _items[index];
		}
		set
		{
			throw new NotSupportedException();
		}
	}

	public <>z__ReadOnlyArray(T[] items)
	{
		_items = items;
	}

	IEnumerator IEnumerable.GetEnumerator()
	{
		return ((IEnumerable)_items).GetEnumerator();
	}

	void ICollection.CopyTo(Array array, int index)
	{
		((ICollection)_items).CopyTo(array, index);
	}

	int IList.Add(object value)
	{
		throw new NotSupportedException();
	}

	void IList.Clear()
	{
		throw new NotSupportedException();
	}

	bool IList.Contains(object value)
	{
		return ((IList)_items).Contains(value);
	}

	int IList.IndexOf(object value)
	{
		return ((IList)_items).IndexOf(value);
	}

	void IList.Insert(int index, object value)
	{
		throw new NotSupportedException();
	}

	void IList.Remove(object value)
	{
		throw new NotSupportedException();
	}

	void IList.RemoveAt(int index)
	{
		throw new NotSupportedException();
	}

	IEnumerator<T> IEnumerable<T>.GetEnumerator()
	{
		return ((IEnumerable<T>)_items).GetEnumerator();
	}

	void ICollection<T>.Add(T item)
	{
		throw new NotSupportedException();
	}

	void ICollection<T>.Clear()
	{
		throw new NotSupportedException();
	}

	bool ICollection<T>.Contains(T item)
	{
		return ((ICollection<T>)_items).Contains(item);
	}

	void ICollection<T>.CopyTo(T[] array, int arrayIndex)
	{
		((ICollection<T>)_items).CopyTo(array, arrayIndex);
	}

	bool ICollection<T>.Remove(T item)
	{
		throw new NotSupportedException();
	}

	int IList<T>.IndexOf(T item)
	{
		return ((IList<T>)_items).IndexOf(item);
	}

	void IList<T>.Insert(int index, T item)
	{
		throw new NotSupportedException();
	}

	void IList<T>.RemoveAt(int index)
	{
		throw new NotSupportedException();
	}
}
[CompilerGenerated]
internal sealed class <>z__ReadOnlySingleElementList<T> : IEnumerable, ICollection, IList, IEnumerable<T>, IReadOnlyCollection<T>, IReadOnlyList<T>, ICollection<T>, IList<T>
{
	private sealed class Enumerator : IDisposable, IEnumerator, IEnumerator<T>
	{
		object IEnumerator.Current => _item;

		T IEnumerator<T>.Current => _item;

		public Enumerator(T item)
		{
			_item = item;
		}

		bool IEnumerator.MoveNext()
		{
			if (!_moveNextCalled)
			{
				return _moveNextCalled = true;
			}
			return false;
		}

		void IEnumerator.Reset()
		{
			_moveNextCalled = false;
		}

		void IDisposable.Dispose()
		{
		}
	}

	int ICollection.Count => 1;

	bool ICollection.IsSynchronized => false;

	object ICollection.SyncRoot => this;

	object IList.this[int index]
	{
		get
		{
			if (index != 0)
			{
				throw new IndexOutOfRangeException();
			}
			return _item;
		}
		set
		{
			throw new NotSupportedException();
		}
	}

	bool IList.IsFixedSize => true;

	bool IList.IsReadOnly => true;

	int IReadOnlyCollection<T>.Count => 1;

	T IReadOnlyList<T>.this[int index]
	{
		get
		{
			if (index != 0)
			{
				throw new IndexOutOfRangeException();
			}
			return _item;
		}
	}

	int ICollection<T>.Count => 1;

	bool ICollection<T>.IsReadOnly => true;

	T IList<T>.this[int index]
	{
		get
		{
			if (index != 0)
			{
				throw new IndexOutOfRangeException();
			}
			return _item;
		}
		set
		{
			throw new NotSupportedException();
		}
	}

	public <>z__ReadOnlySingleElementList(T item)
	{
		_item = item;
	}

	IEnumerator IEnumerable.GetEnumerator()
	{
		return new Enumerator(_item);
	}

	void ICollection.CopyTo(Array array, int index)
	{
		array.SetValue(_item, index);
	}

	int IList.Add(object value)
	{
		throw new NotSupportedException();
	}

	void IList.Clear()
	{
		throw new NotSupportedException();
	}

	bool IList.Contains(object value)
	{
		return EqualityComparer<T>.Default.Equals(_item, (T)value);
	}

	int IList.IndexOf(object value)
	{
		if (!EqualityComparer<T>.Default.Equals(_item, (T)value))
		{
			return -1;
		}
		return 0;
	}

	void IList.Insert(int index, object value)
	{
		throw new NotSupportedException();
	}

	void IList.Remove(object value)
	{
		throw new NotSupportedException();
	}

	void IList.RemoveAt(int index)
	{
		throw new NotSupportedException();
	}

	IEnumerator<T> IEnumerable<T>.GetEnumerator()
	{
		return new Enumerator(_item);
	}

	void ICollection<T>.Add(T item)
	{
		throw new NotSupportedException();
	}

	void ICollection<T>.Clear()
	{
		throw new NotSupportedException();
	}

	bool ICollection<T>.Contains(T item)
	{
		return EqualityComparer<T>.Default.Equals(_item, item);
	}

	void ICollection<T>.CopyTo(T[] array, int arrayIndex)
	{
		array[arrayIndex] = _item;
	}

	bool ICollection<T>.Remove(T item)
	{
		throw new NotSupportedException();
	}

	int IList<T>.IndexOf(T item)
	{
		if (!EqualityComparer<T>.Default.Equals(_item, item))
		{
			return -1;
		}
		return 0;
	}

	void IList<T>.Insert(int index, T item)
	{
		throw new NotSupportedException();
	}

	void IList<T>.RemoveAt(int index)
	{
		throw new NotSupportedException();
	}
}
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
public sealed class Vector3Converter : JsonConverter<Vector3>
{
	public override void WriteJson(JsonWriter writer, Vector3 value, JsonSerializer serializer)
	{
		//IL_0012: Unknown result type (might be due to invalid IL or missing references)
		//IL_0029: Unknown result type (might be due to invalid IL or missing references)
		//IL_0040: Unknown result type (might be due to invalid IL or missing references)
		writer.WriteStartObject();
		writer.WritePropertyName("x");
		writer.WriteValue(value.x);
		writer.WritePropertyName("y");
		writer.WriteValue(value.y);
		writer.WritePropertyName("z");
		writer.WriteValue(value.z);
		writer.WriteEndObject();
	}

	public override Vector3 ReadJson(JsonReader reader, Type objectType, Vector3 existingValue, bool hasExistingValue, JsonSerializer serializer)
	{
		//IL_0013: Unknown result type (might be due to invalid IL or missing references)
		//IL_0019: Invalid comparison between Unknown and I4
		//IL_0020: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
		//IL_009c: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a3: Invalid comparison between Unknown and I4
		//IL_0027: Unknown result type (might be due to invalid IL or missing references)
		//IL_002d: Invalid comparison between Unknown and I4
		float num = 0f;
		float num2 = 0f;
		float num3 = 0f;
		if ((int)reader.TokenType != 1)
		{
			throw new JsonSerializationException("Expected StartObject for Vector3");
		}
		while (reader.Read() && (int)reader.TokenType != 13)
		{
			if ((int)reader.TokenType == 4)
			{
				string text = (string)reader.Value;
				reader.Read();
				switch (text)
				{
				case "x":
					num = Convert.ToSingle(reader.Value);
					break;
				case "y":
					num2 = Convert.ToSingle(reader.Value);
					break;
				case "z":
					num3 = Convert.ToSingle(reader.Value);
					break;
				}
			}
		}
		return new Vector3(num, num2, num3);
	}
}
public class DawnMapObjectNamespacedKeyContainer : MonoBehaviour
{
	[field: SerializeField]
	public NamespacedKey Value { get; internal set; }

	public DawnMapObjectInfo GetDawnMapObjectInfo()
	{
		return LethalContent.MapObjects[Value.AsTyped<DawnMapObjectInfo>()];
	}
}
public class DawnStoryLogNamespacedKeyContainer : MonoBehaviour
{
	[field: SerializeField]
	public NamespacedKey Value { get; internal set; }
}
namespace Dawn
{
	public abstract class BaseInfoBuilder
	{
		internal abstract void SoloAddTags(IEnumerable<NamespacedKey> newTags);
	}
	public abstract class BaseInfoBuilder<TInfo, T, TBuilder> : BaseInfoBuilder where TInfo : INamespaced<TInfo> where TBuilder : BaseInfoBuilder<TInfo, T, TBuilder>
	{
		protected HashSet<NamespacedKey> tags = new HashSet<NamespacedKey>();

		protected IDataContainer? customData;

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

		protected T value { get; private set; }

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

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

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

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

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

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

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

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

		public int Count => dictionary.Count;

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

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

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

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

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

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

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

		public virtual void MarkDirty()
		{
		}

		public virtual IDisposable CreateEditContext()
		{
			return new NoOpDisposable();
		}

		public bool Has<T>(NamespacedKey key)
		{
			if (dictionary.ContainsKey(key))
			{
				return dictionary[key] is T;
			}
			return false;
		}
	}
	public class FrozenEmptyDataContainer : IDataContainer
	{
		public static FrozenEmptyDataContainer Instance { get; private set; } = new FrozenEmptyDataContainer();


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


		public int Count => 0;

		private FrozenEmptyDataContainer()
		{
		}

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

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

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

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

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

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

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

		public IDisposable CreateEditContext()
		{
			throw new RegistryFrozenException();
		}

		public bool Has<T>(NamespacedKey key)
		{
			throw new NotImplementedException();
		}
	}
	public interface IDataContainer
	{
		IEnumerable<NamespacedKey> Keys { get; }

		int Count { get; }

		bool Has<T>(NamespacedKey key);

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

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

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

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

		void Remove(NamespacedKey key);

		void Clear();

		void MarkDirty();

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

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

		private static readonly Dictionary<string, NamespacedKey> CanonicalByFull = new Dictionary<string, NamespacedKey>(StringComparer.Ordinal);

		private static readonly Dictionary<string, NamespacedKey> CanonicalByKey = new Dictionary<string, NamespacedKey>(StringComparer.Ordinal);

		private static readonly Dictionary<string, List<NamespacedKey>> SmartPlaceholdersByKey = new Dictionary<string, List<NamespacedKey>>(StringComparer.Ordinal);

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

		public const string SmartMatchingNamespace = "smart_matching";

		[SerializeField]
		private string _namespace;

		[SerializeField]
		private string _key;

		public string Namespace => _namespace;

		public string Key => _key;

		public ulong NetworkID => ComputeStableHash64(ToString());

		private static void PromoteSmartPlaceholders(string key, string newNamespace)
		{
			if (!SmartPlaceholdersByKey.TryGetValue(key, out List<NamespacedKey> value) || value.Count == 0)
			{
				return;
			}
			foreach (NamespacedKey item in value)
			{
				if (item._namespace == "smart_matching")
				{
					Debuggers.NamespacedKeys?.Log($"Promoting placeholder {item} to {newNamespace}");
					item._namespace = newNamespace;
				}
			}
		}

		internal static string NormalizeStringForNamespacedKey(string input, bool CSharpName)
		{
			if (string.IsNullOrWhiteSpace(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(" ", string.Empty);
				text4 = text4.Replace("_", string.Empty);
				return text4.ToCapitalized();
			}
			return text4.ToLowerInvariant().Replace(" ", "_");
		}

		private static string BuildFullKey(string @namespace, string key)
		{
			return $"{@namespace}{':'}{key}";
		}

		private static bool ShouldReplaceCandidate(NamespacedKey existing, NamespacedKey candidate)
		{
			if (existing.Namespace == "smart_matching" && candidate.Namespace != "smart_matching")
			{
				return true;
			}
			if (candidate.Namespace == "lethal_company" && existing.Namespace != "lethal_company")
			{
				return true;
			}
			return false;
		}

		private static void Register(NamespacedKey key)
		{
			string key2 = BuildFullKey(key.Namespace, key.Key);
			CanonicalByFull.TryAdd(key2, key);
			NamespacedKey value2;
			if (key.Namespace == "smart_matching")
			{
				if (!SmartPlaceholdersByKey.TryGetValue(key.Key, out List<NamespacedKey> value))
				{
					value = new List<NamespacedKey>();
					SmartPlaceholdersByKey[key.Key] = value;
				}
				value.Add(key);
				if (!CanonicalByKey.ContainsKey(key.Key))
				{
					CanonicalByKey[key.Key] = key;
				}
			}
			else if (CanonicalByKey.TryGetValue(key.Key, out value2))
			{
				if (ShouldReplaceCandidate(value2, key))
				{
					CanonicalByKey[key.Key] = key;
					PromoteSmartPlaceholders(key.Key, key.Namespace);
				}
			}
			else
			{
				CanonicalByKey[key.Key] = key;
				PromoteSmartPlaceholders(key.Key, key.Namespace);
			}
		}

		private static bool TrySmartResolveByKey(string normalizedKey, [NotNullWhen(true)] out NamespacedKey? match)
		{
			match = null;
			if (CanonicalByKey.TryGetValue(normalizedKey, out NamespacedKey value))
			{
				match = value;
				return true;
			}
			return false;
		}

		protected NamespacedKey(string @namespace, string key)
		{
			_namespace = NormalizeStringForNamespacedKey(@namespace, CSharpName: false);
			_key = NormalizeStringForNamespacedKey(key, CSharpName: false);
			Register(this);
		}

		[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)
		{
			if (string.IsNullOrWhiteSpace(input))
			{
				throw new ArgumentException("Input cannot be null or empty.", "input");
			}
			string[] array = input.Split(':');
			if (array.Length != 2 || string.IsNullOrWhiteSpace(array[0]) || string.IsNullOrWhiteSpace(array[1]))
			{
				throw new FormatException($"Invalid namespaced key '{input}'. Expected 'namespace{':'}key'.");
			}
			return From(array[0], array[1]);
		}

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

		public static NamespacedKey ForceParse(string input)
		{
			return ForceParse(input, useSmartMatching: false);
		}

		public static NamespacedKey ForceParse(string input, bool useSmartMatching)
		{
			if (string.IsNullOrWhiteSpace(input))
			{
				throw new ArgumentException("Input cannot be null or empty.", "input");
			}
			string[] array = input.Split(':');
			if (array.Length == 2)
			{
				return From(array[0], array[1]);
			}
			string input2 = array[0];
			string text = NormalizeStringForNamespacedKey(input2, CSharpName: false);
			if (useSmartMatching)
			{
				if (TrySmartResolveByKey(text, out NamespacedKey match))
				{
					return match;
				}
				return From("smart_matching", text);
			}
			return From("lethal_company", text);
		}

		public override string ToString()
		{
			return BuildFullKey(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 (this == obj)
			{
				return true;
			}
			if (!(obj is NamespacedKey namespacedKey))
			{
				return false;
			}
			if (string.Equals(Namespace, namespacedKey.Namespace, StringComparison.Ordinal))
			{
				return string.Equals(Key, namespacedKey.Key, StringComparison.Ordinal);
			}
			return false;
		}

		private static ulong ComputeStableHash64(string value)
		{
			ulong num = 14695981039346656037uL;
			byte[] bytes = Encoding.UTF8.GetBytes(value);
			byte[] array = bytes;
			foreach (byte b in array)
			{
				num ^= b;
				num *= 1099511628211L;
			}
			return num;
		}

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

		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)
		{
			if (string.IsNullOrWhiteSpace(input))
			{
				throw new ArgumentException("Input cannot be null or empty.", "input");
			}
			string[] array = input.Split(':');
			if (array.Length != 2 || string.IsNullOrWhiteSpace(array[0]) || string.IsNullOrWhiteSpace(array[1]))
			{
				throw new FormatException($"Invalid namespaced key '{input}'. Expected 'namespace{':'}key'.");
			}
			return From(array[0], array[1]);
		}
	}
	public class NamespacedKeyConverter : JsonConverter
	{
		public override void WriteJson(JsonWriter writer, object? value, JsonSerializer serializer)
		{
			if (value is NamespacedKey namespacedKey)
			{
				writer.WriteValue(namespacedKey.ToString());
			}
			else
			{
				writer.WriteNull();
			}
		}

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

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

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

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

			private bool _prevAutoSave;

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

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

		private string _filePath;

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

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


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


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

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

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

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

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

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

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

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

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

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

		internal ChildPersistentDataContainer()
		{
		}

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

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

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

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

		private IDataContainer? _customData;

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

		public NamespacedKey Key => TypedKey;

		public NamespacedKey<T> TypedKey { get; }

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

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

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

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

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

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

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

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

		private static PersistentDataContainer? _profileContainer;

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

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

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

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

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

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

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

		public static DawnTerminalCommandInfo DefineTerminalCommand(NamespacedKey<DawnTerminalCommandInfo> key, TerminalCommandBasicInformation commandBasicInformation, Action<TerminalCommandInfoBuilder> callback)
		{
			TerminalCommandInfoBuilder terminalCommandInfoBuilder = new TerminalCommandInfoBuilder(key, commandBasicInformation);
			callback(terminalCommandInfoBuilder);
			DawnTerminalCommandInfo dawnTerminalCommandInfo = terminalCommandInfoBuilder.Build();
			LethalContent.TerminalCommands.Register(dawnTerminalCommandInfo);
			return dawnTerminalCommandInfo;
		}

		public static DawnSurfaceInfo DefineSurface(NamespacedKey<DawnSurfaceInfo> key, FootstepSurface surface, Action<SurfaceInfoBuilder> callback)
		{
			SurfaceInfoBuilder surfaceInfoBuilder = new SurfaceInfoBuilder(key, surface);
			callback(surfaceInfoBuilder);
			DawnSurfaceInfo dawnSurfaceInfo = surfaceInfoBuilder.Build();
			surface.SetDawnInfo(dawnSurfaceInfo);
			LethalContent.Surfaces.Register(dawnSurfaceInfo);
			return dawnSurfaceInfo;
		}

		public static DawnStoryLogInfo DefineStoryLog(NamespacedKey<DawnStoryLogInfo> key, GameObject storyLogGameObject, Action<StoryLogInfoBuilder> callback)
		{
			StoryLogInfoBuilder storyLogInfoBuilder = new StoryLogInfoBuilder(key, storyLogGameObject);
			callback(storyLogInfoBuilder);
			DawnStoryLogInfo dawnStoryLogInfo = storyLogInfoBuilder.Build();
			DawnStoryLogNamespacedKeyContainer dawnStoryLogNamespacedKeyContainer = storyLogGameObject.AddComponent<DawnStoryLogNamespacedKeyContainer>();
			dawnStoryLogNamespacedKeyContainer.Value = dawnStoryLogInfo.TypedKey;
			LethalContent.StoryLogs.Register(dawnStoryLogInfo);
			return dawnStoryLogInfo;
		}

		public static DawnDungeonInfo DefineDungeon(NamespacedKey<DawnDungeonInfo> key, string flowName, Action<DungeonFlowInfoBuilder> callback)
		{
			DungeonFlow val = ScriptableObject.CreateInstance<DungeonFlow>();
			((Object)val).name = flowName;
			DungeonFlowInfoBuilder dungeonFlowInfoBuilder = new DungeonFlowInfoBuilder(key, val);
			callback(dungeonFlowInfoBuilder);
			DawnDungeonInfo dawnDungeonInfo = dungeonFlowInfoBuilder.Build();
			val.SetDawnInfo(dawnDungeonInfo);
			LethalContent.Dungeons.Register(dawnDungeonInfo);
			return dawnDungeonInfo;
		}

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

		public static DawnMapObjectInfo DefineMapObject(NamespacedKey<DawnMapObjectInfo> key, GameObject mapObject, Action<MapObjectInfoBuilder> callback)
		{
			MapObjectInfoBuilder mapObjectInfoBuilder = new MapObjectInfoBuilder(key, mapObject);
			callback(mapObjectInfoBuilder);
			DawnMapObjectInfo dawnMapObjectInfo = mapObjectInfoBuilder.Build();
			IIndoorMapHazard val = default(IIndoorMapHazard);
			if (!mapObject.TryGetComponent<IIndoorMapHazard>(ref val))
			{
				DawnMapObjectNamespacedKeyContainer dawnMapObjectNamespacedKeyContainer = mapObject.AddComponent<DawnMapObjectNamespacedKeyContainer>();
				dawnMapObjectNamespacedKeyContainer.Value = dawnMapObjectInfo.Key;
			}
			if (dawnMapObjectInfo.InsideInfo != null)
			{
				dawnMapObjectInfo.InsideInfo.IndoorMapHazardType.SetDawnInfo(dawnMapObjectInfo);
			}
			if (dawnMapObjectInfo.OutsideInfo != null)
			{
				dawnMapObjectInfo.OutsideInfo.SpawnableOutsideObject.SetDawnInfo(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 DawnMoonInfo DefineMoon(NamespacedKey<DawnMoonInfo> key, SelectableLevel level, Action<MoonInfoBuilder> callback)
		{
			MoonInfoBuilder moonInfoBuilder = new MoonInfoBuilder(key, level);
			callback(moonInfoBuilder);
			DawnMoonInfo dawnMoonInfo = moonInfoBuilder.Build();
			level.SetDawnInfo(dawnMoonInfo);
			LethalContent.Moons.Register(dawnMoonInfo);
			return dawnMoonInfo;
		}

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

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

			public static Action<Action<RandomMapObject>, RandomMapObject> <1>__FixRandomMapObjects;

			public static Action <2>__AddDawnDungeonsToMoons;

			public static Action <3>__CollectNonDawnDungeons;

			public static hook_SetPlanetsWeather <4>__UpdateAllDungeonWeights;

			public static hook_EndOfGame <5>__UnloadDungeonBundleForAllPlayers;

			public static hook_Awake <6>__DeleteLLLTranspilerAndEnsureDelayedDungeon;

			public static hook_Awake <7>__RemoveHotloadingIfDebugDunGenPlus;

			public static Manipulator <8>__MakeExtraScrapGenerationMoreModular;

			public static Action <9>__CleanDawnDungeonReferences;

			public static hook_TeleportPlayer <10>__HandleStingerAudio;

			public static Manipulator <11>__DelayDungeonGeneration;

			public static Func<IEnumerator> <12>__LoadDungeonBundle;
		}

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

			public static hook_GenerateNewFloor <>9__0_0;

			public static hook_Start <>9__0_1;

			public static hook_Generate <>9__0_2;

			public static Func<Instruction, bool> <>9__2_0;

			public static Func<Instruction, bool> <>9__2_1;

			public static Func<Instruction, bool> <>9__2_2;

			public static Func<Instruction, bool> <>9__2_3;

			public static Func<Instruction, bool> <>9__2_4;

			public static Func<Instruction, bool> <>9__2_5;

			public static Func<Instruction, bool> <>9__2_6;

			public static Func<Instruction, bool> <>9__2_7;

			public static Func<Instruction, bool> <>9__9_0;

			public static Func<Instruction, bool> <>9__9_1;

			public static Func<Instruction, bool> <>9__9_2;

			public static Func<bool> <>9__11_0;

			public static Func<EntranceTeleport, bool> <>9__12_0;

			public static Func<GlobalPropSettings, bool> <>9__12_1;

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

			public static Func<bool> <>9__17_0;

			internal void <Init>b__0_0(orig_GenerateNewFloor orig, RoundManager self)
			{
				UpdateDungeonWeightOnLevel(self.currentLevel);
				orig.Invoke(self);
			}

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

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

			internal bool <MakeExtraScrapGenerationMoreModular>b__2_0(Instruction instr)
			{
				return ILPatternMatchingExt.MatchLdarg(instr, 0);
			}

			internal bool <MakeExtraScrapGenerationMoreModular>b__2_1(Instruction instr)
			{
				return ILPatternMatchingExt.MatchLdfld<RoundManager>(instr, "currentDungeonType");
			}

			internal bool <MakeExtraScrapGenerationMoreModular>b__2_2(Instruction instr)
			{
				return ILPatternMatchingExt.MatchLdcI4(instr, 4);
			}

			internal bool <MakeExtraScrapGenerationMoreModular>b__2_3(Instruction instr)
			{
				ILLabel val = default(ILLabel);
				return ILPatternMatchingExt.MatchBneUn(instr, ref val);
			}

			internal bool <MakeExtraScrapGenerationMoreModular>b__2_4(Instruction instr)
			{
				return ILPatternMatchingExt.MatchLdloc(instr, 1);
			}

			internal bool <MakeExtraScrapGenerationMoreModular>b__2_5(Instruction instr)
			{
				return ILPatternMatchingExt.MatchLdcI4(instr, 6);
			}

			internal bool <MakeExtraScrapGenerationMoreModular>b__2_6(Instruction instr)
			{
				return ILPatternMatchingExt.MatchAdd(instr);
			}

			internal bool <MakeExtraScrapGenerationMoreModular>b__2_7(Instruction instr)
			{
				return ILPatternMatchingExt.MatchStloc(instr, 1);
			}

			internal bool <DelayDungeonGeneration>b__9_0(Instruction i)
			{
				return ILPatternMatchingExt.MatchLdarg(i, 0);
			}

			internal bool <DelayDungeonGeneration>b__9_1(Instruction i)
			{
				return ILPatternMatchingExt.MatchLdfld<RoundManager>(i, "dungeonGenerator");
			}

			internal bool <DelayDungeonGeneration>b__9_2(Instruction i)
			{
				return ILPatternMatchingExt.MatchCallvirt<RuntimeDungeon>(i, "Generate");
			}

			internal bool <LoadDungeonBundle>b__11_0()
			{
				return NetworkSingleton<DawnDungeonNetworker>.Instance.allPlayersDone;
			}

			internal bool <AdjustFireExits>b__12_0(EntranceTeleport e)
			{
				return e.entranceId != 0;
			}

			internal bool <AdjustFireExits>b__12_1(GlobalPropSettings p)
			{
				return p.ID == DawnDungeonInfo.FireExitGlobalPropID;
			}

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

			internal bool <CollectNonDawnDungeons>b__17_0()
			{
				return true;
			}
		}

		[CompilerGenerated]
		private sealed class <LoadDungeonBundle>d__11 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			private DawnDungeonInfo <dungeonInfo>5__2;

			private IEnumerator <waitForLoad>5__3;

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

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

			[DebuggerHidden]
			public <LoadDungeonBundle>d__11(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<dungeonInfo>5__2 = null;
				<waitForLoad>5__3 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ed: Expected O, but got Unknown
				//IL_009c: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a6: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<dungeonInfo>5__2 = RoundManager.Instance.dungeonGenerator.Generator.DungeonFlow.GetDawnInfo();
					if (DungeonGenerationPlusCompat.Enabled && DungeonGenerationPlusCompat.IsDebugOn())
					{
						break;
					}
					if (!<dungeonInfo>5__2.ShouldSkipIgnoreOverride())
					{
						NetworkSingleton<DawnDungeonNetworker>.Instance.QueueDungeonBundleLoading(<dungeonInfo>5__2.Key);
						<waitForLoad>5__3 = (IEnumerator)new WaitUntil((Func<bool>)(() => NetworkSingleton<DawnDungeonNetworker>.Instance.allPlayersDone));
						goto IL_00c9;
					}
					goto IL_00dd;
				case 1:
					<>1__state = -1;
					goto IL_00c9;
				case 2:
					{
						<>1__state = -1;
						break;
					}
					IL_00dd:
					<>2__current = (object)new WaitForSeconds(0.1f);
					<>1__state = 2;
					return true;
					IL_00c9:
					if (<waitForLoad>5__3.MoveNext())
					{
						<>2__current = <waitForLoad>5__3.Current;
						<>1__state = 1;
						return true;
					}
					<waitForLoad>5__3 = null;
					goto IL_00dd;
				}
				if (LethalLevelLoaderCompat.Enabled && <dungeonInfo>5__2.ShouldSkipRespectOverride())
				{
					LethalLevelLoaderCompat.LetLLLHandleGeneration();
				}
				else
				{
					BoundedRange boundedRange = <dungeonInfo>5__2.DungeonClampRange;
					if (<dungeonInfo>5__2.DungeonClampRange.Min == 0f && <dungeonInfo>5__2.DungeonClampRange.Max == 0f)
					{
						boundedRange = new BoundedRange(0f, 999f);
					}
					RoundManager.Instance.dungeonGenerator.Generator.LengthMultiplier = Mathf.Clamp(RoundManager.Instance.dungeonGenerator.Generator.LengthMultiplier, boundedRange.Min, boundedRange.Max);
					RoundManager.Instance.dungeonGenerator.Generate();
				}
				return false;
			}

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

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

		[CompilerGenerated]
		private sealed class <UnloadDungeonBundleForAllPlayers>d__10 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public orig_EndOfGame orig;

			public StartOfRound self;

			public int bodiesInsured;

			public int connectedPlayersOnServer;

			public int scrapCollected;

			private IEnumerator <origIEnumerator>5__2;

			private IEnumerator <unloadIEnumerator>5__3;

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

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

			[DebuggerHidden]
			public <UnloadDungeonBundleForAllPlayers>d__10(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<origIEnumerator>5__2 = null;
				<unloadIEnumerator>5__3 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if (!DungeonGenerationPlusCompat.Enabled || !DungeonGenerationPlusCompat.IsDebugOn())
					{
						if ((Object)(object)NetworkSingleton<DawnDungeonNetworker>.Instance != (Object)null)
						{
							<unloadIEnumerator>5__3 = NetworkSingleton<DawnDungeonNetworker>.Instance.UnloadExisting();
							goto IL_007b;
						}
						if (!DawnConfig.VanillaCompatibility.Value)
						{
							DawnPlugin.Logger.LogError((object)"DawnDungeonNetworker is null, but VanillaCompatibility is false! This is a bug!");
						}
					}
					goto IL_00c6;
				case 1:
					<>1__state = -1;
					goto IL_007b;
				case 2:
					{
						<>1__state = -1;
						break;
					}
					IL_00c6:
					<origIEnumerator>5__2 = orig.Invoke(self, bodiesInsured, connectedPlayersOnServer, scrapCollected);
					break;
					IL_007b:
					if (<unloadIEnumerator>5__3.MoveNext())
					{
						<>2__current = <unloadIEnumerator>5__3.Current;
						<>1__state = 1;
						return true;
					}
					NetworkSingleton<DawnDungeonNetworker>.Instance.PlayerSetBundleStateRpc(GameNetworkManager.Instance.localPlayerController, DawnMoonNetworker.BundleState.Done);
					<unloadIEnumerator>5__3 = null;
					goto IL_00c6;
				}
				if (<origIEnumerator>5__2.MoveNext())
				{
					<>2__current = <origIEnumerator>5__2.Current;
					<>1__state = 2;
					return true;
				}
				return false;
			}

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

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

		private static bool _alreadyPatched = false;

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

		internal static void Init()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Expected O, but got Unknown
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Expected O, but got Unknown
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Expected O, but got Unknown
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Expected O, but got Unknown
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Expected O, but got Unknown
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Expected O, but got Unknown
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			//IL_012d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0133: Expected O, but got Unknown
			//IL_0148: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0153: Expected O, but got Unknown
			//IL_0168: Unknown result type (might be due to invalid IL or missing references)
			//IL_016d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0173: Expected O, but got Unknown
			//IL_018c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0191: Unknown result type (might be due to invalid IL or missing references)
			//IL_0197: Expected O, but got Unknown
			//IL_01d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dc: Expected O, but got Unknown
			//IL_01f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0200: Expected O, but got Unknown
			//IL_0219: Unknown result type (might be due to invalid IL or missing references)
			//IL_021e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0224: Expected O, but got Unknown
			DetourContext val = new DetourContext(int.MaxValue);
			try
			{
				object obj = <>O.<0>__RegisterDawnDungeons;
				if (obj == null)
				{
					hook_Awake val2 = RegisterDawnDungeons;
					<>O.<0>__RegisterDawnDungeons = val2;
					obj = (object)val2;
				}
				StartOfRound.Awake += (hook_Awake)obj;
			}
			finally
			{
				((IDisposable)val)?.Dispose();
			}
			DetourContext val3 = new DetourContext(200);
			try
			{
				DawnPlugin.Hooks.Add(new Hook((MethodBase)AccessTools.DeclaredMethod(typeof(RandomMapObject), "Awake", (Type[])null, (Type[])null), (Delegate)new Action<Action<RandomMapObject>, RandomMapObject>(FixRandomMapObjects)));
			}
			finally
			{
				((IDisposable)val3)?.Dispose();
			}
			LethalContent.Moons.OnFreeze += AddDawnDungeonsToMoons;
			LethalContent.Moons.OnFreeze += CollectNonDawnDungeons;
			object obj2 = <>O.<4>__UpdateAllDungeonWeights;
			if (obj2 == null)
			{
				hook_SetPlanetsWeather val4 = UpdateAllDungeonWeights;
				<>O.<4>__UpdateAllDungeonWeights = val4;
				obj2 = (object)val4;
			}
			StartOfRound.SetPlanetsWeather += (hook_SetPlanetsWeather)obj2;
			object obj3 = <>O.<5>__UnloadDungeonBundleForAllPlayers;
			if (obj3 == null)
			{
				hook_EndOfGame val5 = UnloadDungeonBundleForAllPlayers;
				<>O.<5>__UnloadDungeonBundleForAllPlayers = val5;
				obj3 = (object)val5;
			}
			StartOfRound.EndOfGame += (hook_EndOfGame)obj3;
			object obj4 = <>O.<6>__DeleteLLLTranspilerAndEnsureDelayedDungeon;
			if (obj4 == null)
			{
				hook_Awake val6 = DeleteLLLTranspilerAndEnsureDelayedDungeon;
				<>O.<6>__DeleteLLLTranspilerAndEnsureDelayedDungeon = val6;
				obj4 = (object)val6;
			}
			MenuManager.Awake += (hook_Awake)obj4;
			object obj5 = <>O.<7>__RemoveHotloadingIfDebugDunGenPlus;
			if (obj5 == null)
			{
				hook_Awake val7 = RemoveHotloadingIfDebugDunGenPlus;
				<>O.<7>__RemoveHotloadingIfDebugDunGenPlus = val7;
				obj5 = (object)val7;
			}
			MenuManager.Awake += (hook_Awake)obj5;
			object obj6 = <>O.<8>__MakeExtraScrapGenerationMoreModular;
			if (obj6 == null)
			{
				Manipulator val8 = MakeExtraScrapGenerationMoreModular;
				<>O.<8>__MakeExtraScrapGenerationMoreModular = val8;
				obj6 = (object)val8;
			}
			RoundManager.SpawnScrapInLevel += (Manipulator)obj6;
			object obj7 = <>c.<>9__0_0;
			if (obj7 == null)
			{
				hook_GenerateNewFloor val9 = delegate(orig_GenerateNewFloor orig, RoundManager self)
				{
					UpdateDungeonWeightOnLevel(self.currentLevel);
					orig.Invoke(self);
				};
				<>c.<>9__0_0 = val9;
				obj7 = (object)val9;
			}
			RoundManager.GenerateNewFloor += (hook_GenerateNewFloor)obj7;
			LethalContent.Dungeons.BeforeFreeze += CleanDawnDungeonReferences;
			object obj8 = <>O.<10>__HandleStingerAudio;
			if (obj8 == null)
			{
				hook_TeleportPlayer val10 = HandleStingerAudio;
				<>O.<10>__HandleStingerAudio = val10;
				obj8 = (object)val10;
			}
			EntranceTeleport.TeleportPlayer += (hook_TeleportPlayer)obj8;
			object obj9 = <>c.<>9__0_1;
			if (obj9 == null)
			{
				hook_Start val11 = delegate(orig_Start orig, RuntimeDungeon self)
				{
					self.GenerateOnStart = false;
					orig.Invoke(self);
				};
				<>c.<>9__0_1 = val11;
				obj9 = (object)val11;
			}
			RuntimeDungeon.Start += (hook_Start)obj9;
			object obj10 = <>c.<>9__0_2;
			if (obj10 == null)
			{
				hook_Generate val12 = delegate(orig_Generate orig, RuntimeDungeon self)
				{
					AdjustFireExits(self.Generator.DungeonFlow);
					TryInjectTileSets(self.Generator.DungeonFlow);
					orig.Invoke(self);
				};
				<>c.<>9__0_2 = val12;
				obj10 = (object)val12;
			}
			RuntimeDungeon.Generate += (hook_Generate)obj10;
		}

		private static void RemoveHotloadingIfDebugDunGenPlus(orig_Awake orig, MenuManager self)
		{
			if ((Object)(object)self.versionNumberText == (Object)null)
			{
				orig.Invoke(self);
				return;
			}
			if (DungeonGenerationPlusCompat.Enabled && DungeonGenerationPlusCompat.IsDebugOn() && !DungeonGenerationPlusCompat.RemovedHotloading)
			{
				DungeonGenerationPlusCompat.RemovedHotloading = true;
				foreach (DawnDungeonInfo value in LethalContent.Dungeons.Values)
				{
					if (!value.ShouldSkipIgnoreOverride())
					{
						AssetBundle val = AssetBundle.LoadFromFile(value.AssetBundlePath);
						DungeonFlow val2 = val.LoadAsset<DungeonFlow>(((Object)value.DungeonFlow).name ?? "");
						if ((Object)(object)val2 == (Object)null)
						{
							DawnPlugin.Logger.LogError((object)("Bundle: " + Path.GetFileName(value.AssetBundlePath) + " does not contain DungeonFlow: " + ((Object)value.DungeonFlow).name + "."));
							return;
						}
						DawnDungeonNetworker.TryApplyLoadedDungeonFlow(val2, val);
					}
				}
			}
			orig.Invoke(self);
		}

		private static void MakeExtraScrapGenerationMoreModular(ILContext il)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			//IL_014b: Unknown result type (might be due to invalid IL or missing references)
			//IL_016d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0179: Unknown result type (might be due to invalid IL or missing references)
			ILCursor val = new ILCursor(il);
			ILLabel val2 = default(ILLabel);
			if (!val.TryGotoNext((MoveType)0, new Func<Instruction, bool>[8]
			{
				(Instruction instr) => ILPatternMatchingExt.MatchLdarg(instr, 0),
				(Instruction instr) => ILPatternMatchingExt.MatchLdfld<RoundManager>(instr, "currentDungeonType"),
				(Instruction instr) => ILPatternMatchingExt.MatchLdcI4(instr, 4),
				(Instruction instr) => ILPatternMatchingExt.MatchBneUn(instr, ref val2),
				(Instruction instr) => ILPatternMatchingExt.MatchLdloc(instr, 1),
				(Instruction instr) => ILPatternMatchingExt.MatchLdcI4(instr, 6),
				(Instruction instr) => ILPatternMatchingExt.MatchAdd(instr),
				(Instruction instr) => ILPatternMatchingExt.MatchStloc(instr, 1)
			}))
			{
				DawnPlugin.Logger.LogWarning((object)"Failed to find IL for RoundManager.SpawnScrapInLevel (MakeExtraScrapGenerationMoreModular).");
				return;
			}
			val.RemoveRange(8);
			val.Emit(OpCodes.Ldloc_1);
			val.Emit(OpCodes.Call, (MethodBase)AccessTools.DeclaredMethod(typeof(DungeonRegistrationHandler), "GetExtraScrapForCurrentlyLoadedInterior", (Type[])null, (Type[])null));
			val.Emit(OpCodes.Add);
			val.Emit(OpCodes.Stloc_1);
		}

		private static int GetExtraScrapForCurrentlyLoadedInterior()
		{
			return (RoundManager.Instance.dungeonGenerator?.Generator?.DungeonFlow?.GetDawnInfo())?.ExtraScrapGeneration ?? 0;
		}

		private static void HandleStingerAudio(orig_TeleportPlayer orig, EntranceTeleport self)
		{
			if (!self.checkedForFirstTime)
			{
				self.checkedForFirstTime = true;
				DawnDungeonInfo dawnDungeonInfo = RoundManager.Instance.dungeonGenerator?.Generator?.DungeonFlow.GetDawnInfo();
				if (dawnDungeonInfo == null || (Object)(object)dawnDungeonInfo.StingerDetail.FirstTimeAudio == (Object)null)
				{
					orig.Invoke(self);
					return;
				}
				if (!dawnDungeonInfo.StingerDetail.AllowStingerToPlay.Provide())
				{
					orig.Invoke(self);
					return;
				}
				if (!dawnDungeonInfo.CustomData.TryGet<bool>(DawnKeys.StingerPlayed, out var value))
				{
					DawnPlugin.Logger.LogError((object)$"Failed to get {DawnKeys.StingerPlayed} from dungeon: {dawnDungeonInfo.Key}.");
					orig.Invoke(self);
					return;
				}
				if (value && !dawnDungeonInfo.StingerDetail.PlaysMoreThanOnce)
				{
					orig.Invoke(self);
					return;
				}
				float num = Random.Range(0f, 100f);
				if (num > dawnDungeonInfo.StingerDetail.PlayChance)
				{
					orig.Invoke(self);
					return;
				}
				Debuggers.Dungeons?.Log($"Playing dungeon stinger for dungeon {dawnDungeonInfo.Key}, alreadyPlayed: {value} (Chance Roll: {num} <= {dawnDungeonInfo.StingerDetail.PlayChance})");
				dawnDungeonInfo.CustomData.Set(DawnKeys.StingerPlayed, value: true);
				((MonoBehaviour)self).StartCoroutine(self.playMusicOnDelay());
			}
			orig.Invoke(self);
		}

		private static void FixRandomMapObjects(Action<RandomMapObject> orig, RandomMapObject self)
		{
			foreach (DawnMapObjectInfo value in LethalContent.MapObjects.Values)
			{
				for (int i = 0; i < self.spawnablePrefabs.Count; i++)
				{
					if (!((Object)(object)self.spawnablePrefabs[i] == (Object)null))
					{
						GameObject mapObjectPrefab = value.GetMapObjectPrefab();
						if (!((Object)(object)mapObjectPrefab == (Object)null) && ((Object)self.spawnablePrefabs[i]).name.Equals(((Object)mapObjectPrefab).name, StringComparison.OrdinalIgnoreCase))
						{
							self.spawnablePrefabs[i] = mapObjectPrefab;
							break;
						}
					}
				}
			}
			orig.Invoke(self);
		}

		private static void DeleteLLLTranspilerAndEnsureDelayedDungeon(orig_Awake orig, MenuManager self)
		{
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Expected O, but got Unknown
			orig.Invoke(self);
			if (!_alreadyPatched)
			{
				if (LethalLevelLoaderCompat.Enabled)
				{
					DawnPlugin.Logger.LogDebug((object)"Removing LethalLevelLoader dungeon generation transpiler.");
					LethalLevelLoaderCompat.TryRemoveLLLDungeonTranspiler();
					LethalLevelLoaderCompat.ScrewWithLLLDynamicDungeonRarity();
				}
				object obj = <>O.<11>__DelayDungeonGeneration;
				if (obj == null)
				{
					Manipulator val = DelayDungeonGeneration;
					<>O.<11>__DelayDungeonGeneration = val;
					obj = (object)val;
				}
				RoundManager.GenerateNewFloor += (Manipulator)obj;
				_alreadyPatched = true;
			}
		}

		private static void CleanDawnDungeonReferences()
		{
			foreach (DawnDungeonInfo value in LethalContent.Dungeons.Values)
			{
				if (!value.ShouldSkipIgnoreOverride())
				{
					List<DungeonArchetype> list = value.DungeonFlow.GetUsedArchetypes().Distinct().ToList();
					List<TileSet> list2 = value.DungeonFlow.GetUsedTileSets().Distinct().ToList();
					value.DungeonFlow.Nodes.Clear();
					value.DungeonFlow.Lines.Clear();
					for (int num = list.Count - 1; num >= 0; num--)
					{
						Object.Destroy((Object)(object)list[num]);
					}
					for (int num2 = list2.Count - 1; num2 >= 0; num2--)
					{
						Object.Destroy((Object)(object)list2[num2]);
					}
				}
			}
		}

		private static void DelayDungeonGeneration(ILContext il)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			ILCursor val = new ILCursor(il);
			if (val.TryGotoNext((MoveType)0, new Func<Instruction, bool>[3]
			{
				(Instruction i) => ILPatternMatchingExt.MatchLdarg(i, 0),
				(Instruction i) => ILPatternMatchingExt.MatchLdfld<RoundManager>(i, "dungeonGenerator"),
				(Instruction i) => ILPatternMatchingExt.MatchCallvirt<RuntimeDungeon>(i, "Generate")
			}))
			{
				val.RemoveRange(3);
				val.Emit(OpCodes.Ldarg_0);
				val.EmitDelegate<Func<IEnumerator>>((Func<IEnumerator>)LoadDungeonBundle);
				MethodInfo method = typeof(MonoBehaviour).GetMethod("StartCoroutine", new Type[1] { typeof(IEnumerator) });
				val.Emit(OpCodes.Callvirt, (MethodBase)method);
				val.Emit(OpCodes.Pop);
			}
			else
			{
				DawnPlugin.Logger.LogError((object)"Failed to apply DawnLib dungeon generation delay patch!");
				DawnPlugin.Logger.LogError((object)"IL code:");
				DawnPlugin.Logger.LogError((object)((object)il).ToString());
			}
		}

		[IteratorStateMachine(typeof(<UnloadDungeonBundleForAllPlayers>d__10))]
		private static IEnumerator UnloadDungeonBundleForAllPlayers(orig_EndOfGame orig, StartOfRound self, int bodiesInsured, int connectedPlayersOnServer, int scrapCollected)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <UnloadDungeonBundleForAllPlayers>d__10(0)
			{
				orig = orig,
				self = self,
				bodiesInsured = bodiesInsured,
				connectedPlayersOnServer = connectedPlayersOnServer,
				scrapCollected = scrapCollected
			};
		}

		[IteratorStateMachine(typeof(<LoadDungeonBundle>d__11))]
		private static IEnumerator LoadDungeonBundle()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <LoadDungeonBundle>d__11(0);
		}

		private static void AdjustFireExits(DungeonFlow dungeonFlow)
		{
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Expected O, but got Unknown
			EntranceTeleport[] array = (from e in Object.FindObjectsByType<EntranceTeleport>((FindObjectsInactive)0, (FindObjectsSortMode)0)
				where e.entranceId != 0
				select e).ToArray();
			for (int i = 0; i < array.Length; i++)
			{
				EntranceTeleport val = array[i];
				val.entranceId = i + 1;
			}
			foreach (GlobalPropSettings item in dungeonFlow.GlobalProps.Where((GlobalPropSettings p) => p.ID == DawnDungeonInfo.FireExitGlobalPropID))
			{
				item.Count = new IntRange(array.Length, array.Length);
			}
		}

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

		internal static void UpdateDungeonWeightOnLevel(SelectableLevel level)
		{
			if (!LethalContent.Weathers.IsFrozen || !LethalContent.Dungeons.IsFrozen || (Object)(object)StartOfRound.Instance == (Object)null || (WeatherRegistryCompat.Enabled && !WeatherRegistryCompat.IsWeatherManagerReady()))
			{
				return;
			}
			IntWithRarity[] dungeonFlowTypes = level.dungeonFlowTypes;
			foreach (IntWithRarity val in dungeonFlowTypes)
			{
				DawnDungeonInfo dawnInfo = RoundManagerRefs.Instance.dungeonFlowTypes[val.id].dungeonFlow.GetDawnInfo();
				if (!dawnInfo.ShouldSkipRespectOverride())
				{
					SpawnWeightContext ctx = new SpawnWeightContext(level.GetDawnInfo(), null, TimeOfDayRefs.GetCurrentWeatherEffect(level)?.GetDawnInfo()).WithExtra(SpawnWeightExtraKeys.RoutingPriceKey, level.GetDawnInfo().DawnPurchaseInfo.Cost.Provide());
					int valueOrDefault = (dawnInfo.Weights?.GetFor(in ctx)).GetValueOrDefault();
					val.rarity = valueOrDefault.Clamp0();
				}
			}
		}

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

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

		private static void CollectNonDawnDungeons()
		{
			Dictionary<string, WeightTableBuilder<DawnMoonInfo, SpawnWeightContext>> dictionary = new Dictionary<string, WeightTableBuilder<DawnMoonInfo, SpawnWeightContext>>();
			foreach (DawnMoonInfo value3 in LethalContent.Moons.Values)
			{
				SelectableLevel level = value3.Level;
				List<IntWithRarity> list = level.dungeonFlowTypes.ToList();
				if (LethalLevelLoaderCompat.Enabled)
				{
					list.AddRange(LethalLevelLoaderCompat.GetCustomDungeonsWithRarities(level));
				}
				foreach (IntWithRarity item in list)
				{
					DungeonFlow dungeonFlow = RoundManagerRefs.Instance.dungeonFlowTypes[item.id].dungeonFlow;
					if (!dictionary.TryGetValue(((Object)dungeonFlow).name, out var value))
					{
						value = new WeightTableBuilder<DawnMoonInfo, SpawnWeightContext>();
						dictionary[((Object)dungeonFlow).name] = value;
					}
					Debuggers.Dungeons?.Log($"Grabbing weight {item.rarity} to {((Object)dungeonFlow).name} on level {level.PlanetName}");
					value.AddWeight(value3.TypedKey, item.rarity);
				}
			}
			IndoorMapType[] dungeonFlowTypes = RoundManagerRefs.Instance.dungeonFlowTypes;
			foreach (IndoorMapType val in dungeonFlowTypes)
			{
				if (val == null || (Object)(object)val.dungeonFlow == (Object)null || val.dungeonFlow.HasDawnInfo())
				{
					continue;
				}
				string name = FormatFlowName(val.dungeonFlow);
				NamespacedKey<DawnDungeonInfo> namespacedKey = DungeonKeys.GetByReflection(name);
				BoundedRange dungeonClampRange = new BoundedRange(0f, 999f);
				if (namespacedKey == null && LethalLevelLoaderCompat.Enabled && LethalLevelLoaderCompat.TryGetExtendedDungeonModName(val.dungeonFlow, out string modName))
				{
					namespacedKey = NamespacedKey<DawnDungeonInfo>.From(modName, ((Object)val.dungeonFlow).name);
					dungeonClampRange = LethalLevelLoaderCompat.GetDungeonClamp(val.dungeonFlow);
				}
				else if (namespacedKey == null)
				{
					namespacedKey = NamespacedKey<DawnDungeonInfo>.From("unknown_modded", ((Object)val.dungeonFlow).name);
				}
				if (LethalContent.Dungeons.ContainsKey(namespacedKey))
				{
					Debuggers.Dungeons?.Log($"LethalContent.Dungeons already contains {namespacedKey}");
					val.dungeonFlow.SetDawnInfo(LethalContent.Dungeons[namespacedKey]);
					continue;
				}
				HashSet<NamespacedKey> tags = new HashSet<NamespacedKey> { DawnLibTags.IsExternal };
				CollectLLLTags(val.dungeonFlow, tags);
				dictionary.TryGetValue(((Object)val.dungeonFlow).name, out var value2);
				if (value2 == null)
				{
					value2 = new WeightTableBuilder<DawnMoonInfo, SpawnWeightContext>();
				}
				PersistentDataContainer persistentDataContainer = new PersistentDataContainer(Path.Combine(PersistentDataHandler.RootPath, "dungeon_" + namespacedKey.Namespace + "_" + namespacedKey.Key));
				if (!persistentDataContainer.Has(DawnKeys.StingerPlayed))
				{
					persistentDataContainer.Set(DawnKeys.StingerPlayed, value: false);
				}
				DawnStingerDetail stingerDetail = new DawnStingerDetail(val.firstTimeAudio, playsMoreThanOnce: false, 100f, new FuncProvider<bool>(() => true));
				int extraScrapGeneration = 0;
				if (namespacedKey == DungeonKeys.MineshaftFlow)
				{
					extraScrapGeneration = 6;
				}
				DawnDungeonInfo dawnDungeonInfo = new DawnDungeonInfo(namespacedKey, tags, val.dungeonFlow, value2.Build(), val.MapTileSize, stingerDetail, string.Empty, dungeonClampRange, extraScrapGeneration, persistentDataContainer);
				val.dungeonFlow.SetDawnInfo(dawnDungeonInfo);
				LethalContent.Dungeons.Register(dawnDungeonInfo);
			}
			CollectArchetypesAndTileSets();
			LethalContent.Dungeons.Freeze();
		}

		private static void CollectArchetypesAndTileSets()
		{
			foreach (DawnDungeonInfo value in LethalContent.Dungeons.Values)
			{
				DungeonArchetype[] usedArchetypes = value.DungeonFlow.GetUsedArchetypes();
				foreach (DungeonArchetype val in usedArchetypes)
				{
					Debuggers.Dungeons?.Log("dungeonArchetype.name: " + ((Object)val).name);
					NamespacedKey<DawnArchetypeInfo> namespacedKey;
					if (value.Key.IsVanilla())
					{
						string text = FormatArchetypeName(val);
						namespacedKey = DungeonArchetypeKeys.GetByReflection(text);
						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, archetype has formatted name: {text}!");
							continue;
						}
					}
					else
					{
						namespacedKey = NamespacedKey<DawnArchetypeInfo>.From(value.Key.Namespace, ((Object)val).name);
					}
					if (LethalContent.Archetypes.ContainsKey(namespacedKey))
					{
						Debuggers.Dungeons?.Log($"LethalContent.Archetypes already contains {namespacedKey}");
						val.SetDawnInfo(LethalContent.Archetypes[namespacedKey]);
						continue;
					}
					HashSet<NamespacedKey> hashSet = new HashSet<NamespacedKey>();
					if (value.HasTag(DawnLibTags.IsExternal))
					{
						hashSet.Add(DawnLibTags.IsExternal);
					}
					DawnArchetypeInfo dawnArchetypeInfo = new DawnArchetypeInfo(namespacedKey, hashSet, val, null);
					val.SetDawnInfo(dawnArchetypeInfo);
					dawnArchetypeInfo.ParentInfo = value;
					LethalContent.Archetypes.Register(dawnArchetypeInfo);
					List<TileSet> tileSets = val.TileSets;
					List<TileSet> branchCapTileSets = val.BranchCapTileSets;
					List<TileSet> list = new List<TileSet>(tileSets.Count + branchCapTileSets.Count);
					list.AddRange(tileSets);
					list.AddRange(branchCapTileSets);
					List<TileSet> list2 = list;
					foreach (TileSet item in list2)
					{
						Debuggers.Dungeons?.Log("tileSet.name: " + ((Object)item).name);
						NamespacedKey<DawnTileSetInfo> namespacedKey2;
						if (value.Key.IsVanilla())
						{
							string text2 = FormatTileSetName(item);
							namespacedKey2 = DungeonTileSetKeys.GetByReflection(text2);
							if (namespacedKey2 == null)
							{
								DawnPlugin.Logger.LogWarning((object)$"tileset: '{((Object)item).name}' (part of {namespacedKey}) is vanilla, but DawnLib couldn't get a corresponding NamespacedKey, tileset has formatted name: {text2}!");
								continue;
							}
						}
						else
						{
							namespacedKey2 = NamespacedKey<DawnTileSetInfo>.From(value.Key.Namespace, ((Object)item).name);
						}
						if (LethalContent.TileSets.ContainsKey(namespacedKey2))
						{
							Debuggers.Dungeons?.Log($"LethalContent.TileSets already contains {namespacedKey2}");
							item.SetDawnInfo(LethalContent.TileSets[namespacedKey2]);
							continue;
						}
						HashSet<NamespacedKey> hashSet2 = new HashSet<NamespacedKey>();
						if (value.HasTag(DawnLibTags.IsExternal))
						{
							hashSet2.Add(DawnLibTags.IsExternal);
						}
						DawnTileSetInfo dawnTileSetInfo = new DawnTileSetInfo(namespacedKey2, hashSet2, ConstantPredicate.True, item, val.BranchCapTileSets.Contains(item), val.TileSets.Contains(item), null);
						dawnArchetypeInfo.AddTileSet(dawnTileSetInfo);
						item.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)
		{
			string text = input;
			foreach (KeyValuePair<string, string> internalToHumanDungeonName in _internalToHumanDungeonNames)
			{
				internalToHumanDungeonName.Deconstruct(out var key, out var value);
				string oldValue = key;
				string newValue = value;
				text = text.Replace(oldValue, newValue);
			}
			return text;
		}

		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);
			}
		}

		private static void TryInjectTileSets(DungeonFlow dungeonFlow)
		{
			DungeonArchetype[] usedArchetypes = dungeonFlow.GetUsedArchetypes();
			foreach (DungeonArchetype val in usedArchetypes)
			{
				if ((Object)(object)val == (Object)null)
				{
					Debuggers.Dungeons?.Log("Archetype is null in dungeonflow: " + ((Object)dungeonFlow).name);
					continue;
				}
				Debuggers.Dungeons?.Log("Injecting tile sets for " + ((Object)val).name);
				foreach (DawnTileSetInfo tileSet in val.GetDawnInfo().TileSets)
				{
					if (tileSet.ShouldSkipIgnoreOverride())
					{
						continue;
					}
					val.BranchCapTileSets.Remove(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>
	{
		internal List<DoorwaySocket> sockets = new List<DoorwaySocket>();

		internal List<Doorway> doorways = new List<Doorway>();

		internal List<SpawnSyncedObject> spawnSyncedObjects = new List<SpawnSyncedObject>();

		internal List<Tile> tiles = new List<Tile>();

		public static int FireExitGlobalPropID = 1231;

		public DungeonFlow DungeonFlow { get; }

		public string AssetBundlePath { get; }

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

		public float MapTileSize { get; private set; }

		public DawnStingerDetail StingerDetail { get; private set; }

		public BoundedRange DungeonClampRange { get; private set; }

		public int ExtraScrapGeneration { get; private set; }

		public IReadOnlyList<Tile> Tiles => tiles.AsReadOnly();

		public IReadOnlyList<Doorway> Doorways => doorways.AsReadOnly();

		public IReadOnlyList<SpawnSyncedObject> SpawnSyncedObjects => spawnSyncedObjects.AsReadOnly();

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

		internal DawnDungeonInfo(NamespacedKey<DawnDungeonInfo> key, HashSet<NamespacedKey> tags, DungeonFlow dungeonFlow, ProviderTable<int?, DawnMoonInfo, SpawnWeightContext> weights, float mapTileSize, DawnStingerDetail stingerDetail, string assetBundlePath, BoundedRange dungeonClampRange, int extraScrapGeneration, IDataContainer? customData)
			: base(key, tags, customData)
		{
			DungeonFlow = dungeonFlow;
			Weights = weights;
			MapTileSize = mapTileSize;
			StingerDetail = stingerDetail;
			AssetBundlePath = assetBundlePath;
			DungeonClampRange = dungeonClampRange;
			ExtraScrapGeneration = extraScrapGeneration;
			if (!ShouldSkipIgnoreOverride())
			{
				return;
			}
			sockets = new List<DoorwaySocket>();
			List<TileSet> list = new List<TileSet>();
			TileSet[] usedTileSets = DungeonFlow.GetUsedTileSets();
			foreach (TileSet val in usedTileSets)
			{
				if ((Object)(object)val == (Object)null)
				{
					DawnPlugin.Logger.LogWarning((object)("TileSet is null in dungeonflow: " + ((Object)DungeonFlow).name));
				}
				else if (!list.Contains(val))
				{
					list.Add(val);
				}
			}
			foreach (TileInjectionRule tileInjectionRule in DungeonFlow.TileInjectionRules)
			{
				if ((Object)(object)tileInjectionRule.TileSet == (Object)null)
				{
					DawnPlugin.Logger.LogWarning((object)"TileSet is null in a tileInjectionRule");
				}
				else if (!list.Contains(tileInjectionRule.TileSet))
				{
					list.Add(tileInjectionRule.TileSet);
				}
			}
			foreach (TileSet item in list)
			{
				foreach (GameObjectChance weight in item.TileWeights.Weights)
				{
					if ((Object)(object)weight.Value == (Object)null)
					{
						DawnPlugin.Logger.LogWarning((object)("GameObject is null in tileSet: " + ((Object)item).name));
						continue;
					}
					Tile[] componentsInChildren = weight.Value.GetComponentsInChildren<Tile>();
					foreach (Tile val2 in componentsInChildren)
					{
						if ((Object)(object)val2 == (Object)null)
						{
							DawnPlugin.Logger.LogWarning((object)("Tile is null in tileSet: " + ((Object)item).name));
						}
						else if (!tiles.Contains(val2))
						{
							tiles.Add(val2);
						}
					}
				}
			}
			doorways = new List<Doorway>();
			spawnSyncedObjects = new List<SpawnSyncedObject>();
			foreach (Tile tile in Tiles)
			{
				Doorway[] componentsInChildren2 = ((Component)tile).gameObject.GetComponentsInChildren<Doorway>();
				foreach (Doorway val3 in componentsInChildren2)
				{
					if (!Doorways.Contains(val3))
					{
						doorways.Add(val3);
					}
					if (!Sockets.Contains(val3.socket))
					{
						if ((Object)(object)val3.socket == (Object)null)
						{
							DawnPlugin.Logger.LogWarning((object)("DungeonFlow: " + ((Object)DungeonFlow).name + " has a null socket in doorway: " + ((Object)val3).name + " from Tile: " + ((Object)tile).name));
							continue;
						}
						sockets.Add(val3.socket);
					}
					foreach (GameObjectWeight connectorPrefabWeight in val3.ConnectorPrefabWeights)
					{
						SpawnSyncedObject[] componentsInChildren3 = connectorPrefabWeight.GameObject.GetComponentsInChildren<SpawnSyncedObject>();
						foreach (SpawnSyncedObject val4 in componentsInChildren3)
						{
							if (!SpawnSyncedObjects.Contains(val4))
							{
								spawnSyncedObjects.Add(val4);
							}
						}
					}
					foreach (GameObjectWeight blockerPrefabWeight in val3.BlockerPrefabWeights)
					{
						SpawnSyncedObject[] componentsInChildren4 = blockerPrefabWeight.GameObject.GetComponentsInChildren<SpawnSyncedObject>();
						foreach (SpawnSyncedObject val5 in componentsInChildren4)
						{
							if (!SpawnSyncedObjects.Contains(val5))
							{
								spawnSyncedObjects.Add(val5);
							}
						}
					}
				}
				SpawnSyncedObject[] componentsInChildren5 = ((Component)tile).gameObject.GetComponentsInChildren<SpawnSyncedObject>();
				foreach (SpawnSyncedObject val6 in componentsInChildren5)
				{
					if (!SpawnSyncedObjects.Contains(val6))
					{
						spawnSyncedObjects.Add(val6);
					}
				}
			}
		}
	}
	public class DawnStingerDetail
	{
		public AudioClip? FirstTimeAudio { get; private set; }

		public bool PlaysMoreThanOnce { get; private set; }

		public float PlayChance { get; private set; }

		public FuncProvider<bool> AllowStingerToPlay { get; private set; }

		public DawnStingerDetail(AudioClip? firstTimeAudio, bool playsMoreThanOnce, float playChance, FuncProvider<bool> allowStingerToPlay)
		{
			FirstTimeAudio = firstTimeAudio;
			PlaysMoreThanOnce = playsMoreThanOnce;
			PlayChance = playChance;
			AllowStingerToPlay = allowStingerToPlay;
			base..ctor();
		}
	}
	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;
		}

		public static bool TryGetDawnInfo(this DungeonFlow dungeonFlow, [NotNullWhen(true)] out DawnDungeonInfo? dungeonInfo)
		{
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			dungeonInfo = (DawnDungeonInfo)((IDawnObject)dungeonFlow).DawnInfo;
			return dungeonInfo != null;
		}

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

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

		private AudioClip? _firstTimeAudio;

		private ProviderTable<int?, DawnMoonInfo, SpawnWeightContext> _weights;

		private string _assetBundlePath = string.Empty;

		private BoundedRange _dungeonRangeClamp = new BoundedRange(0f, 999f);

		private bool _stingerPlaysMoreThanOnce;

		private float _stingerPlayChance = 100f;

		private FuncProvider<bool> _allowStingerToPlay = new FuncProvider<bool>(() => true);

		private int _extraScrapGeneration;

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

		public DungeonFlowInfoBuilder SetArchetypeTileSetMapping(string archetypeName, IEnumerable<string> tileSetNames)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			GraphLine val = new GraphLine(base.value);
			base.value.Lines.Add(val);
			TileSet[] array = base.value.GetUsedTileSets() ?? Array.Empty<TileSet>();
			Dictionary<string, TileSet> dictionary = new Dictionary<string, TileSet>(StringComparer.Ordinal);
			TileSet[] array2 = array;
			foreach (TileSet val2 in array2)
			{
				if (!dictionary.ContainsKey(((Object)val2).name))
				{
					dictionary.Add(((Object)val2).name, val2);
				}
			}
			List<TileSet> list = new List<TileSet>();
			foreach (string tileSetName in tileSetNames)
			{
				string name = tileSetName.Trim();
				if (!dictionary.TryGetValue(name, out var val3))
				{
					val3 = ScriptableObject.CreateInstance<TileSet>();
					((Object)val3).name = name;
					dictionary.Add(name, val3);
				}
				if (!list.Contains(val3))
				{
					list.Add(val3);
				}
			}
			DungeonArchetype val4 = null;
			DungeonArchetype[] usedArchetypes = base.value.GetUsedArchetypes();
			if (usedArchetypes != null)
			{
				DungeonArchetype[] array3 = usedArchetypes;
				foreach (DungeonArchetype val5 in array3)
				{
					if (!((Object)(object)val5 == (Object)null) && string.Equals(((Object)val5).name, archetypeName, StringComparison.Ordinal))
					{
						val4 = val5;
						break;
					}
				}
			}
			if ((Object)(object)val4 == (Object)null)
			{
				val4 = ScriptableObject.CreateInstance<DungeonArchetype>();
				((Object)val4).name = archetypeName;
			}
			if (val4.TileSets == null)
			{
				val4.TileSets = new List<TileSet>();
			}
			else
			{
				val4.TileSets.Clear();
			}
			val4.TileSets.AddRange(list);
			if (val.DungeonArchetypes == null)
			{
				val.DungeonArchetypes = new List<DungeonArchetype>();
			}
			else
			{
				val.DungeonArchetypes.Clear();
			}
			val.DungeonArchetypes.Add(val4);
			return this;
		}

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

		public DungeonFlowInfoBuilder SetExtraScrapGeneration(int extraScrapGeneration)
		{
			_extraScrapGeneration = extraScrapGeneration;
			return this;
		}

		public DungeonFlowInfoBuilder SetAssetBundlePath(string assetBundlePath)
		{
			_assetBundlePath = assetBundlePath;
			return this;
		}

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

		public DungeonFlowInfoBuilder OverrideStingerPlaysMoreThanOnce(bool stingerPlaysMoreThanOnce)
		{
			_stingerPlaysMoreThanOnce = stingerPlaysMoreThanOnce;
			return this;
		}

		public DungeonFlowInfoBuilder OverrideStingerPlayChance(float stingerPlayChance)
		{
			_stingerPlayChance = stingerPlayChance;
			return this;
		}

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

		public DungeonFlowInfoBuilder SetDungeonRangeClamp(BoundedRange dungeonRangeClamp)
		{
			_dungeonRangeClamp = dungeonRangeClamp;
			return this;
		}

		public DungeonFlowInfoBuilder OverrideAllowStingerToPlay(FuncProvider<bool> allowStingerToPlay)
		{
			_allowStingerToPlay = allowStingerToPlay;
			return this;
		}

		internal override DawnDungeonInfo Build()
		{
			if (_weights == null)
			{
				DawnPlugin.Logger.LogWarning((object)$"DungeonFlow '{base.key}' didn't set weights. If you intend to have no weights (doing something special), call .SetWeights(() => {{}})");
				_weights = ProviderTable<int?, DawnMoonInfo, SpawnWeightContext>.Empty();
			}
			DawnStingerDetail stingerDetail = new DawnStingerDetail(_firstTimeAudio, _stingerPlaysMoreThanOnce, _stingerPlayChance, _allowStingerToPlay);
			return new DawnDungeonInfo(base.key, new HashSet<NamespacedKey>(), base.value, _weights, _mapTileSize, stingerDetail, _assetBundlePath, _dungeonRangeClamp, _extraScrapGeneration, customData);
		}
	}
	public static class TileSetExtensions
	{
		public static DawnTileSetInfo GetDawnInfo(this TileSet tileSet)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			return (DawnTileSetInfo)((IDawnObject)tileSet).DawnInfo;
		}

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

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

		private bool _regular = true;

		private IPredicate? _predicate;

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

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

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

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

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

			public static hook_AssignRandomEnemyToVent <1>__CheckIfEnemyCanSpawn;

			public static hook_SetPlanetsWeather <2>__UpdateEnemyWeights;

			public static hook_Start <3>__EnsureCorrectEnemyVariables;

			public static hook_Start <4>__AddEnemiesToDebugList;

			public static Manipulator <5>__StopDawnEnemyResetting;

			public static hook_Awake <6>__AddBestiaryNodes;

			public static hook_Start <7>__CollectAllEnemyTypes;

			public static Action <8>__RegisterEnemies;

			public static Action <9>__RedoEnemiesDebugMenu;

			public static Action <10>__FixDawnEnemyReferences;

			public static Func<EnemyType, bool> <11>__DawnLibHandledEnemy;
		}

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

		internal static void Init()
		{
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Expected O, but got Unknown
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Expected O, but got Unknown
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Expected O, but got Unknown
			//IL_0130: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: Expected O, but got Unknown
			//IL_0150: Unknown result type (might be due to invalid IL or missing references)
			//IL_0155: Unknown result type (might be due to invalid IL or missing references)
			//IL_015b: Expected O, but got Unknown
			//IL_0170: Unknown result type (might be due to invalid IL or missing references)
			//IL_0175: Unknown result type (might be due to invalid IL or missing references)
			//IL_017b: Expected O, but got Unknown
			//IL_0190: Unknown result type (might be due to invalid IL or missing references)
			//IL_0195: Unknown result type (might be due to invalid IL or missing references)
			//IL_019b: Expected O, but got Unknown
			//IL_01b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bb: Expected O, but got Unknown
			//IL_01d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01db: Expected O, but got Unknown
			//IL_0205: Unknown result type (might be due to invalid IL or missing references)
			//IL_020b: Expected O, but got Unknown
			//IL_01f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fb: Expected O, but got Unknown
			//IL_021b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0220: Unknown result type (might be due to invalid IL or missing references)
			//IL_0226: Expected O, but got Unknown
			//IL_023b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0240: Unknown result type (might be due to invalid IL or missing references)
			//IL_0246: 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>__CheckIfEnemyCanSpawn;
			if (obj2 == null)
			{
				hook_AssignRandomEnemyToVent val2 = CheckIfEnemyCanSpawn;
				<>O.<1>__CheckIfEnemyCanSpawn = val2;
				obj2 = (object)val2;
			}
			RoundManager.AssignRandomEnemyToVent += (hook_AssignRandomEnemyToVent)obj2;
			object obj3 = <>O.<2>__UpdateEnemyWeights;
			if (obj3 == null)
			{
				hook_SetPlanetsWeather val3 = UpdateEnemyWeights;
				<>O.<2>__UpdateEnemyWeights = val3;
				obj3 = (object)val3;
			}
			StartOfRound.SetPlanetsWeather += (hook_SetPlanetsWeather)obj3;
			object obj4 = <>O.<3>__EnsureCorrectEnemyVariables;
			if (obj4 == null)
			{
				hook_Start val4 = EnsureCorrectEnemyVariables;
				<>O.<3>__EnsureCorrectEnemyVariables = val4;
				obj4 = (object)val4;
			}
			EnemyAI.Start += (hook_Start)obj4;
			object obj5 = <>O.<4>__AddEnemiesToDebugList;
			if (obj5 == null)
			{
				hook_Start val5 = AddEnemiesToDebugList;
				<>O.<4>__AddEnemiesToDebugList = val5;
				obj5 = (object)val5;
			}
			QuickMenuManager.Start += (hook_Start)obj5;
			object obj6 = <>O.<5>__StopDawnEnemyResetting;
			if (obj6 == null)
			{
				Manipulator val6 = StopDawnEnemyResetting;
				<>O.<5>__StopDawnEnemyResetting = val6;
				obj6 = (object)val6;
			}
			RoundManager.SpawnRandomDaytimeEnemy += (Manipulator)obj6;
			object obj7 = <>O.<5>__StopDawnEnemyResetting;
			if (obj7 == null)
			{
				Manipulator val7 = StopDawnEnemyResetting;
				<>O.<5>__StopDawnEnemyResetting = val7;
				obj7 = (object)val7;
			}
			RoundManager.AssignRandomEnemyToVent += (Manipulator)obj7;
			object obj8 = <>O.<5>__StopDawnEnemyResetting;
			if (obj8 == null)
			{
				Manipulator val8 = StopDawnEnemyResetting;
				<>O.<5>__StopDawnEnemyResetting = val8;
				obj8 = (object)val8;
			}
			RoundManager.SpawnRandomOutsideEnemy += (Manipulator)obj8;
			object obj9 = <>O.<5>__StopDawnEnemyResetting;
			if (obj9 == null)
			{
				Manipulator val9 = StopDawnEnemyResetting;
				<>O.<5>__StopDawnEnemyResetting = val9;
				obj9 = (object)val9;
			}
			RoundManager.SpawnRandomWeedEnemy += (Manipulator)obj9;
			object obj10 = <>O.<5>__StopDawnEnemyResetting;
			if (obj10 == null)
			{
				Manipulator val10 = StopDawnEnemyResetting;
				<>O.<5>__StopDawnEnemyResetting = val10;
				obj10 = (object)val10;
			}
			RoundManager.PredictAllOutsideEnemies += (Manipulator)obj10;
			DetourContext val11 = new DetourContext(int.MaxValue);
			try
			{
				object obj11 = <>O.<6>__AddBestiaryNodes;
				if (obj11 == null)
				{
					hook_Awake val12 = AddBestiaryNodes;
					<>O.<6>__AddBestiaryNodes = val12;
					obj11 = (object)val12;
				}
				Terminal.Awake += (hook_Awake)obj11;
				object obj12 = <>O.<7>__CollectAllEnemyTypes;
				if (obj12 == null)
				{
					hook_Start val13 = CollectAllEnemyTypes;
					<>O.<7>__CollectAllEnemyTypes = val13;
					obj12 = (object)val13;
				}
				GameNetworkManager.Start += (hook_Start)obj12;
			}
			finally
			{
				((IDisposable)val11)?.Dispose();
			}
			LethalContent.Moons.OnFreeze += RegisterEnemies;
			LethalContent.Enemies.OnFreeze += RedoEnemiesDebugMenu;
			LethalContent.Enemies.OnFreeze += FixDawnEnemyReferences;
		}

		private static void StopDawnEnemyResetting(ILContext il)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Expected O, but got Unknown
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0233: Unknown result type (might be due to invalid IL or missing references)
			ILCursor val = new ILCursor(il);
			int firstEnemyTypeLoc = -1;
			ILLabel firstSkip = null;
			if (!val.TryGotoNext((MoveType)2, new Func<Instruction, bool>[2]
			{
				(Instruction c) => ILPatternMatchingExt.MatchLdfld<SpawnableEnemyWithRarity>(c, "enemyType"),
				(Instruction c) => ILPatternMatchingExt.MatchStloc(c, ref firstEnemyTypeLoc)
			}))
			{
				DawnPlugin.Logger.LogError((object)("Failed to apply " + ((MemberReference)il.Method).Name + " patch (0)!"));
				return;
			}
			if (!val.TryGotoNext((MoveType)2, new Func<Instruction, bool>[1]
			{
				(Instruction c) => ILPatternMatchingExt.MatchBrfalse(c, ref firstSkip)
			}))
			{
				DawnPlugin.Logger.LogError((object)("Failed to apply " + ((MemberReference)il.Method).Name + " patch (1)!"));
				return;
			}
			val.Emit(OpCodes.Ldloc, firstEnemyTypeLoc);
			val.EmitDelegate<Func<EnemyType, bool>>((Func<EnemyType, bool>)DawnLibHandledEnemy);
			val.Emit(OpCodes.Brfalse_S, (object)firstSkip);
			if (!((MemberReference)il.Method).Name.Contains("PredictAllOutsideEnemies") && !((MemberReference)il.Method).Name.Contains("SpawnRandomWeedEnemy"))
			{
				int secondEnemyTypeLoc = -1;
				ILLabel secondSkip = null;
				FieldReference val2 = default(FieldReference);
				if (!val.TryGotoNext((MoveType)2, new Func<Instruction, bool>[5]
				{
					(Instruction c) => ILPatternMatchingExt.MatchLdfld<SpawnableEnemyWithRarity>(c, "enemyType"),
					(Instruction c) => ILPatternMatchingExt.MatchStloc(c, ref secondEnemyTypeLoc),
					(Instruction c) => ILPatternMatchingExt.MatchLdarg(c, 0),
					(Instruction c) => ILPatternMatchingExt.MatchLdfld(c, ref val2),
					(Instruction c) => ILPatternMatchingExt.MatchBrfalse(c, ref secondSkip)
				}))
				{
					DawnPlugin.Logger.LogError((object)("Failed to apply " + ((MemberReference)il.Method).Name + " patch (2)!"));
					return;
				}
				val.Emit(OpCodes.Ldloc, secondEnemyTypeLoc);
				val.EmitDelegate<Func<EnemyType, bool>>((Func<EnemyType, bool>)DawnLibHandledEnemy);
				val.Emit(OpCodes.Brfalse_S, (object)secondSkip);
			}
		}

		private static bool DawnLibHandledEnemy(EnemyType enemyType)
		{
			return enemyType.GetDawnInfo()?.ShouldSkipRespectOverride() ?? true;
		}

		private static void FixDawnEnemyReferences()
		{
			CadaverGrowthAI component = LethalContent.Enemies[EnemyKeys.CadaverGrowths].EnemyType.enemyPrefab.GetComponent<CadaverGrowthAI>();
			GameObject faceSporesPrefab = component.faceSporesPrefab;
			GameObject cadaverSporesParticle = component.CadaverSporesParticle;
			CadaverGrowthAI val = default(CadaverGrowthAI);
			foreach (DawnEnemyInfo value in LethalContent.Enemies.Values)
			{
				if (!value.ShouldSkipIgnoreOverride() && value.EnemyType.enemyPrefab.TryGetComponent<CadaverGrowthAI>(ref val))
				{
					val.faceSporesPrefab = faceSporesPrefab;
					val.CadaverSporesParticle = cadaverSporesParticle;
				}
			}
		}

		private static bool CheckIfEnemyCanSpawn(orig_AssignRandomEnemyToVent orig, RoundManager self, EnemyVent vent, float spawnTime)
		{
			if (self.enemyRushIndex == -1)
			{
				return orig.Invoke(self, vent, spawnTime);
			}
			List<EnemyType> list = new List<EnemyType>();
			foreach (EnemyType item in self.currentLevel.Enemies.Select((SpawnableEnemyWithRarity def) => def.enemyType))
			{
				if (!item.HasDawnInfo())
				{
					continue;
				}
				DawnEnemyInfo dawnInfo = item.GetDawnInfo();
				if (!dawnInfo.ShouldSkipRespectOverride() && !dawnInfo.EnemyType.spawningDisabled && dawnInfo.Inside != null)
				{
					SpawnWeightContext ctx = new SpawnWeightContext(self.currentLevel.GetDawnInfo(), self.dungeonGenerator.Generator.DungeonFlow.GetDawnInfo(), TimeOfDayRefs.GetCurrentWeatherEffect(self.currentLevel)?.GetDawnInfo()).WithExtra(SpawnWeightExtraKeys.RoutingPriceKey, self.currentLevel.GetDawnInfo().DawnPurchaseInfo.Cost.Provide());
					if (!(dawnInfo.Inside.Weights.GetFor(in ctx) > 0))
					{
						item.spawningDisabled = true;
						list.Add(item);
					}
				}
			}
			orig.Invoke(self, vent, spawnTime);
			foreach (EnemyType item2 in list)
			{
				item2.spawningDisabled = false;
			}
			return true;
		}

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

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

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

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

		private static void AddEnemiesToDebugList(orig_Start orig, QuickMenuManager self)
		{
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Expected O, but got Unknown
			SelectableLevel level = LethalContent.Moons[MoonKeys.Test].Level;
			foreach (DawnEnemyInfo enemyInfo in LethalContent.Enemies.Values)
			{
				if (!enemyInfo.ShouldSkipIgnoreOverride())
				{
					SpawnableEnemyWithRarity item = new SpawnableEnemyWithRarity(enemyInfo.EnemyType, 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_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_0136: Unknown result type (might be due to invalid IL or missing references)
			//IL_0141: Unknown result type (might be due to invalid IL or missing references)
			if (!self.enemyType.HasDawnInfo())
			{
				DawnPlugin.Logger.LogError((object)("Enemy with names " + ((Object)self.enemyType).name + " and " + self.enemyType.enemyName + " has no DawnEnemyInfo, this means this enemy is not properly registered."));
				orig.Invoke(self);
				return;
			}
			DawnEnemyInfo dawnInfo = self.enemyType.GetDawnInfo();
			if (dawnInfo.ShouldSkipRespectOverride() || StarlancerAIFixCompat.Enabled)
			{
				orig.Invoke(self);
				return;
			}
			bool isDaytimeEnemy = self.enemyType.isDaytimeEnemy;
			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)
				{
					if (!((Object)(object)val == (Object)null))
					{
						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)
				{
					if (!((Object)(object)val2 == (Object)null))
					{
						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 (isDaytimeEnemy != self.enemyType.isDaytimeEnemy)
			{
				self.enemyType.isDaytimeEnemy = isDaytimeEnemy;
			}
			if (isOutsideEnemy != self.enemyType.isOutsideEnemy)
			{
				self.enemyType.isOutsideEnemy = isOutsideEnemy;
			}
		}

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

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

		internal static void UpdateEnemyWeightsOnLevel(SelectableLevel level)
		{
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Expected O, but got Unknown
			//IL_01b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bf: Expected O, but got Unknown
			//IL_0283: Unknown result type (might be due to invalid IL or missing references)
			//IL_028a: Expected O, but got Unknown
			if (!LethalContent.Weathers.IsFrozen || !LethalContent.Enemies.IsFrozen || (Object)(object)StartOfRound.Instance == (Object)null || (WeatherRegistryCompat.Enabled && !WeatherRegistryCompat.IsWeatherManagerReady()))
			{
				return;
			}
			DungeonFlow val = RoundManager.Instance.dungeonGenerator?.Generator?.DungeonFlow;
			foreach (DawnEnemyInfo enemyInfo in LethalContent.Enemies.Values)
			{
				if (enemyInfo.ShouldSkipRespectOverride())
				{
					continue;
				}
				Debuggers.Enemies?.Log($"Updating weights for {enemyInfo.EnemyType} on level {level.PlanetName}");
				if (enemyInfo.Outside != null)
				{
					SpawnableEnemyWithRarity val2 = ((IEnumerable<SpawnableEnemyWithRarity>)level.OutsideEnemies).FirstOrDefault((Func<SpawnableEnemyWithRarity, bool>)((SpawnableEnemyWithRarity x) => (Object)(object)x.enemyType == (Object)(object)enemyInfo.EnemyType));
					if (val2 == null)
					{
						val2 = new SpawnableEnemyWithRarity(enemyInfo.EnemyType, 0);
						level.OutsideEnemies.Add(val2);
					}
					SpawnWeightContext ctx = new SpawnWeightContext(level.GetDawnInfo(), val?.GetDawnInfo(), TimeOfDayRefs.GetCurrentWeatherEffect(level)?.GetDawnInfo()).WithExtra(SpawnWeightExtraKeys.RoutingPriceKey, level.GetDawnInfo().DawnPurchaseInfo.Cost.Provide());
					int valueOrDefault = enemyInfo.Outside.Weights.GetFor(in ctx).GetValueOrDefault();
					val2.rarity = valueOrDefault.Clamp0();
				}
				if (enemyInfo.Inside != null)
				{
					SpawnableEnemyWithRarity val3 = ((IEnumerable<SpawnableEnemyWithRarity>)level.Enemies).FirstOrDefault((Func<SpawnableEnemyWithRarity, bool>)((SpawnableEnemyWithRarity x) => (Object)(object)x.enemyType == (Object)(object)enemyInfo.EnemyType));
					if (val3 == null)
					{
						val3 = new SpawnableEnemyWithRarity(enemyInfo.EnemyType, 0);
						level.Enemies.Add(val3);
					}
					SpawnWeightContext ctx2 = new SpawnWeightContext(level.GetDawnInfo(), val?.GetDawnInfo(), TimeOfDayRefs.GetCurrentWeatherEffect(level)?.GetDawnInfo()).WithExtra(SpawnWeightExtraKeys.RoutingPriceKey, level.GetDawnInfo().DawnPurchaseInfo.Cost.Provide());
					int valueOrDefault2 = enemyInfo.Inside.Weights.GetFor(in ctx2).GetValueOrDefault();
					val3.rarity = valueOrDefault2.Clamp0();
				}
				if (enemyInfo.Daytime != null)
				{
					SpawnableEnemyWithRarity val4 = ((IEnumerable<SpawnableEnemyWithRarity>)level.DaytimeEnemies).FirstOrDefault((Func<SpawnableEnemyWithRarity, bool>)((SpawnableEnemyWithRarity x) => (Object)(object)x.enemyType == (Object)(object)enemyInfo.EnemyType));
					if (val4 == null)
					{
						val4 = new SpawnableEnemyWithRarity(enemyInfo.EnemyType, 0);
						level.DaytimeEnemies.Add(val4);
					}
					SpawnWeightContext ctx3 = new SpawnWeightContext(level.GetDawnInfo(), val?.GetDawnInfo(), TimeOfDayRefs.GetCurrentWeatherEffect(level)?.GetDawnInfo()).WithExtra(SpawnWeightExtraKeys.RoutingPriceKey, level.GetDawnInfo().DawnPurchaseInfo.Cost.Provide());
					int valueOrDefault3 = enemyInfo.Daytime.Weights.GetFor(in ctx3).GetValueOrDefault();
					val4.rarity = valueOrDefault3.Clamp0();
				}
			}
		}

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

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

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

			private T <>2__current;

			private int <>l__initialThreadId;

			public DawnEnemyInfo <>4__this;

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

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

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

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

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

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

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

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

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

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

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

		public EnemyType EnemyType { get; }

		public DawnEnemyLocationInfo? Outside { get; private set; }

		public DawnEnemyLocationInfo? Inside { get; private set; }

		public DawnEnemyLocationInfo? Daytime { get; private set; }

		public TerminalNode? BestiaryNode { get; }

		public TerminalKeyword? NameKeyword { get; }

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

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

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

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

			private EnemyInfoBuilder _parent;

			public EnemyLocationBuilder SetWeights(Action<WeightTableBuilder<DawnMoonInfo, SpawnWeightContext>> callback)
			{
				WeightTableBuilder<DawnMoonInfo, SpawnWeightContext> weightTableBuilder = new WeightTableBuilder<DawnMoonInfo, SpawnWeightContext>();
				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, SpawnWeightContext>.Empty();
				}
				return new DawnEnemyLocationInfo(_weights);
			}
		}

		private DawnEnemyLocationInfo? _inside;

		private DawnEnemyLocationInfo? _outside;

		private DawnEnemyLocationInfo? _daytime;

		private TerminalNode? _bestiaryNode;

		private TerminalKeyword? _nameKeyword;

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

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

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

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

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

		public EnemyInfoBuilder CreateNameKeyword(string wordOverride)
		{
			if (string.IsNullOrWhiteSpace(wordOverride))
			{
				wordOverride = base.value.enemyName.ToLowerInvariant();
			}
			_nameKeyword = new TerminalKeywordBuilder(base.value.enemyName + "NameKeyword", wordOverride, (DawnKeywordType)6).Build();
			return this;
		}

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

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

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

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

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

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

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

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

		private bool _value;

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

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

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

		public T Provide()
		{
			return <value>P;
		}
	}
	public class ConfigEntryProvider<T> : IProvider<T>
	{
		[CompilerGenerated]
		private ConfigEntry<T> <configEntry>P;

		public ConfigEntryProvider(ConfigEntry<T> configEntry)
		{
			<configEntry>P = configEntry;
			base..ctor();
		}

		public T Provide()
		{
			return <configEntry>P.Value;
		}
	}
	public class FuncProvider<T> : IProvider<T>
	{
		[CompilerGenerated]
		private Func<T> <function>P;

		public FuncProvider(Func<T> function)
		{
			<function>P = function;
			base..ctor();
		}

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

			public static hook_Awake <1>__RegisterShopItemsToTerminal;

			public static hook_SpawnScrapInLevel <2>__UpdateItemWeights;

			public static hook_SetPlanetsWeather <3>__UpdateItemWeights;

			public static Action <4>__FreezeItemContent;

			public static Action <5>__RedoItemsDebugMenu;
		}

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

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

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

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

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

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

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

		internal static void UpdateItemWeightsOnLevel(SelectableLevel level)
		{
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Expected O, but got Unknown
			if (!LethalContent.Weathers.IsFrozen || !LethalContent.Items.IsFrozen || (Object)(object)StartOfRound.Instance == (Object)null || (WeatherRegistryCompat.Enabled && !WeatherRegistryCompat.IsWeatherManagerReady()))
			{
				return;
			}
			foreach (DawnItemInfo itemInfo in LethalContent.Items.Values)
			{
				DawnScrapItemInfo scrapInfo = itemInfo.ScrapInfo;
				if (scrapInfo != null && !itemInfo.ShouldSkipRespectOverride())
				{
					Debuggers.Items?.Log("Updating " + itemInfo.Item.itemName + "'s weights on level " + level.PlanetName + ".");
					SpawnableItemWithRarity val = ((IEnumerable<SpawnableItemWithRarity>)level.spawnableScrap).FirstOrDefault((Func<SpawnableItemWithRarity, bool>)((SpawnableItemWithRarity x) => (Object)(object)x.spawnableItem == (Object)(object)itemInfo.Item));
					if (val == null)
					{
						val = new SpawnableItemWithRarity(itemInfo.Item, 0);
						level.spawnableScrap.Add(val);
					}
					SpawnWeightContext ctx = new SpawnWeightContext(level.GetDawnInfo(), RoundManager.Instance.dungeonGenerator?.Generator?.DungeonFlow?.GetDawnInfo(), TimeOfDayRefs.GetCurrentWeatherEffect(level)?.GetDawnInfo()).WithExtra(SpawnWeightExtraKeys.RoutingPriceKey, level.GetDawnInfo().DawnPurchaseInfo.Cost.Provide());
					int valueOrDefault = scrapInfo.Weights.GetFor(in ctx).GetValueOrDefault();
					val.rarity = valueOrDefault.Clamp0();
				}
			}
		}

		private static void FreezeItemContent()
		{
			//IL_03e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_03eb: Expected O, but got Unknown
			Dictionary<string, WeightTableBuilder<DawnMoonInfo, SpawnWeightContext>> dictionary = new Dictionary<string, WeightTableBuilder<DawnMoonInfo, SpawnWeightContext>>();
			Dictionary<string, DawnShopItemInfo> dictionary2 = new Dictionary<string, DawnShopItemInfo>();
			foreach (DawnMoonInfo value5 in LethalContent.Moons.Values)
			{
				SelectableLevel level = value5.Level;
				Dictionary<Item, SpawnableItemWithRarity> dictionary3 = new Dictionary<Item, SpawnableItemWithRarity>();
				for (int num = level.spawnableScrap.Count - 1; num >= 0; num--)
				{
					SpawnableItemWithRarity val = level.spawnableScrap[num];
					if (dictionary3.ContainsKey(val.spawnableItem))
					{
						DawnPlugin.Logger.LogWarning((object)("Duplicate item found in level " + level.PlanetName + " with name " + ((Object)val.spawnableItem).name + ", adding weight to previous entry to avoid issues."));
						level.spawnableScrap.Remove(val);
						SpawnableItemWithRarity obj = dictionary3[val.spawnableItem];
						obj.rarity += val.rarity;
					}
					else
					{
						dictionary3[val.spawnableItem] = val;
					}
				}
				foreach (var (val4, val5) in dictionary3)
				{
					if (!dictionary.TryGetValue(((Object)val4).name, out var value))
					{
						value = new WeightTableBuilder<DawnMoonInfo, SpawnWeightContext>();
						dictionary[((Object)val4).name] = value;
					}
					Debuggers.Items?.Log($"Adding weight {val5.rarity} to {((Object)val4).name} on level {level.PlanetName}");
					value.AddWeight(value5.TypedKey, val5.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();
			int i;
			for (i = 0; i < instance.buyableItemsList.Length; i++)
			{
				Item val6 = instance.buyableItemsList[i];
				TerminalNode val7 = null;
				TerminalNode requestNode = null;
				TerminalNode val8 = null;
				string text = val6.itemName.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 " + val6.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;
				}
				val8 = requestNode.terminalOptions[0].result;
				TerminalKeyword val9 = (from noun in TerminalRefs.BuyKeyword.compatibleNouns
					where (Object)(object)noun.result == (Object)(object)requestNode
					select noun.noun).FirstOrDefault();
				if ((Object)(object)val9 == (Object)null)
				{
					DawnPlugin.Logger.LogWarning((object)("No buy Keyword found for " + val6.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 val10 in compatibleNouns)
				{
					if ((Object)(object)val10.noun == (Object)(object)val9)
					{
						val7 = val10.result;
						break;
					}
				}
				if ((Object)(object)val7 == (Object)null)
				{
					val7 = new TerminalNodeBuilder(text + "InfoNode").SetDisplayText("[No information about this object was found.]\n\n").SetClearPreviousText(clearPreviousText: true).SetMaxCharactersToType(25)
						.Build();
					CompatibleNoun item = new CompatibleNoun(val9, val7);
					List<CompatibleNoun> list4 = infoKeyword.compatibleNouns.ToList();
					list4.Add(item);
					infoKeyword.compatibleNouns = list4.ToArray();
				}
				CompatibleNoun[] compatibleNouns2 = buyKeyword.compatibleNouns;
				foreach (CompatibleNoun val11 in compatibleNouns2)
				{
					if ((Object)(object)val11.noun == (Object)(object)val9)
					{
						requestNode = val11.result;
						break;
					}
				}
				DawnPurchaseInfo dawnPurchaseInfo = new DawnPurchaseInfo(new SimpleProvider<int>(val6.creditsWorth), ITerminalPurchasePredicate.AlwaysSuccess());
				DawnShopItemInfo value2 = new DawnShopItemInfo(dawnPurchaseInfo, val7, requestNode, val8);
				dictionary2[((Object)val6).name] = 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(modName, items.itemName);
				}
				else if (namespacedKey == null && LethalLevelLoaderCompat.Enabled && LethalLevelLoaderCompat.TryGetExtendedItemModName(items, out modName2))
				{
					namespacedKey = NamespacedKey<DawnItemInfo>.From(modName2, items.itemName);
				}
				else if (namespacedKey == null)
				{
					namespacedKey = NamespacedKey<DawnItemInfo>.From("unknown_lib", items.itemName);
				}
				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(((Object)items).name, out var value3);
				DawnScrapItemInfo scrapItemInfo = null;
				dictionary2.TryGetValue(((Object)items).name, 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;
				}
				Debuggers.Items?.Log($"Registering {items.itemName} ({((Object)items).name}) with range of values: {(double)items.minValue * 0.4} and {(double)items.maxValue * 0.4}");
				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_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Expected O, but got Unknown
			foreach (DawnItemInfo value in LethalContent.Items.Values)
			{
				DawnScrapItemInfo scrapInfo = value.ScrapInfo;
				if (scrapInfo == null || value.ShouldSkipRespectOverride())
				{
					continue;
				}
				foreach (DawnMoonInfo value2 in LethalContent.Moons.Values)
				{
					SelectableLevel level = value2.Level;
					bool flag = false;
					foreach (SpawnableItemWithRarity item2 in level.spawnableScrap)
					{
						if ((Object)(object)item2.spawnableItem == (Object)(object)value.Item)
						{
							flag = true;
							break;
						}
					}
					if (!flag)
					{
						SpawnableItemWithRarity item = new SpawnableItemWithRarity(value.Item, 0);
						level.spawnableScrap.Add(item);
					}
				}
			}
		}

		private static void RegisterShopItemsToTerminal(orig_Awake orig, Terminal self)
		{
			orig.Invoke(self);
			foreach (DawnItemInfo value in LethalContent.Items.Values)
			{
				TryRegisterItemIntoShop(value.Item);
			}
		}

		private static void TryRegisterItemIntoShop(Item item)
		{
			//IL_01a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ac: Expected O, but got Unknown
			//IL_01b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b8: Expected O, but got Unknown
			//IL_01c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cd: Expected O, but got Unknown
			//IL_01d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e2: Expected O, but got Unknown
			DawnItemInfo dawnInfo = item.GetDawnInfo();
			if (dawnInfo == null)
			{
				DawnPlugin.Logger.LogWarning((object)("Item: " + item.itemName + " does not have a dawn info, this means they cannot be registered to the terminal as a shop item"));
				return;
			}
			_ = TerminalRefs.Instance;
			TerminalKeyword buyKeyword = TerminalRefs.BuyKeyword;
			TerminalKeyword infoKeyword = TerminalRefs.InfoKeyword;
			TerminalKeyword confirmPurchaseKeyword = TerminalRefs.ConfirmPurchaseKeyword;
			TerminalKeyword denyKeyword = TerminalRefs.DenyKeyword;
			TerminalNode cancelPurchaseNode = TerminalRefs.CancelPurchaseNode;
			DawnShopItemInfo shopInfo = dawnInfo.ShopInfo;
			if (shopInfo == null || dawnInfo.ShouldSkipRespectOverride() || TerminalRefs.Instance.buyableItemsList.Contains(item))
			{
				return;
			}
			List<Item> list = TerminalRefs.Instance.buyableItemsList.ToList();
			string text = dawnInfo.Item.itemName.ToLowerInvariant();
			list.Add(dawnInfo.Item);
			TerminalKeyword[] allKeywords = TerminalRefs.Instance.terminalNodes.allKeywords;
			foreach (TerminalKeyword val in allKeywords)
			{
				if (((Object)val).name == text)
				{
					TerminalRefs.Instance.buyableItemsList = list.ToArray();
					return;
				}
			}
			List<CompatibleNoun> list2 = buyKeyword.compatibleNouns.ToList();
			List<CompatibleNoun> list3 = infoKeyword.compatibleNouns.ToList();
			List<TerminalKeyword> list4 = TerminalRefs.Instance.terminalNodes.allKeywords.ToList();
			TerminalKeyword val2 = new TerminalKeywordBuilder(text, text, (DawnKeywordType)5).SetIsVerb(isVerb: false).SetDefaultVerb(buyKeyword).SetAccessTerminalObjects(accessTerminalObjects: false)
				.Build();
			list4.Add(val2);
			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(confirmPurchaseKeyword, receiptNode),
				new CompatibleNoun(denyKeyword, cancelPurchaseNode)
			};
			list2.Add(new CompatibleNoun(val2, requestNode));
			list3.Add(new CompatibleNoun(val2, shopInfo.InfoNode));
			TerminalRefs.Instance.buyableItemsList = list.ToArray();
			infoKeyword.compatibleNouns = list3.ToArray();
			buyKeyword.compatibleNouns = list2.ToArray();
			TerminalRefs.Instance.terminalNodes.allKeywords = list4.ToArray();
		}

		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; private set; }

		public DawnShopItemInfo? ShopInfo { get; private set; }

		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, SpawnWeightContext> Weights { get; private set; }

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

		public TerminalNode? InfoNode { get; private set; }

		public TerminalNode RequestNode { get; }

		public TerminalNode ReceiptNode { get; }

		public DawnPurchaseInfo DawnPurchaseInfo { get; }

		internal DawnShopItemInfo(DawnPurchaseInfo dawnPurchaseInfo, TerminalNode? infoNode, TerminalNode requestNode, TerminalNode receiptNode)
		{
			DawnPurchaseInfo = dawnPurchaseInfo;
			InfoNode = infoNode;
			RequestNode = requestNode;
			ReceiptNode = receiptNode;
		}

		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()
		{
			return TerminalRefs.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, SpawnWeightContext>? _weights;

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

			public ScrapBuilder SetWeights(Action<WeightTableBuilder<DawnMoonInfo, SpawnWeightContext>> callback)
			{
				WeightTableBuilder<DawnMoonInfo, SpawnWeightContext> weightTableBuilder = new WeightTableBuilder<DawnMoonInfo, SpawnWeightContext>();
				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, SpawnWeightContext>.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)
						.SetPlaySyncedClip(0)
						.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(new DawnPurchaseInfo(_costOverride, _purchasePredicate), _infoNode, _requestNode, _receiptNode);
			}
		}

		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 Registry<DawnStoryLogInfo> StoryLogs = new Registry<DawnStoryLogInfo>();

		public static Registry<DawnSurfaceInfo> Surfaces = new Registry<DawnSurfaceInfo>();

		public static Registry<DawnTerminalCommandInfo> TerminalCommands = new Registry<DawnTerminalCommandInfo>();
	}
	public static class DawnLibTags
	{
		public static readonly NamespacedKey IsExternal = NamespacedKey.From("dawn_lib", "is_external");

		public static readonly NamespacedKey LunarConfig = NamespacedKey.From("dawn_lib", "lunar_config");

		public static readonly NamespacedKey HasBuyingPercent = NamespacedKey.From("dawn_lib", "has_buying_percent");
	}
	internal static class MapObjectRegistrationHandler
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static Action<Action<RandomMapObject>, RandomMapObject> <0>__AddPrefabsToRandomMapObjects;

			public static hook_SpawnOutsideHazards <1>__SpawnOutsideMapObjects;

			public static Manipulator <2>__RegenerateNavMeshTranspiler;

			public static hook_SetPlanetsWeather <3>__UpdateMapObjectSpawnWeights;

			public static hook_SpawnMapObjects <4>__UpdateMapObjectSpawnWeights;

			public static Action <5>__RegisterMapObjects;

			public static Action <6>__FixMapObjectBlanksOnDawnMoons;
		}

		private static int _spawnedObjects;

		internal static void Init()
		{
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: 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
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Expected O, but got Unknown
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Expected O, but got Unknown
			DawnPlugin.Hooks.Add(new Hook((MethodBase)AccessTools.DeclaredMethod(typeof(RandomMapObject), "Awake", (Type[])null, (Type[])null), (Delegate)new Action<Action<RandomMapObject>, RandomMapObject>(AddPrefabsToRandomMapObjects)));
			object obj = <>O.<1>__SpawnOutsideMapObjects;
			if (obj == null)
			{
				hook_SpawnOutsideHazards val = SpawnOutsideMapObjects;
				<>O.<1>__SpawnOutsideMapObjects = val;
				obj = (object)val;
			}
			RoundManager.SpawnOutsideHazards += (hook_SpawnOutsideHazards)obj;
			object obj2 = <>O.<2>__RegenerateNavMeshTranspiler;
			if (obj2 == null)
			{
				Manipulator val2 = RegenerateNavMeshTranspiler;
				<>O.<2>__RegenerateNavMeshTranspiler = val2;
				obj2 = (object)val2;
			}
			RoundManager.SpawnOutsideHazards += (Manipulator)obj2;
			object obj3 = <>O.<3>__UpdateMapObjectSpawnWeights;
			if (obj3 == null)
			{
				hook_SetPlanetsWeather val3 = UpdateMapObjectSpawnWeights;
				<>O.<3>__UpdateMapObjectSpawnWeights = val3;
				obj3 = (object)val3;
			}
			StartOfRound.SetPlanetsWeather += (hook_SetPlanetsWeather)obj3;
			object obj4 = <>O.<4>__UpdateMapObjectSpawnWeights;
			if (obj4 == null)
			{
				hook_SpawnMapObjects val4 = UpdateMapObjectSpawnWeights;
				<>O.<4>__UpdateMapObjectSpawnWeights = val4;
				obj4 = (object)val4;
			}
			RoundManager.SpawnMapObjects += (hook_SpawnMapObjects)obj4;
			LethalContent.Moons.OnFreeze += RegisterMapObjects;
			LethalContent.MapObjects.OnFreeze += FixMapObjectBlanksOnDawnMoons;
		}

		private static void AddPrefabsToRandomMapObjects(Action<RandomMapObject> orig, RandomMapObject self)
		{
			foreach (DawnMapObjectInfo value in LethalContent.MapObjects.Values)
			{
				if (value.InsideInfo != null && !value.ShouldSkipRespectOverride() && value.HasNetworkObject)
				{
					if ((Object)(object)value.InsideInfo.IndoorMapHazardType.prefabToSpawn == (Object)null)
					{
						DawnPlugin.Logger.LogWarning((object)("MapObject Inside prefab is null for " + ((Object)value.InsideInfo.IndoorMapHazardType).name));
					}
					else
					{
						self.spawnablePrefabs.Add(value.InsideInfo.IndoorMapHazardType.prefabToSpawn);
					}
				}
			}
			orig.Invoke(self);
		}

		private static void FixMapObjectBlanksOnDawnMoons()
		{
			List<ScriptableObject> list = new List<ScriptableObject>();
			foreach (DawnMoonInfo value in LethalContent.Moons.Values)
			{
				if (value.ShouldSkipIgnoreOverride())
				{
					continue;
				}
				IndoorMapHazard[] indoorMapHazards = value.Level.indoorMapHazards;
				foreach (IndoorMapHazard val in indoorMapHazards)
				{
					if ((Object)(object)val.hazardType == (Object)null)
					{
						continue;
					}
					foreach (DawnMapObjectInfo value2 in LethalContent.MapObjects.Values)
					{
						if (value2.InsideInfo != null && ((Object)value2.InsideInfo.IndoorMapHazardType).name == ((Object)val.hazardType).name)
						{
							list.Add((ScriptableObject)(object)val.hazardType);
							val.hazardType = value2.InsideInfo.IndoorMapHazardType;
							break;
						}
					}
				}
				SpawnableOutsideObjectWithRarity[] spawnableOutsideObjects = value.Level.spawnableOutsideObjects;
				foreach (SpawnableOutsideObjectWithRarity val2 in spawnableOutsideObjects)
				{
					if ((Object)(object)val2.spawnableObject == (Object)null)
					{
						continue;
					}
					foreach (DawnMapObjectInfo value3 in LethalContent.MapObjects.Values)
					{
						if (value3.OutsideInfo != null && ((Object)value3.OutsideInfo.SpawnableOutsideObject).name == ((Object)val2.spawnableObject).name)
						{
							list.Add((ScriptableObject)(object)val2.spawnableObject);
							val2.spawnableObject = value3.OutsideInfo.SpawnableOutsideObject;
							break;
						}
					}
				}
			}
			for (int num = list.Count - 1; num >= 0; num--)
			{
				Object.Destroy((Object)(object)list[num]);
			}
		}

		private static void RegenerateNavMeshTranspiler(ILContext il)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			ILCursor val = new ILCursor(il);
			int num2 = default(int);
			ILLabel val3 = default(ILLabel);
			if (!val.TryGotoNext(new Func<Instruction, bool>[3]
			{
				(Instruction i) => ILPatternMatchingExt.MatchLdloc(i, ref num2),
				(Instruction i) => ILPatternMatchingExt.MatchLdcI4(i, 0),
				(Instruction i) => ILPatternMatchingExt.MatchBgt(i, ref val3)
			}))
			{
				DawnPlugin.Logger.LogWarning((object)"Failed to apply RoundManager.SpawnOutsideHazards patch (1)!");
				return;
			}
			if (!val.TryGotoNext(new Func<Instruction, bool>[1]
			{
				(Instruction i) => ILPatternMatchingExt.MatchLdstr(i, "OutsideLevelNavMesh")
			}))
			{
				DawnPlugin.Logger.LogWarning((object)"Failed to apply RoundManager.SpawnOutsideHazards patch (2)!");
				return;
			}
			int num = default(int);
			ILLabel val2 = default(ILLabel);
			val.GotoPrev((MoveType)0, new Func<Instruction, bool>[3]
			{
				(Instruction i) => ILPatternMatchingExt.MatchLdloc(i, ref num),
				(Instruction i) => ILPatternMatchingExt.MatchLdcI4(i, 0),
				(Instruction i) => ILPatternMatchingExt.MatchBgt(i, ref val2)
			});
			int index = val.Index;
			val.Index = index + 1;
			val.EmitDelegate<Func<int, int>>((Func<int, int>)((int spawned) => spawned + _spawnedObjects));
		}

		private static void FreezeMapObjectContents()
		{
			Dictionary<IndoorMapHazardType, CurveTableBuilder<DawnMoonInfo, SpawnWeightContext>> dictionary = new Dictionary<IndoorMapHazardType, CurveTableBuilder<DawnMoonInfo, SpawnWeightContext>>();
			Dictionary<SpawnableOutsideObject, CurveTableBuilder<DawnMoonInfo, SpawnWeightContext>> dictionary2 = new Dictionary<SpawnableOutsideObject, CurveTableBuilder<DawnMoonInfo, SpawnWeightContext>>();
			foreach (DawnMoonInfo value8 in LethalContent.Moons.Values)
			{
				SelectableLevel level = value8.Level;
				IndoorMapHazard[] indoorMapHazards = level.indoorMapHazards;
				foreach (IndoorMapHazard val in indoorMapHazards)
				{
					IndoorMapHazardType hazardType = val.hazardType;
					if (!((Object)(object)hazardType == (Object)null) && !((Object)(object)hazardType.prefabToSpawn == (Object)null) && !hazardType.HasDawnInfo())
					{
						if (!dictionary.TryGetValue(hazardType, out var value))
						{
							value = (dictionary[hazardType] = new CurveTableBuilder<DawnMoonInfo, SpawnWeightContext>());
						}
						value.AddCurve(value8.TypedKey, val.numberToSpawn);
					}
				}
				SpawnableOutsideObjectWithRarity[] spawnableOutsideObjects = level.spawnableOutsideObjects;
				foreach (SpawnableOutsideObjectWithRarity val2 in spawnableOutsideObjects)
				{
					SpawnableOutsideObject spawnableObject = val2.spawnableObject;
					if (!((Object)(object)spawnableObject == (Object)null) && !((Object)(object)spawnableObject.prefabToSpawn == (Object)null) && !spawnableObject.HasDawnInfo())
					{
						if (!dictionary2.TryGetValue(spawnableObject, out var value2))
						{
							value2 = (dictionary2[spawnableObject] = new CurveTableBuilder<DawnMoonInfo, SpawnWeightContext>());
						}
						value2.AddCurve(value8.TypedKey, val2.randomAmount);
					}
				}
			}
			Dictionary<GameObject, DawnInsideMapObjectInfo> dictionary3 = new Dictionary<GameObject, DawnInsideMapObjectInfo>();
			foreach (KeyValuePair<IndoorMapHazardType, CurveTableBuilder<DawnMoonInfo, SpawnWeightContext>> item in dictionary)
			{
				IndoorMapHazardType key = item.Key;
				ProviderTable<AnimationCurve, DawnMoonInfo, SpawnWeightContext> spawnWeights = item.Value.Build();
				DawnInsideMapObjectInfo value3 = new DawnInsideMapObjectInfo(item.Key, spawnWeights);
				dictionary3[key.prefabToSpawn] = value3;
			}
			Dictionary<GameObject, DawnOutsideMapObjectInfo> dictionary4 = new Dictionary<GameObject, DawnOutsideMapObjectInfo>();
			foreach (KeyValuePair<SpawnableOutsideObject, CurveTableBuilder<DawnMoonInfo, SpawnWeightContext>> item2 in dictionary2)
			{
				SpawnableOutsideObject key2 = item2.Key;
				ProviderTable<AnimationCurve, DawnMoonInfo, SpawnWeightContext> spawnWeights2 = item2.Value.Build();
				DawnOutsideMapObjectInfo value4 = new DawnOutsideMapObjectInfo(key2, spawnWeights2, alignWithTerrain: false, 0);
				dictionary4[key2.prefabToSpawn] = value4;
			}
			List<GameObject> list = dictionary.Keys.Select((IndoorMapHazardType x) => x.prefabToSpawn).Concat(dictionary2.Keys.Select((SpawnableOutsideObject x) => x.prefabToSpawn)).Distinct()
				.ToList();
			IIndoorMapHazard val3 = default(IIndoorMapHazard);
			foreach (GameObject item3 in list)
			{
				string name = NamespacedKey.NormalizeStringForNamespacedKey(((Object)item3).name, CSharpName: true);
				NamespacedKey<DawnMapObjectInfo> namespacedKey = MapObjectKeys.GetByReflection(name);
				string modName2;
				if (namespacedKey == null && LethalLibCompat.Enabled && LethalLibCompat.TryGetMapObjectFromLethalLib(item3, out string modName))
				{
					namespacedKey = NamespacedKey<DawnMapObjectInfo>.From(modName, ((Object)item3).name);
				}
				else if (namespacedKey == null && LethalLevelLoaderCompat.Enabled && LethalLevelLoaderCompat.TryGetExtendedMapObjectModName(item3, out modName2))
				{
					namespacedKey = NamespacedKey<DawnMapObjectInfo>.From(modName2, ((Object)item3).name);
				}
				else if (namespacedKey == null)
				{
					namespacedKey = NamespacedKey<DawnMapObjectInfo>.From("unknown_lib", ((Object)item3).name);
				}
				dictionary3.TryGetValue(item3, out var value5);
				dictionary4.TryGetValue(item3, out var value6);
				DawnMapObjectInfo dawnMapObjectInfo = new DawnMapObjectInfo(namespacedKey, new HashSet<NamespacedKey> { DawnLibTags.IsExternal }, value5, value6, null);
				if (!item3.TryGetComponent<IIndoorMapHazard>(ref val3))
				{
					DawnMapObjectNamespacedKeyContainer dawnMapObjectNamespacedKeyContainer = item3.AddComponent<DawnMapObjectNamespacedKeyContainer>();
					dawnMapObjectNamespacedKeyContainer.Value = namespacedKey;
				}
				value5?.IndoorMapHazardType.SetDawnInfo(dawnMapObjectInfo);
				value6?.SpawnableOutsideObject.SetDawnInfo(dawnMapObjectInfo);
				if (LethalContent.MapObjects.TryGetValue(dawnMapObjectInfo.TypedKey, out DawnMapObjectInfo value7))
				{
					value5?.IndoorMapHazardType.SetDawnInfo(value7);
					value6?.SpawnableOutsideObject.SetDawnInfo(value7);
				}
				else
				{
					LethalContent.MapObjects.Register(dawnMapObjectInfo);
				}
			}
			LethalContent.MapObjects.Freeze();
		}

		private static void UpdateMapObjectSpawnWeights(orig_SpawnMapObjects orig, RoundManager self)
		{
			UpdateIndoorMapHazardSpawnWeightsOnLevel(self.currentLevel);
			orig.Invoke(self);
		}

		private static void SpawnOutsideMapObjects(orig_SpawnOutsideHazards orig, RoundManager self)
		{
			UpdateOutsideMapObjectSpawnWeightsOnLevel(self.currentLevel);
			Random everyoneRandom = new Random(StartOfRound.Instance.randomMapSeed + 69);
			Random serverOnlyRandom = new Random(StartOfRound.Instance.randomMapSeed + 6969);
			List<(DawnOutsideMapObjectInfo, Vector3)> occupiedPositions = new List<(DawnOutsideMapObjectInfo, Vector3)>();
			EntranceTeleport[] entranceTeleports = Object.FindObjectsByType<EntranceTeleport>((FindObjectsInactive)0, (FindObjectsSortMode)1);
			Transform[] shipSpawnPathPoints = RoundManager.Instance.shipSpawnPathPoints;
			GameObject[] spawnDenialPoints = GameObject.FindGameObjectsWithTag("SpawnDenialPoint");
			GameObject itemShipLandingNode = GameObject.FindGameObjectWithTag("ItemShipLandingNode");
			foreach (DawnMapObjectInfo value in LethalContent.MapObjects.Values)
			{
				DawnOutsideMapObjectInfo outsideInfo = value.OutsideInfo;
				if (outsideInfo != null && !value.ShouldSkipRespectOverride())
				{
					if (outsideInfo.ParentInfo == null)
					{
						DawnPlugin.Logger.LogError((object)("Failed to get outside parent info for " + ((Object)outsideInfo.SpawnableOutsideObject.prefabToSpawn).name));
					}
					else
					{
						HandleSpawningOutsideObjects(outsideInfo, occupiedPositions, everyoneRandom, serverOnlyRandom, entranceTeleports, shipSpawnPathPoints, spawnDenialPoints, itemShipLandingNode);
					}
				}
			}
			orig.Invoke(self);
			_spawnedObjects = 0;
		}

		private static void HandleSpawningOutsideObjects(DawnOutsideMapObjectInfo outsideInfo, List<(DawnOutsideMapObjectInfo outsideMapObjectInfo, Vector3 position)> occupiedPositions, Random everyoneRandom, Random serverOnlyRandom, EntranceTeleport[] entranceTeleports, Transform[] shipSpawnPathPoints, GameObject[] spawnDenialPoints, GameObject itemShipLandingNode)
		{
			//IL_066c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0679: Unknown result type (might be due to invalid IL or missing references)
			//IL_0238: Unknown result type (might be due to invalid IL or missing references)
			//IL_023d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0244: Unknown result type (might be due to invalid IL or missing references)
			//IL_024d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0253: Unknown result type (might be due to invalid IL or missing references)
			//IL_025d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0262: Unknown result type (might be due to invalid IL or missing references)
			//IL_026c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0271: Unknown result type (might be due to invalid IL or missing references)
			//IL_0276: Unknown result type (might be due to invalid IL or missing references)
			//IL_0278: Unknown result type (might be due to invalid IL or missing references)
			//IL_027a: Unknown result type (might be due to invalid IL or missing references)
			//IL_06b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_037e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0388: Unknown result type (might be due to invalid IL or missing references)
			//IL_038e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0390: Unknown result type (might be due to invalid IL or missing references)
			//IL_0395: Unknown result type (might be due to invalid IL or missing references)
			//IL_0397: Unknown result type (might be due to invalid IL or missing references)
			//IL_0399: Unknown result type (might be due to invalid IL or missing references)
			//IL_0304: Unknown result type (might be due to invalid IL or missing references)
			//IL_03fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0403: Unknown result type (might be due to invalid IL or missing references)
			//IL_03be: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_047c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0481: Unknown result type (might be due to invalid IL or missing references)
			//IL_0441: Unknown result type (might be due to invalid IL or missing references)
			//IL_0446: Unknown result type (might be due to invalid IL or missing references)
			//IL_04d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_04e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_04e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_051a: Unknown result type (might be due to invalid IL or missing references)
			//IL_049d: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_054d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0552: Unknown result type (might be due to invalid IL or missing references)
			//IL_053c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0566: Unknown result type (might be due to invalid IL or missing references)
			//IL_0568: Unknown result type (might be due to invalid IL or missing references)
			//IL_0572: Unknown result type (might be due to invalid IL or missing references)
			//IL_0577: Unknown result type (might be due to invalid IL or missing references)
			//IL_05b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_05c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_05ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_05d3: Unknown result type (might be due to invalid IL or missing references)
			if (RoundManager.Instance.outsideAINodes.Length <= outsideInfo.MinimumAINodeSpawnRequirement)
			{
				return;
			}
			SelectableLevel currentLevel = RoundManager.Instance.currentLevel;
			DawnMapObjectInfo parentInfo = outsideInfo.ParentInfo;
			GameObject prefabToSpawn = outsideInfo.SpawnableOutsideObject.prefabToSpawn;
			SpawnWeightContext ctx = new SpawnWeightContext(currentLevel.GetDawnInfo(), RoundManager.Instance.dungeonGenerator.Generator.DungeonFlow.GetDawnInfo(), TimeOfDayRefs.GetCurrentWeatherEffect(currentLevel)?.GetDawnInfo()).WithExtra(SpawnWeightExtraKeys.RoutingPriceKey, currentLevel.GetDawnInfo().DawnPurchaseInfo.Cost.Provide());
			AnimationCurve val = outsideInfo.SpawnWeights.GetFor(in ctx) ?? AnimationCurve.Constant(0f, 1f, 0f);
			int num2;
			if (parentInfo.HasNetworkObject)
			{
				if (!NetworkManager.Singleton.IsServer)
				{
					return;
				}
				float num = val.Evaluate(serverOnlyRandom.NextFloat(0f, 1f)) + 0.5f;
				Debuggers.MapObjects?.Log($"number generated for host only: {num}");
				num2 = Mathf.FloorToInt(num);
			}
			else
			{
				float num3 = val.Evaluate(everyoneRandom.NextFloat(0f, 1f)) + 0.5f;
				Debuggers.MapObjects?.Log("number generated for everyone: " + num3);
				num2 = Mathf.FloorToInt(num3);
			}
			Debuggers.MapObjects?.Log($"Spawning {num2} of {((Object)prefabToSpawn).name} for level {currentLevel}");
			float num4 = outsideInfo.SpawnableOutsideObject.objectWidth;
			int num5 = 0;
			int num6 = num2;
			RaycastHit val3 = default(RaycastHit);
			DawnSurface dawnSurface = default(DawnSurface);
			while (num2 > 0 && num5 < 10 * num6)
			{
				Debuggers.MapObjects?.Log($"Attempt number: {num5} with {num2} left to spawn with initial number: {num6}.");
				num5++;
				Random random = (parentInfo.HasNetworkObject ? serverOnlyRandom : everyoneRandom);
				GameObject val2 = RoundManager.Instance.outsideAINodes[random.Next(0, RoundManager.Instance.outsideAINodes.Length)];
				if ((Object)(object)val2 == (Object)null)
				{
					DawnPlugin.Logger.LogWarning((object)("Failed to get a valid outside AI node to spawn map object at level: " + currentLevel.sceneName + "."));
					continue;
				}
				Vector3 position = val2.transform.position;
				position = RoundManager.Instance.GetRandomNavMeshPositionInBoxPredictable(position, 10f, default(NavMeshHit), random, -1, 1f) + Vector3.up * 2f;
				if (!Physics.Raycast(position, Vector3.down, ref val3, 100f, StartOfRound.Instance.collidersAndRoomMaskAndDefault, (QueryTriggerInteraction)1) || !Object.op_Implicit((Object)(object)((RaycastHit)(ref val3)).collider))
				{
					continue;
				}
				string[] spawnableFloorTags = outsideInfo.SpawnableOutsideObject.spawnableFloorTags;
				if (spawnableFloorTags != null && spawnableFloorTags.Length != 0)
				{
					bool flag = false;
					Transform transform = ((Component)((RaycastHit)(ref val3)).collider).transform;
					int footstepIndex = -1;
					if (((Component)transform).TryGetComponent<DawnSurface>(ref dawnSurface) && (dawnSurface.SurfaceIndex > -1 || dawnSurface.TerrainIndices.Count > 0))
					{
						dawnSurface.TryGetFootstepIndex(((RaycastHit)(ref val3)).point, checkStandingOnTerrain: false, out footstepIndex);
					}
					for (int i = 0; i < spawnableFloorTags.Length; i++)
					{
						if (footstepIndex != -1)
						{
							DawnSurfaceInfo dawnInfo = StartOfRound.Instance.footstepSurfaces[footstepIndex].GetDawnInfo();
							if (dawnInfo.Surface.surfaceTag.Equals(spawnableFloorTags[i], StringComparison.OrdinalIgnoreCase))
							{
								flag = true;
								break;
							}
						}
						else if (((Component)transform).CompareTag(spawnableFloorTags[i]))
						{
							flag = true;
							break;
						}
					}
					if (!flag)
					{
						continue;
					}
				}
				Vector3 val4 = RoundManager.Instance.PositionEdgeCheck(((RaycastHit)(ref val3)).point, num4, -1, default(Vector3));
				if (val4 == Vector3.zero)
				{
					continue;
				}
				bool flag2 = false;
				if (shipSpawnPathPoints != null)
				{
					for (int j = 0; j < shipSpawnPathPoints.Length; j++)
					{
						if (Vector3.Distance(((Component)shipSpawnPathPoints[j]).transform.position, val4) < num4 + 6f)
						{
							flag2 = true;
							break;
						}
					}
				}
				foreach (EntranceTeleport val5 in entranceTeleports)
				{
					if (Vector3.Distance(((Component)val5).transform.position, val4) < num4 + 6f)
					{
						flag2 = true;
						break;
					}
				}
				if (flag2)
				{
					continue;
				}
				if (spawnDenialPoints != null)
				{
					for (int l = 0; l < spawnDenialPoints.Length; l++)
					{
						if (Vector3.Distance(spawnDenialPoints[l].transform.position, val4) < num4)
						{
							flag2 = true;
							break;
						}
					}
				}
				if (flag2 || ((Object)(object)itemShipLandingNode != (Object)null && Vector3.Distance(itemShipLandingNode.transform.position, val4) < num4))
				{
					continue;
				}
				if (num4 > 4f)
				{
					for (int m = 0; m < occupiedPositions.Count; m++)
					{
						if (Vector3.Distance(val4, occupiedPositions[m].position) < num4)
						{
							flag2 = true;
							break;
						}
					}
					if (flag2)
					{
						continue;
					}
				}
				num2--;
				occupiedPositions.Add((outsideInfo, val4));
				GameObject val6 = Object.Instantiate<GameObject>(prefabToSpawn, val4, Quaternion.identity, RoundManager.Instance.mapPropsContainer.transform);
				Debuggers.MapObjects?.Log($"Spawning {((Object)val6).name} at {val4}");
				if (outsideInfo.AlignWithTerrain)
				{
					val6.transform.up = ((RaycastHit)(ref val3)).normal;
				}
				Vector3 eulerAngles = val6.transform.eulerAngles;
				if (outsideInfo.SpawnableOutsideObject.spawnFacingAwayFromWall)
				{
					float y = RoundManager.Instance.YRotationThatFacesTheFarthestFromPosition(val4 + Vector3.up * 0.2f, 25f, 6);
					eulerAngles.y = y;
				}
				else
				{
					int num7 = random.Next(0, 360);
					eulerAngles.y = num7;
				}
				val6.transform.eulerAngles = eulerAngles;
				Transform transform2 = val6.transform;
				transform2.localEulerAngles += outsideInfo.SpawnableOutsideObject.rotationOffset;
				_spawnedObjects++;
				if (parentInfo.HasNetworkObject)
				{
					val6.GetComponent<NetworkObject>().Spawn(true);
				}
			}
			if (!NetworkManager.Singleton.IsServer)
			{
				return;
			}
			List<GameObject> list = GameObject.FindGameObjectsWithTag("Tree").ToList();
			for (int n = 0; n < occupiedPositions.Count; n++)
			{
				if (!occupiedPositions[n].outsideMapObjectInfo.SpawnableOutsideObject.destroyTrees)
				{
					continue;
				}
				for (int num8 = list.Count - 1; num8 >= 0; num8--)
				{
					float num9 = Vector3.Distance(list[num8].transform.position, occupiedPositions[n].position);
					if (num9 < (float)occupiedPositions[n].outsideMapObjectInfo.SpawnableOutsideObject.objectWidth)
					{
						RoundManager.Instance.DestroyTreeAtPosition(list[num8].transform.position, 5f);
						list.RemoveAt(num8);
					}
				}
			}
		}

		private static void UpdateMapObjectSpawnWeights(orig_SetPlanetsWeather orig, StartOfRound self, int connectedPlayersOnServer)
		{
			orig.Invoke(self, connectedPlayersOnServer);
			UpdateIndoorMapHazardSpawnWeightsOnLevel(self.currentLevel);
			UpdateOutsideMapObjectSpawnWeightsOnLevel(self.currentLevel);
		}

		internal static void UpdateIndoorMapHazardSpawnWeightsOnLevel(SelectableLevel level)
		{
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Expected O, but got Unknown
			if (!LethalContent.Weathers.IsFrozen || !LethalContent.MapObjects.IsFrozen || (Object)(object)StartOfRound.Instance == (Object)null || (WeatherRegistryCompat.Enabled && !WeatherRegistryCompat.IsWeatherManagerReady()))
			{
				return;
			}
			foreach (DawnMapObjectInfo value in LethalContent.MapObjects.Values)
			{
				DawnInsideMapObjectInfo insideInfo = value.InsideInfo;
				if (insideInfo != null && !value.ShouldSkipRespectOverride())
				{
					Debuggers.MapObjects?.Log("Updating weights for " + ((Object)insideInfo.IndoorMapHazardType.prefabToSpawn).name + " on level " + level.PlanetName);
					IndoorMapHazard val = ((IEnumerable<IndoorMapHazard>)level.indoorMapHazards).FirstOrDefault((Func<IndoorMapHazard, bool>)((IndoorMapHazard mapObject) => (Object)(object)mapObject.hazardType == (Object)(object)insideInfo.IndoorMapHazardType));
					if (val == null)
					{
						val = new IndoorMapHazard
						{
							hazardType = insideInfo.IndoorMapHazardType,
							numberToSpawn = AnimationCurve.Constant(0f, 1f, 0f)
						};
						List<IndoorMapHazard> list = level.indoorMapHazards.ToList();
						list.Add(val);
						level.indoorMapHazards = list.ToArray();
					}
					SpawnWeightContext ctx = new SpawnWeightContext(level.GetDawnInfo(), RoundManager.Instance.dungeonGenerator?.Generator?.DungeonFlow?.GetDawnInfo(), TimeOfDayRefs.GetCurrentWeatherEffect(level)?.GetDawnInfo()).WithExtra(SpawnWeightExtraKeys.RoutingPriceKey, level.GetDawnInfo().DawnPurchaseInfo.Cost.Provide());
					val.numberToSpawn = insideInfo.SpawnWeights.GetFor(in ctx) ?? AnimationCurve.Constant(0f, 1f, 0f);
				}
			}
		}

		internal static void UpdateOutsideMapObjectSpawnWeightsOnLevel(SelectableLevel level)
		{
			if (!LethalContent.Weathers.IsFrozen || !LethalContent.MapObjects.IsFrozen || (Object)(object)StartOfRound.Instance == (Object)null || (WeatherRegistryCompat.Enabled && !WeatherRegistryCompat.IsWeatherManagerReady()))
			{
				return;
			}
			foreach (DawnMapObjectInfo value in LethalContent.MapObjects.Values)
			{
				DawnOutsideMapObjectInfo outsideInfo = value.OutsideInfo;
				if (outsideInfo != null && !value.ShouldSkipRespectOverride())
				{
					SpawnableOutsideObjectWithRarity val = ((IEnumerable<SpawnableOutsideObjectWithRarity>)level.spawnableOutsideObjects).FirstOrDefault((Func<SpawnableOutsideObjectWithRarity, bool>)((SpawnableOutsideObjectWithRarity mapObject) => (Object)(object)mapObject.spawnableObject.prefabToSpawn == (Object)(object)outsideInfo.SpawnableOutsideObject.prefabToSpawn));
					if (val != null)
					{
						List<SpawnableOutsideObjectWithRarity> list = level.spawnableOutsideObjects.ToList();
						list.Remove(val);
						level.spawnableOutsideObjects = list.ToArray();
						Debuggers.MapObjects?.Log("Updating weights for " + ((Object)outsideInfo.SpawnableOutsideObject.prefabToSpawn).name + " on level " + level.PlanetName);
					}
				}
			}
		}

		private static void RegisterMapObjects()
		{
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Expected O, but got Unknown
			foreach (DawnMoonInfo value in LethalContent.Moons.Values)
			{
				List<IndoorMapHazard> list = value.Level.indoorMapHazards.ToList();
				foreach (DawnMapObjectInfo value2 in LethalContent.MapObjects.Values)
				{
					if (value2.InsideInfo != null && !value2.ShouldSkipRespectOverride())
					{
						IndoorMapHazard item = new IndoorMapHazard
						{
							hazardType = value2.InsideInfo.IndoorMapHazardType,
							numberToSpawn = AnimationCurve.Constant(0f, 1f, 0f)
						};
						list.Add(item);
					}
				}
				value.Level.indoorMapHazards = list.ToArray();
			}
			FreezeMapObjectContents();
		}
	}
	public sealed class DawnInsideMapObjectInfo
	{
		public DawnMapObjectInfo ParentInfo { get; internal set; }

		public IndoorMapHazardType IndoorMapHazardType { get; set; }

		public ProviderTable<AnimationCurve?, DawnMoonInfo, SpawnWeightContext> SpawnWeights { get; private set; }

		internal DawnInsideMapObjectInfo(IndoorMapHazardType indoorMapHazardType, ProviderTable<AnimationCurve?, DawnMoonInfo, SpawnWeightContext> spawnWeights)
		{
			IndoorMapHazardType = indoorMapHazardType;
			SpawnWeights = spawnWeights;
		}
	}
	public sealed class DawnMapObjectInfo : DawnBaseInfo<DawnMapObjectInfo>
	{
		public DawnInsideMapObjectInfo? InsideInfo { get; private set; }

		public DawnOutsideMapObjectInfo? OutsideInfo { get; private set; }

		public bool HasNetworkObject { get; }

		internal DawnMapObjectInfo(NamespacedKey<DawnMapObjectInfo> key, HashSet<NamespacedKey> tags, DawnInsideMapObjectInfo? insideInfo, DawnOutsideMapObjectInfo? outsideInfo, IDataContainer? customData)
			: base(key, tags, customData)
		{
			InsideInfo = insideInfo;
			if (InsideInfo != null)
			{
				InsideInfo.ParentInfo = this;
				HasNetworkObject = (Object)(object)InsideInfo.IndoorMapHazardType.prefabToSpawn.GetComponent<NetworkObject>() != (Object)null;
			}
			OutsideInfo = outsideInfo;
			if (OutsideInfo != null)
			{
				OutsideInfo.ParentInfo = this;
				HasNetworkObject = (Object)(object)OutsideInfo.SpawnableOutsideObject.prefabToSpawn.GetComponent<NetworkObject>() != (Object)null;
			}
		}

		public GameObject GetMapObjectPrefab()
		{
			if (InsideInfo != null)
			{
				return InsideInfo.IndoorMapHazardType.prefabToSpawn;
			}
			if (OutsideInfo != null)
			{
				return OutsideInfo.SpawnableOutsideObject.prefabToSpawn;
			}
			DawnPlugin.Logger.LogError((object)$"Failed to get map object prefab for {base.Key}");
			return null;
		}
	}
	public sealed class DawnOutsideMapObjectInfo
	{
		public DawnMapObjectInfo ParentInfo { get; internal set; }

		public SpawnableOutsideObject SpawnableOutsideObject { get; private set; }

		public ProviderTable<AnimationCurve?, DawnMoonInfo, SpawnWeightContext> SpawnWeights { get; private set; }

		public bool AlignWithTerrain { get; private set; }

		public int MinimumAINodeSpawnRequirement { get; private set; }

		internal DawnOutsideMapObjectInfo(SpawnableOutsideObject spawnableOutsideObject, ProviderTable<AnimationCurve?, DawnMoonInfo, SpawnWeightContext> spawnWeights, bool alignWithTerrain, int minimumAINodeSpawnRequirement)
		{
			SpawnableOutsideObject = spawnableOutsideObject;
			SpawnWeights = spawnWeights;
			AlignWithTerrain = alignWithTerrain;
			MinimumAINodeSpawnRequirement = minimumAINodeSpawnRequirement;
		}
	}
	public static class IndoorMapHazardTypeExtensions
	{
		public static DawnMapObjectInfo GetDawnInfo(this IndoorMapHazardType IndoorMapHazardType)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			return (DawnMapObjectInfo)((IDawnObject)IndoorMapHazardType).DawnInfo;
		}

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

		internal static void SetDawnInfo(this IndoorMapHazardType IndoorMapHazardType, DawnMapObjectInfo IndoorMapHazardTypeInfo)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			((IDawnObject)IndoorMapHazardType).DawnInfo = IndoorMapHazardTypeInfo;
		}
	}
	[Serializable]
	public class InsideMapObjectSettings
	{
		public bool spawnFacingAwayFromWall;

		public bool spawnFacingWall;

		public bool spawnWithBackToWall;

		public bool spawnWithBackFlushAgainstWall;

		public bool requireDistanceBetweenSpawns;

		public bool disallowSpawningNearEntrances;

		public bool allowInMineshaft;
	}
	public class MapObjectInfoBuilder : BaseInfoBuilder<DawnMapObjectInfo, GameObject, MapObjectInfoBuilder>
	{
		public class InsideBuilder
		{
			private MapObjectInfoBuilder _parentBuilder;

			private bool _spawnFacingAwayFromWall;

			private bool _spawnFacingWall;

			private bool _spawnWithBackToWall;

			private bool _spawnWithBackFlushAgainstWall;

			private bool _requireDistanceBetweenSpawns;

			private bool _disallowSpawningNearEntrances;

			private bool _allowInMineshaft;

			private ProviderTable<AnimationCurve?, DawnMoonInfo, SpawnWeightContext>? _weights;

			internal InsideBuilder(MapObjectInfoBuilder parent)
			{
				_parentBuilder = parent;
			}

			public InsideBuilder OverrideSpawnFacingAwayFromWall(bool spawnFacingAwayFromWall)
			{
				_spawnFacingAwayFromWall = spawnFacingAwayFromWall;
				return this;
			}

			public InsideBuilder OverrideSpawnFacingWall(bool spawnFacingWall)
			{
				_spawnFacingWall = spawnFacingWall;
				return this;
			}

			public InsideBuilder OverrideSpawnWithBackToWall(bool spawnWWithBackToWall)
			{
				_spawnWithBackToWall = spawnWWithBackToWall;
				return this;
			}

			public InsideBuilder OverrideSpawnWithBackFlushAgainstWall(bool spawnWithBackFlushAgainstWall)
			{
				_spawnWithBackFlushAgainstWall = spawnWithBackFlushAgainstWall;
				return this;
			}

			public InsideBuilder OverrideRequireDistanceBetweenSpawns(bool requireDistanceBetweenSpawns)
			{
				_requireDistanceBetweenSpawns = requireDistanceBetweenSpawns;
				return this;
			}

			public InsideBuilder OverrideDisallowSpawningNearEntrances(bool disallowSpawningNearEntrances)
			{
				_disallowSpawningNearEntrances = disallowSpawningNearEntrances;
				return this;
			}

			public InsideBuilder OverrideAllowInMineshaft(bool allowInMineshaft)
			{
				_allowInMineshaft = allowInMineshaft;
				return this;
			}

			public InsideBuilder SetWeights(Action<CurveTableBuilder<DawnMoonInfo, SpawnWeightContext>> callback)
			{
				CurveTableBuilder<DawnMoonInfo, SpawnWeightContext> curveTableBuilder = new CurveTableBuilder<DawnMoonInfo, SpawnWeightContext>();
				callback(curveTableBuilder);
				_weights = curveTableBuilder.Build();
				return this;
			}

			internal DawnInsideMapObjectInfo Build()
			{
				if (_weights == null)
				{
					DawnPlugin.Logger.LogWarning((object)$"MapObject: '{_parentBuilder.key}' didn't set inside weights. If you intend to have no weights (doing something special), call .SetWeights(() => {{}})");
					_weights = ProviderTable<AnimationCurve, DawnMoonInfo, SpawnWeightContext>.Empty();
				}
				IndoorMapHazardType val = ScriptableObject.CreateInstance<IndoorMapHazardType>();
				((Object)val).name = _parentBuilder.key.Key;
				val.prefabToSpawn = _parentBuilder.value;
				val.spawnFacingAwayFromWall = _spawnFacingAwayFromWall;
				val.spawnFacingWall = _spawnFacingWall;
				val.spawnWithBackToWall = _spawnWithBackToWall;
				val.spawnWithBackFlushAgainstWall = _spawnWithBackFlushAgainstWall;
				val.requireDistanceBetweenSpawns = _requireDistanceBetweenSpawns;
				val.disallowSpawningNearEntrances = _disallowSpawningNearEntrances;
				val.allowInMineshaft = _allowInMineshaft;
				return new DawnInsideMapObjectInfo(val, _weights);
			}
		}

		public class OutsideBuilder
		{
			private MapObjectInfoBuilder _parentBuilder;

			private bool _alignWithTerrain;

			private bool _destroyTrees;

			private bool _spawnFacingAwayFromWall;

			private int _objectWidth = 6;

			private int _minimumNodeSpawnRequirement;

			private Vector3 _rotationOffset = Vector3.zero;

			private string[] _spawnableFloorTags = Array.Empty<string>();

			private ProviderTable<AnimationCurve?, DawnMoonInfo, SpawnWeightContext>? _weights;

			internal OutsideBuilder(MapObjectInfoBuilder parent)
			{
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				//IL_000d: Unknown result type (might be due to invalid IL or missing references)
				_parentBuilder = parent;
			}

			public OutsideBuilder OverrideAlignWithTerrain(bool alignWithTerrain)
			{
				_alignWithTerrain = alignWithTerrain;
				return this;
			}

			public OutsideBuilder OverrideSpawnFacingAwayFromWall(bool spawnFacingAwayFromWall)
			{
				_spawnFacingAwayFromWall = spawnFacingAwayFromWall;
				return this;
			}

			public OutsideBuilder OverrideMinimumNodeSpawnRequirement(int minimumAINodeRequirement)
			{
				_minimumNodeSpawnRequirement = minimumAINodeRequirement;
				return this;
			}

			public OutsideBuilder OverrideRotationOffset(Vector3 rotationOffset)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				_rotationOffset = rotationOffset;
				return this;
			}

			public OutsideBuilder OverrideSpawnableFloorTags(string[] spawnableFloorTags)
			{
				_spawnableFloorTags = spawnableFloorTags;
				return this;
			}

			public OutsideBuilder OverrideObjectWidth(int objectWidth)
			{
				_objectWidth = objectWidth;
				return this;
			}

			public OutsideBuilder OverrideDestroyTrees(bool destroyTrees)
			{
				_destroyTrees = destroyTrees;
				return this;
			}

			public OutsideBuilder SetWeights(Action<CurveTableBuilder<DawnMoonInfo, SpawnWeightContext>> callback)
			{
				CurveTableBuilder<DawnMoonInfo, SpawnWeightContext> curveTableBuilder = new CurveTableBuilder<DawnMoonInfo, SpawnWeightContext>();
				callback(curveTableBuilder);
				_weights = curveTableBuilder.Build();
				return this;
			}

			internal DawnOutsideMapObjectInfo Build()
			{
				//IL_006d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0072: Unknown result type (might be due to invalid IL or missing references)
				if (_weights == null)
				{
					DawnPlugin.Logger.LogWarning((object)$"MapObject: '{_parentBuilder.key}' didn't set inside weights. If you intend to have no weights (doing something special), call .SetWeights(() => {{}})");
					_weights = ProviderTable<AnimationCurve, DawnMoonInfo, SpawnWeightContext>.Empty();
				}
				SpawnableOutsideObject val = ScriptableObject.CreateInstance<SpawnableOutsideObject>();
				((Object)val).name = _parentBuilder.key.Key;
				val.prefabToSpawn = _parentBuilder.value;
				val.spawnFacingAwayFromWall = _spawnFacingAwayFromWall;
				val.rotationOffset = _rotationOffset;
				val.destroyTrees = _destroyTrees;
				val.spawnableFloorTags = _spawnableFloorTags;
				val.objectWidth = _objectWidth;
				return new DawnOutsideMapObjectInfo(val, _weights, _alignWithTerrain, _minimumNodeSpawnRequirement);
			}
		}

		private DawnInsideMapObjectInfo? _insideInfo;

		private DawnOutsideMapObjectInfo? _outsideInfo;

		internal MapObjectInfoBuilder(NamespacedKey<DawnMapObjectInfo> key, GameObject mapObject)
			: base(key, mapObject)
		{
		}

		public MapObjectInfoBuilder DefineInside(Action<InsideBuilder> callback)
		{
			InsideBuilder insideBuilder = new InsideBuilder(this);
			callback(insideBuilder);
			_insideInfo = insideBuilder.Build();
			return this;
		}

		public MapObjectInfoBuilder DefineOutside(Action<OutsideBuilder> callback)
		{
			OutsideBuilder outsideBuilder = new OutsideBuilder(this);
			callback(outsideBuilder);
			_outsideInfo = outsideBuilder.Build();
			return this;
		}

		internal override DawnMapObjectInfo Build()
		{
			return new DawnMapObjectInfo(base.key, tags, _insideInfo, _outsideInfo, customData);
		}
	}
	[Serializable]
	public class OutsideMapObjectSettings
	{
		[FormerlySerializedAs("SpawnFacingAwayFromWall")]
		public bool spawnFacingAwayFromWall;

		[FormerlySerializedAs("ObjectWidth")]
		public int objectWidth = 6;

		public bool destroyTrees;

		[FormerlySerializedAs("RotationOffset")]
		public Vector3 rotationOffset = Vector3.zero;

		[FormerlySerializedAs("SpawnableFloorTags")]
		public string[] spawnableFloorTags = Array.Empty<string>();

		[FormerlySerializedAs("MinimumAINodeSpawnRequirement")]
		public int minimumAINodeSpawnRequirement;

		[FormerlySerializedAs("AlignWithTerrain")]
		public bool alignWithTerrain;
	}
	public static class SpawnableOutsideObjectExtensions
	{
		public static DawnMapObjectInfo GetDawnInfo(this SpawnableOutsideObject SpawnableOutsideObject)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			return (DawnMapObjectInfo)((IDawnObject)SpawnableOutsideObject).DawnInfo;
		}

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

		internal static void SetDawnInfo(this SpawnableOutsideObject SpawnableOutsideObject, DawnMapObjectInfo SpawnableOutsideObjectInfo)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			((IDawnObject)SpawnableOutsideObject).DawnInfo = SpawnableOutsideObjectInfo;
		}
	}
	[HarmonyPatch]
	internal static class MoonRegistrationHandler
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static hook_Awake <0>__CollectTestLevel;

			public static hook_Awake <1>__CollectLevels;

			public static hook_Awake <2>__SpawnRouteProgressUI;

			public static hook_Awake <3>__RegisterDawnLevels;

			public static Action <4>__FixAmbienceLibraries;

			public static Action <5>__FixDawnMoonEnemies;

			public static Action <6>__FixDawnMoonItems;

			public static hook_ChangeLevel <7>__StartOfRoundOnChangeLevel;

			public static hook_OnClientConnect <8>__StartOfRoundOnClientConnect;

			public static hook_OnClientDisconnect <9>__StartOfRoundOnClientDisconnect;

			public static hook_TravelToLevelEffects <10>__DelayTravelEffects;

			public static hook_TextPostProcess <11>__DynamicMoonCatalogue;

			public static Manipulator <12>__ReplaceStaticOutsideEnemyProbabilityRange;

			public static Manipulator <13>__MultiplyGlobalTimeMultiplierToDaySpeedMultiplier;

			public static Manipulator <14>__IgnoreDaySpeedMultiplier;
		}

		[CompilerGenerated]
		private sealed class <DelayTravelEffects>d__15 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public orig_TravelToLevelEffects orig;

			public StartOfRound self;

			private IEnumerator <enumerator>5__2;

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

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

			[DebuggerHidden]
			public <DelayTravelEffects>d__15(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<enumerator>5__2 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ba: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<enumerator>5__2 = orig.Invoke(self);
					break;
				case 1:
				{
					<>1__state = -1;
					object current = <enumerator>5__2.Current;
					WaitForSeconds val = (WaitForSeconds)((current is WaitForSeconds) ? current : null);
					if (val != null && Mathf.Approximately(val.m_Seconds, self.currentLevel.timeToArrive))
					{
						<>2__current = (object)new WaitUntil((Func<bool>)(() => NetworkSingleton<DawnMoonNetworker>.Instance.allPlayersDone));
						<>1__state = 2;
						return true;
					}
					break;
				}
				case 2:
					<>1__state = -1;
					break;
				}
				if (<enumerator>5__2.MoveNext())
				{
					<>2__current = <enumerator>5__2.Current;
					<>1__state = 1;
					return true;
				}
				self.shipTravelCoroutine = null;
				return false;
			}

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

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

		[CompilerGenerated]
		private sealed class <DoHotloadSceneStuff>d__19 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public SelectableLevel level;

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

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

			[DebuggerHidden]
			public <DoHotloadSceneStuff>d__19(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0037: Unknown result type (might be due to invalid IL or missing references)
				//IL_0041: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitUntil((Func<bool>)(() => (Object)(object)NetworkSingleton<DawnMoonNetworker>.Instance != (Object)null && (Object)(object)Singleton<RouteProgressUI>.Instance != (Object)null));
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					NetworkSingleton<DawnMoonNetworker>.Instance.HostDecide(level.GetDawnInfo());
					return false;
				}
			}

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

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

		public static MainGroupAlgorithm MoonGroupAlgorithm = new MainGroupAlgorithm();

		internal static GameObject RouteProgressUIPrefab;

		internal static void Init()
		{
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Expected O, but got Unknown
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Expected O, but got Unknown
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Expected O, but got Unknown
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0132: Expected O, but got Unknown
			//IL_0147: Unknown result type (might be due to invalid IL or missing references)
			//IL_014c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0152: Expected O, but got Unknown
			//IL_01f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fc: Expected O, but got Unknown
			//IL_02b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c3: Expected O, but got Unknown
			//IL_0211: Unknown result type (might be due to invalid IL or missing references)
			//IL_0216: Unknown result type (might be due to invalid IL or missing references)
			//IL_021c: Expected O, but got Unknown
			//IL_02d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e3: Expected O, but got Unknown
			//IL_0231: Unknown result type (might be due to invalid IL or missing references)
			//IL_0236: Unknown result type (might be due to invalid IL or missing references)
			//IL_023c: Expected O, but got Unknown
			//IL_02f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0303: Expected O, but got Unknown
			//IL_0251: Unknown result type (might be due to invalid IL or missing references)
			//IL_0256: Unknown result type (might be due to invalid IL or missing references)
			//IL_025c: Expected O, but got Unknown
			//IL_0271: Unknown result type (might be due to invalid IL or missing references)
			//IL_0276: Unknown result type (might be due to invalid IL or missing references)
			//IL_027c: Expected O, but got Unknown
			//IL_0291: Unknown result type (might be due to invalid IL or missing references)
			//IL_0296: Unknown result type (might be due to invalid IL or missing references)
			//IL_029c: Expected O, but got Unknown
			LethalContent.Moons.AddAutoTaggers(new SimpleAutoTagger<DawnMoonInfo>(Tags.Company, (DawnMoonInfo moonInfo) => !moonInfo.Level.spawnEnemiesAndScrap), new SimpleAutoTagger<DawnMoonInfo>(Tags.Free, (DawnMoonInfo moonInfo) => Object.op_Implicit((Object)(object)moonInfo.RouteNode) && moonInfo.RouteNode.itemCost == 0), new SimpleAutoTagger<DawnMoonInfo>(Tags.Paid, (DawnMoonInfo moonInfo) => Object.op_Implicit((Object)(object)moonInfo.RouteNode) && moonInfo.RouteNode.itemCost > 0), new SimpleAutoTagger<DawnMoonInfo>(DawnLibTags.HasBuyingPercent, (DawnMoonInfo moonInfo) => moonInfo.GetNumberlessPlanetName() == "Gordion"));
			DetourContext val = new DetourContext(2147483637);
			try
			{
				object obj = <>O.<0>__CollectTestLevel;
				if (obj == null)
				{
					hook_Awake val2 = CollectTestLevel;
					<>O.<0>__CollectTestLevel = val2;
					obj = (object)val2;
				}
				StartOfRound.Awake += (hook_Awake)obj;
				object obj2 = <>O.<1>__CollectLevels;
				if (obj2 == null)
				{
					hook_Awake val3 = CollectLevels;
					<>O.<1>__CollectLevels = val3;
					obj2 = (object)val3;
				}
				StartOfRound.Awake += (hook_Awake)obj2;
				if (!DawnConfig.VanillaCompatibility.Value)
				{
					object obj3 = <>O.<2>__SpawnRouteProgressUI;
					if (obj3 == null)
					{
						hook_Awake val4 = SpawnRouteProgressUI;
						<>O.<2>__SpawnRouteProgressUI = val4;
						obj3 = (object)val4;
					}
					StartOfRound.Awake += (hook_Awake)obj3;
					object obj4 = <>O.<3>__RegisterDawnLevels;
					if (obj4 == null)
					{
						hook_Awake val5 = RegisterDawnLevels;
						<>O.<3>__RegisterDawnLevels = val5;
						obj4 = (object)val5;
					}
					Terminal.Awake += (hook_Awake)obj4;
				}
			}
			finally
			{
				((IDisposable)val)?.Dispose();
			}
			LethalContent.Moons.OnFreeze += FixAmbienceLibraries;
			LethalContent.Enemies.OnFreeze += FixDawnMoonEnemies;
			LethalContent.Items.OnFreeze += FixDawnMoonItems;
			if (!DawnConfig.VanillaCompatibility.Value)
			{
				object obj5 = <>O.<7>__StartOfRoundOnChangeLevel;
				if (obj5 == null)
				{
					hook_ChangeLevel val6 = StartOfRoundOnChangeLevel;
					<>O.<7>__StartOfRoundOnChangeLevel = val6;
					obj5 = (object)val6;
				}
				StartOfRound.ChangeLevel += (hook_ChangeLevel)obj5;
				object obj6 = <>O.<8>__StartOfRoundOnClientConnect;
				if (obj6 == null)
				{
					hook_OnClientConnect val7 = StartOfRoundOnClientConnect;
					<>O.<8>__StartOfRoundOnClientConnect = val7;
					obj6 = (object)val7;
				}
				StartOfRound.OnClientConnect += (hook_OnClientConnect)obj6;
				object obj7 = <>O.<9>__StartOfRoundOnClientDisconnect;
				if (obj7 == null)
				{
					hook_OnClientDisconnect val8 = StartOfRoundOnClientDisconnect;
					<>O.<9>__StartOfRoundOnClientDisconnect = val8;
					obj7 = (object)val8;
				}
				StartOfRound.OnClientDisconnect += (hook_OnClientDisconnect)obj7;
				object obj8 = <>O.<10>__DelayTravelEffects;
				if (obj8 == null)
				{
					hook_TravelToLevelEffects val9 = DelayTravelEffects;
					<>O.<10>__DelayTravelEffects = val9;
					obj8 = (object)val9;
				}
				StartOfRound.TravelToLevelEffects += (hook_TravelToLevelEffects)obj8;
				object obj9 = <>O.<11>__DynamicMoonCatalogue;
				if (obj9 == null)
				{
					hook_TextPostProcess val10 = DynamicMoonCatalogue;
					<>O.<11>__DynamicMoonCatalogue = val10;
					obj9 = (object)val10;
				}
				Terminal.TextPostProcess += (hook_TextPostProcess)obj9;
				object obj10 = <>O.<12>__ReplaceStaticOutsideEnemyProbabilityRange;
				if (obj10 == null)
				{
					Manipulator val11 = ReplaceStaticOutsideEnemyProbabilityRange;
					<>O.<12>__ReplaceStaticOutsideEnemyProbabilityRange = val11;
					obj10 = (object)val11;
				}
				RoundManager.PredictAllOutsideEnemies += (Manipulator)obj10;
			}
			if (!MoonDaySpeedMultiplierPatcherCompat.Enabled)
			{
				object obj11 = <>O.<13>__MultiplyGlobalTimeMultiplierToDaySpeedMultiplier;
				if (obj11 == null)
				{
					Manipulator val12 = MultiplyGlobalTimeMultiplierToDaySpeedMultiplier;
					<>O.<13>__MultiplyGlobalTimeMultiplierToDaySpeedMultiplier = val12;
					obj11 = (object)val12;
				}
				TimeOfDay.MoveGlobalTime += (Manipulator)obj11;
				object obj12 = <>O.<14>__IgnoreDaySpeedMultiplier;
				if (obj12 == null)
				{
					Manipulator val13 = IgnoreDaySpeedMultiplier;
					<>O.<14>__IgnoreDaySpeedMultiplier = val13;
					obj12 = (object)val13;
				}
				TimeOfDay.CalculatePlanetTime += (Manipulator)obj12;
				object obj13 = <>O.<14>__IgnoreDaySpeedMultiplier;
				if (obj13 == null)
				{
					Manipulator val14 = IgnoreDaySpeedMultiplier;
					<>O.<14>__IgnoreDaySpeedMultiplier = val14;
					obj13 = (object)val14;
				}
				TimeOfDay.Update += (Manipulator)obj13;
			}
		}

		private static void ReplaceStaticOutsideEnemyProbabilityRange(ILContext il)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_0140: Unknown result type (might be due to invalid IL or missing references)
			//IL_014c: Unknown result type (might be due to invalid IL or missing references)
			ILCursor val = new ILCursor(il);
			int num3 = default(int);
			int num2 = default(int);
			if (!val.TryGotoNext((MoveType)2, new Func<Instruction, bool>[3]
			{
				(Instruction i) => ILPatternMatchingExt.MatchLdloc(i, ref num3),
				(Instruction i) => ILPatternMatchingExt.MatchLdloc(i, ref num2),
				(Instruction i) => ILPatternMatchingExt.MatchLdcR4(i, 3f)
			}))
			{
				DawnPlugin.Logger.LogWarning((object)"Failed to apply RoundManager.PredictAllOutsideEnemies patch (1)");
				return;
			}
			val.Emit(OpCodes.Pop);
			val.Emit(OpCodes.Call, (MethodBase)typeof(MoonRegistrationHandler).GetMethod("GetMoonOutsideEnemyProbabilitySpawnRange", BindingFlags.Static | BindingFlags.NonPublic));
			int num = default(int);
			if (!val.TryGotoNext((MoveType)2, new Func<Instruction, bool>[3]
			{
				(Instruction i) => ILPatternMatchingExt.MatchConvI4(i),
				(Instruction i) => ILPatternMatchingExt.MatchLdloc(i, ref num),
				(Instruction i) => ILPatternMatchingExt.MatchLdcR4(i, 3f)
			}))
			{
				DawnPlugin.Logger.LogWarning((object)"Failed to apply RoundManager.PredictAllOutsideEnemies patch (2)");
				return;
			}
			val.Emit(OpCodes.Pop);
			val.Emit(OpCodes.Call, (MethodBase)typeof(MoonRegistrationHandler).GetMethod("GetMoonOutsideEnemyProbabilitySpawnRange", BindingFlags.Static | BindingFlags.NonPublic));
		}

		private static float GetMoonOutsideEnemyProbabilitySpawnRange()
		{
			if ((Object)(object)StartOfRound.Instance == (Object)null || (Object)(object)StartOfRound.Instance.currentLevel == (Object)null || !StartOfRound.Instance.currentLevel.HasDawnInfo())
			{
				return 3f;
			}
			return StartOfRound.Instance.currentLevel.GetDawnInfo().OutsideEnemiesProbabilityRange;
		}

		private static void MultiplyGlobalTimeMultiplierToDaySpeedMultiplier(ILContext il)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			ILCursor val = new ILCursor(il);
			if (!val.TryGotoNext((MoveType)2, new Func<Instruction, bool>[2]
			{
				(Instruction i) => ILPatternMatchingExt.MatchLdarg(i, 0),
				(Instruction i) => ILPatternMatchingExt.MatchLdfld<TimeOfDay>(i, "globalTimeSpeedMultiplier")
			}))
			{
				DawnPlugin.Logger.LogWarning((object)"Failed to apply TimeOfDay.MoveGlobalTime patch");
				return;
			}
			val.Emit(OpCodes.Ldarg_0);
			val.Emit(OpCodes.Ldfld, typeof(TimeOfDay).GetField("currentLevel"));
			val.Emit(OpCodes.Ldfld, typeof(SelectableLevel).GetField("DaySpeedMultiplier"));
			val.Emit(OpCodes.Mul);
		}

		private static void IgnoreDaySpeedMultiplier(ILContext il)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			//IL_0049: 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)
			ILCursor val = new ILCursor(il);
			if (!val.TryGotoNext((MoveType)2, new Func<Instruction, bool>[1]
			{
				(Instruction i) => ILPatternMatchingExt.MatchLdfld<SelectableLevel>(i, "DaySpeedMultiplier")
			}))
			{
				DawnPlugin.Logger.LogWarning((object)"Failed to apply TimeOfDay.Update patch");
				return;
			}
			val.Emit(OpCodes.Pop);
			val.Emit(OpCodes.Ldc_R4, 1f);
		}

		private static void SpawnRouteProgressUI(orig_Awake orig, StartOfRound self)
		{
			Object.Instantiate<GameObject>(RouteProgressUIPrefab, ((Component)self.radarCanvas).transform);
			orig.Invoke(self);
		}

		private static void FixAmbienceLibraries()
		{
			List<LevelAmbienceLibrary> vanillaLevelAmbienceLibraries = new List<LevelAmbienceLibrary>();
			foreach (DawnMoonInfo value in LethalContent.Moons.Values)
			{
				if (value.TypedKey.IsVanilla())
				{
					if ((Object)(object)value.Level.levelAmbienceClips != (Object)null)
					{
						vanillaLevelAmbienceLibraries.Add(value.Level.levelAmbienceClips);
					}
					vanillaLevelAmbienceLibraries.AddRange(from dungeonFlowType in value.Level.dungeonFlowTypes
						select dungeonFlowType.overrideLevelAmbience into x
						where (Object)(object)x != (Object)null
						select x);
				}
			}
			vanillaLevelAmbienceLibraries = vanillaLevelAmbienceLibraries.Distinct().ToList();
			List<LevelAmbienceLibrary> list = new List<LevelAmbienceLibrary>();
			foreach (DawnMoonInfo value2 in LethalContent.Moons.Values)
			{
				if (value2.ShouldSkipIgnoreOverride())
				{
					continue;
				}
				foreach (LevelAmbienceLibrary item in vanillaLevelAmbienceLibraries)
				{
					if ((Object)(object)value2.Level.levelAmbienceClips != (Object)null && ((Object)value2.Level.levelAmbienceClips).name == ((Object)item).name)
					{
						list.Add(value2.Level.levelAmbienceClips);
						value2.Level.levelAmbienceClips = item;
					}
					for (int i = 0; i < value2.Level.dungeonFlowTypes.Length; i++)
					{
						LevelAmbienceLibrary overrideLevelAmbience = value2.Level.dungeonFlowTypes[i].overrideLevelAmbience;
						if (!((Object)(object)overrideLevelAmbience == (Object)null) && !(((Object)overrideLevelAmbience).name != ((Object)item).name))
						{
							list.Add(overrideLevelAmbience);
							value2.Level.dungeonFlowTypes[i].overrideLevelAmbience = item;
						}
					}
				}
			}
			list = list.Where((LevelAmbienceLibrary x) => !vanillaLevelAmbienceLibraries.Contains(x)).Distinct().ToList();
			for (int num = list.Count - 1; num >= 0; num--)
			{
				Object.Destroy((Object)(object)list[num]);
			}
		}

		private static void RegisterDawnLevels(orig_Awake orig, Terminal self)
		{
			//IL_016b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0175: Expected O, but got Unknown
			//IL_01b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bf: Expected O, but got Unknown
			//IL_01cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d3: Expected O, but got Unknown
			List<SelectableLevel> list = StartOfRoundRefs.Instance.levels.ToList();
			foreach (DawnMoonInfo value in LethalContent.Moons.Values)
			{
				if (!value.ShouldSkipIgnoreOverride())
				{
					value.Level.levelID = list.Count;
					list.Add(value.Level);
					UpdateMoonPrice(value);
				}
			}
			StartOfRoundRefs.Instance.levels = list.ToArray();
			if (LethalContent.Moons.IsFrozen)
			{
				orig.Invoke(self);
				return;
			}
			List<TerminalKeyword> list2 = TerminalRefs.Instance.terminalNodes.allKeywords.ToList();
			List<CompatibleNoun> list3 = TerminalRefs.RouteKeyword.compatibleNouns.ToList();
			List<SelectableLevel> list4 = TerminalRefs.Instance.moonsCatalogueList.ToList();
			foreach (DawnMoonInfo value2 in LethalContent.Moons.Values)
			{
				if (!value2.ShouldSkipIgnoreOverride() && !((Object)(object)value2.ReceiptNode == (Object)null) && !((Object)(object)value2.RouteNode == (Object)null) && !((Object)(object)value2.NameKeyword == (Object)null))
				{
					value2.ReceiptNode.buyRerouteToMoon = value2.Level.levelID;
					value2.RouteNode.displayPlanetInfo = value2.Level.levelID;
					list3.Add(new CompatibleNoun(value2.NameKeyword, value2.RouteNode));
					list2.Add(value2.NameKeyword);
					value2.NameKeyword.defaultVerb = TerminalRefs.RouteKeyword;
					value2.RouteNode.overrideOptions = true;
					value2.RouteNode.terminalOptions = (CompatibleNoun[])(object)new CompatibleNoun[2]
					{
						new CompatibleNoun(TerminalRefs.DenyKeyword, TerminalRefs.CancelRouteNode),
						new CompatibleNoun(TerminalRefs.ConfirmPurchaseKeyword, value2.ReceiptNode)
					};
					if (!(value2.DawnPurchaseInfo.PurchasePredicate.CanPurchase() is TerminalPurchaseResult.HiddenPurchaseResult))
					{
						list4.Add(value2.Level);
					}
				}
			}
			TerminalRefs.Instance.moonsCatalogueList = list4.ToArray();
			TerminalRefs.RouteKeyword.compatibleNouns = list3.ToArray();
			TerminalRefs.Instance.terminalNodes.allKeywords = list2.ToArray();
			orig.Invoke(self);
		}

		[HarmonyPatch(typeof(StartOfRound), "Start")]
		[HarmonyPrefix]
		[HarmonyPriority(-999)]
		private static void FreezeMoonRegistry()
		{
			foreach (DawnMoonInfo value in LethalContent.Moons.Values)
			{
				if (value.Level.indoorMapHazards == null)
				{
					value.Level.indoorMapHazards = Array.Empty<IndoorMapHazard>();
				}
			}
			if (!LethalContent.Moons.IsFrozen)
			{
				LethalContent.Moons.Freeze();
			}
		}

		private static void FixDawnMoonItems()
		{
			List<Item> list = new List<Item>();
			foreach (DawnMoonInfo value in LethalContent.Moons.Values)
			{
				if (value.ShouldSkipIgnoreOverride())
				{
					continue;
				}
				SpawnableItemWithRarity[] array = value.Level.spawnableScrap.ToArray();
				foreach (SpawnableItemWithRarity val in array)
				{
					if ((Object)(object)val.spawnableItem == (Object)null)
					{
						value.Level.spawnableScrap.Remove(val);
						continue;
					}
					bool flag = val.spawnableItem.HasDawnInfo();
					foreach (DawnItemInfo value2 in LethalContent.Items.Values)
					{
						if (!flag && ((Object)value2.Item).name == ((Object)val.spawnableItem).name)
						{
							list.Add(val.spawnableItem);
							val.spawnableItem = value2.Item;
							break;
						}
					}
				}
			}
			for (int num = list.Count - 1; num >= 0; num--)
			{
				Object.Destroy((Object)(object)list[num]);
			}
		}

		private static void FixDawnMoonEnemies()
		{
			List<EnemyType> list = new List<EnemyType>();
			foreach (DawnMoonInfo value in LethalContent.Moons.Values)
			{
				if (value.ShouldSkipIgnoreOverride())
				{
					continue;
				}
				SpawnableEnemyWithRarity[] array = value.Level.Enemies.ToArray();
				foreach (SpawnableEnemyWithRarity val in array)
				{
					if ((Object)(object)val.enemyType == (Object)null)
					{
						value.Level.Enemies.Remove(val);
						continue;
					}
					bool flag = val.enemyType.HasDawnInfo();
					foreach (DawnEnemyInfo value2 in LethalContent.Enemies.Values)
					{
						if (!flag && ((Object)value2.EnemyType).name == ((Object)val.enemyType).name)
						{
							Debuggers.Moons?.Log("replacing fake SO " + ((Object)val.enemyType).name + " with " + ((Object)value2.EnemyType).name);
							list.Add(val.enemyType);
							val.enemyType = value2.EnemyType;
							break;
						}
					}
				}
				SpawnableEnemyWithRarity[] array2 = value.Level.OutsideEnemies.ToArray();
				foreach (SpawnableEnemyWithRarity val2 in array2)
				{
					if ((Object)(object)val2.enemyType == (Object)null)
					{
						value.Level.OutsideEnemies.Remove(val2);
						continue;
					}
					bool flag2 = val2.enemyType.HasDawnInfo();
					foreach (DawnEnemyInfo value3 in LethalContent.Enemies.Values)
					{
						if (!flag2 && ((Object)value3.EnemyType).name == ((Object)val2.enemyType).name)
						{
							Debuggers.Moons?.Log("replacing fake SO " + ((Object)val2.enemyType).name + " with " + ((Object)value3.EnemyType).name);
							list.Add(val2.enemyType);
							val2.enemyType = value3.EnemyType;
							break;
						}
					}
				}
				SpawnableEnemyWithRarity[] array3 = value.Level.DaytimeEnemies.ToArray();
				foreach (SpawnableEnemyWithRarity val3 in array3)
				{
					if ((Object)(object)val3.enemyType == (Object)null)
					{
						value.Level.DaytimeEnemies.Remove(val3);
						continue;
					}
					bool flag3 = val3.enemyType.HasDawnInfo();
					foreach (DawnEnemyInfo value4 in LethalContent.Enemies.Values)
					{
						if (!flag3 && ((Object)value4.EnemyType).name == ((Object)val3.enemyType).name)
						{
							Debuggers.Moons?.Log("replacing fake SO " + ((Object)val3.enemyType).name + " with " + ((Object)value4.EnemyType).name);
							list.Add(val3.enemyType);
							val3.enemyType = value4.EnemyType;
							break;
						}
					}
				}
			}
			for (int num = list.Count - 1; num >= 0; num--)
			{
				Object.Destroy((Object)(object)list[num]);
			}
		}

		private static string DynamicMoonCatalogue(orig_TextPostProcess orig, Terminal self, string modifieddisplaytext, TerminalNode node)
		{
			if ((Object)(object)node != (Object)(object)TerminalRefs.MoonCatalogueNode)
			{
				return orig.Invoke(self, modifieddisplaytext, node);
			}
			StringBuilder stringBuilder = new StringBuilder("\n\nWelcome to the exomoons catalogue.\nTo route the autopilot to a moon, use the word ROUTE.\nTo learn about any moon, use INFO.\n____________________________\n");
			IEnumerable<DawnMoonInfo> input = from it in LethalContent.Moons.Values
				where !it.HasTag(Tags.Unimplemented)
				orderby it.HasTag(Tags.Vanilla) descending
				select it;
			List<MoonGroup> list = MoonGroupAlgorithm.Group(input);
			foreach (MoonGroup item in list)
			{
				stringBuilder.AppendLine("");
				if (!string.IsNullOrWhiteSpace(item.GroupName))
				{
					stringBuilder.AppendLine(item.GroupName);
				}
				foreach (DawnMoonInfo moon in item.Moons)
				{
					TerminalPurchaseResult result = moon.DawnPurchaseInfo.PurchasePredicate.CanPurchase();
					stringBuilder.AppendLine(FormatMoonEntry(moon, result));
				}
			}
			return orig.Invoke(self, stringBuilder.ToString(), node);
		}

		private static string FormatMoonEntry(DawnMoonInfo moonInfo, TerminalPurchaseResult result)
		{
			StringBuilder stringBuilder = new StringBuilder();
			string text = moonInfo.GetNumberlessPlanetName();
			if (result is TerminalPurchaseResult.FailedPurchaseResult failedPurchaseResult)
			{
				text = failedPurchaseResult.OverrideName ?? text;
			}
			if (text == "Gordion")
			{
				text = "The Company building";
			}
			stringBuilder.Append("* " + text + " ");
			if (moonInfo.HasTag(DawnLibTags.HasBuyingPercent))
			{
				stringBuilder.Append("//  Buying at [companyBuyingPercent].");
			}
			else
			{
				DawnWeatherEffectInfo currentWeather = moonInfo.GetCurrentWeather();
				if (currentWeather != null)
				{
					stringBuilder.Append("(" + ((object)(LevelWeatherType)(ref moonInfo.Level.currentWeather)).ToString() + ")");
				}
			}
			return stringBuilder.ToString();
		}

		[IteratorStateMachine(typeof(<DelayTravelEffects>d__15))]
		private static IEnumerator DelayTravelEffects(orig_TravelToLevelEffects orig, StartOfRound self)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <DelayTravelEffects>d__15(0)
			{
				orig = orig,
				self = self
			};
		}

		private static void StartOfRoundOnClientDisconnect(orig_OnClientDisconnect orig, StartOfRound self, ulong clientid)
		{
			orig.Invoke(self, clientid);
			if (((NetworkBehaviour)self).IsServer && self.inShipPhase)
			{
				NetworkSingleton<DawnMoonNetworker>.Instance?.HostRebroadcastQueue();
			}
		}

		private static void StartOfRoundOnClientConnect(orig_OnClientConnect orig, StartOfRound self, ulong clientid)
		{
			orig.Invoke(self, clientid);
			if (((NetworkBehaviour)self).IsServer && self.inShipPhase)
			{
				NetworkSingleton<DawnMoonNetworker>.Instance?.HostRebroadcastQueue();
			}
		}

		private static void StartOfRoundOnChangeLevel(orig_ChangeLevel orig, StartOfRound self, int levelid)
		{
			orig.Invoke(self, levelid);
			if (((NetworkBehaviour)self).IsServer)
			{
				((MonoBehaviour)self).StartCoroutine(DoHotloadSceneStuff(self.currentLevel));
			}
		}

		[IteratorStateMachine(typeof(<DoHotloadSceneStuff>d__19))]
		private static IEnumerator DoHotloadSceneStuff(SelectableLevel level)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <DoHotloadSceneStuff>d__19(0)
			{
				level = level
			};
		}

		private static void CollectLevels(orig_Awake orig, StartOfRound self)
		{
			orig.Invoke(self);
			if (LethalContent.Moons.IsFrozen)
			{
				return;
			}
			_ = TerminalRefs.Instance;
			SelectableLevel[] levels = StartOfRound.Instance.levels;
			foreach (SelectableLevel val in levels)
			{
				if (val.HasDawnInfo())
				{
					continue;
				}
				Debuggers.Moons?.Log($"Registering level: {val.PlanetName} with scrap spawn range of: {val.minScrap} and {val.maxScrap}");
				NamespacedKey<DawnMoonInfo> namespacedKey = MoonKeys.GetByReflection(NamespacedKey.NormalizeStringForNamespacedKey(val.PlanetName, CSharpName: true).RemoveEnd("Level"));
				if (namespacedKey == null && LethalLevelLoaderCompat.Enabled && LethalLevelLoaderCompat.TryGetExtendedLevelModName(val, out string modName))
				{
					namespacedKey = NamespacedKey<DawnMoonInfo>.From(modName, val.PlanetName);
				}
				else if (namespacedKey == null)
				{
					namespacedKey = NamespacedKey<DawnMoonInfo>.From("unknown_modded", val.PlanetName);
				}
				HashSet<NamespacedKey> tags = new HashSet<NamespacedKey> { DawnLibTags.IsExternal };
				CollectLLLTags(val, tags);
				TerminalNode val2 = null;
				TerminalNode receiptNode = null;
				TerminalKeyword nameKeyword = null;
				CompatibleNoun[] compatibleNouns = TerminalRefs.RouteKeyword.compatibleNouns;
				foreach (CompatibleNoun val3 in compatibleNouns)
				{
					if (val3.result.displayPlanetInfo == val.levelID)
					{
						val2 = val3.result;
						if (val2.terminalOptions.Length > 1)
						{
							receiptNode = val2.terminalOptions[1].result;
						}
						nameKeyword = val3.noun;
						break;
					}
				}
				ITerminalPurchasePredicate purchasePredicate = ITerminalPurchasePredicate.AlwaysSuccess();
				if (LethalLevelLoaderCompat.Enabled && LethalLevelLoaderCompat.ExtendedLevelIsModded(val, out object extendedLevelObject))
				{
					purchasePredicate = new LethalLevelLoaderTerminalPredicate(extendedLevelObject);
				}
				else if (LethalLevelLoaderCompat.Enabled && DawnConfig.AllowLLLToOverrideVanillaStatus.Value && namespacedKey.Namespace == "lethal_company")
				{
					purchasePredicate = new LethalLevelLoaderTerminalPredicate(val);
				}
				else if (object.Equals(namespacedKey, MoonKeys.Embrion) || object.Equals(namespacedKey, MoonKeys.Artifice))
				{
					purchasePredicate = new ConstantTerminalPredicate(TerminalPurchaseResult.Hidden().SetFailure(isFailure: false));
				}
				DawnMoonInfo dawnMoonInfo = new DawnMoonInfo(namespacedKey, tags, val, 3f, new List<IMoonSceneInfo>(new <>z__ReadOnlySingleElementList<IMoonSceneInfo>(new VanillaMoonSceneInfo(namespacedKey.AsTyped<IMoonSceneInfo>(), val.sceneName))), val2, receiptNode, nameKeyword, new DawnPurchaseInfo(new SimpleProvider<int>(val2?.itemCost ?? (-1)), purchasePredicate), null);
				val.SetDawnInfo(dawnMoonInfo);
				LethalContent.Moons.Register(dawnMoonInfo);
			}
		}

		private static void CollectTestLevel(orig_Awake orig, StartOfRound self)
		{
			if (LethalContent.Moons.IsFrozen)
			{
				orig.Invoke(self);
				return;
			}
			DawnMoonInfo dawnMoonInfo = new DawnMoonInfo(MoonKeys.Test, new HashSet<NamespacedKey> { DawnLibTags.IsExternal }, self.currentLevel, 3f, new List<IMoonSceneInfo>(), null, null, null, new DawnPurchaseInfo(new SimpleProvider<int>(-1), ITerminalPurchasePredicate.AlwaysHide()), null);
			self.currentLevel.SetDawnInfo(dawnMoonInfo);
			LethalContent.Moons.Register(dawnMoonInfo);
			orig.Invoke(self);
		}

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

		internal static void UpdateAllPrices()
		{
			foreach (DawnMoonInfo value in LethalContent.Moons.Values)
			{
				if (!value.ShouldSkipRespectOverride())
				{
					UpdateMoonPrice(value);
				}
			}
		}

		private static void UpdateMoonPrice(DawnMoonInfo moonInfo)
		{
			int itemCost = moonInfo.DawnPurchaseInfo.Cost.Provide();
			if ((Object)(object)moonInfo.RouteNode != (Object)null)
			{
				moonInfo.RouteNode.itemCost = itemCost;
			}
			if ((Object)(object)moonInfo.ReceiptNode != (Object)null)
			{
				moonInfo.ReceiptNode.itemCost = itemCost;
			}
		}
	}
	public class DawnMoonInfo : DawnBaseInfo<DawnMoonInfo>
	{
		public SelectableLevel Level { get; }

		public TerminalNode? RouteNode { get; }

		public TerminalNode? ReceiptNode { get; }

		public TerminalKeyword? NameKeyword { get; }

		public float OutsideEnemiesProbabilityRange { get; private set; }

		public List<IMoonSceneInfo> Scenes { get; } = new List<IMoonSceneInfo>();


		public DawnPurchaseInfo DawnPurchaseInfo { get; }

		internal DawnMoonInfo(NamespacedKey<DawnMoonInfo> key, HashSet<NamespacedKey> tags, SelectableLevel level, float outsideEnemiesProbabilityRange, List<IMoonSceneInfo> scenes, TerminalNode? routeNode, TerminalNode? receiptNode, TerminalKeyword? nameKeyword, DawnPurchaseInfo dawnPurchaseInfo, IDataContainer? customData)
			: base(key, tags, customData)
		{
			Level = level;
			OutsideEnemiesProbabilityRange = outsideEnemiesProbabilityRange;
			Scenes.AddRange(scenes);
			RouteNode = routeNode;
			ReceiptNode = receiptNode;
			NameKeyword = nameKeyword;
			DawnPurchaseInfo = dawnPurchaseInfo;
		}

		public DawnWeatherEffectInfo? GetCurrentWeather()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Invalid comparison between Unknown and I4
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			LevelWeatherType currentWeather = Level.currentWeather;
			if ((int)currentWeather == -1)
			{
				return null;
			}
			WeatherEffect weatherEffect = TimeOfDay.Instance.effects[currentWeather];
			if (weatherEffect.HasDawnInfo())
			{
				return weatherEffect.GetDawnInfo();
			}
			return null;
		}

		public string GetConfigName()
		{
			string text = StripSpecialCharacters(Level.PlanetName);
			if (!text.EndsWith("Level", ignoreCase: true, CultureInfo.InvariantCulture))
			{
				text += "Level";
			}
			return text.ToLowerInvariant();
		}

		public string GetNumberlessPlanetName()
		{
			return StripSpecialCharacters(Level.PlanetName);
		}

		public void RouteTo()
		{
			int num = Array.IndexOf(StartOfRound.Instance.levels, Level);
			StartOfRound.Instance.ChangeLevelServerRpc(num, TerminalRefs.Instance.groupCredits);
		}

		public void ChangeWeatherTo(LevelWeatherType levelWeatherType)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			if (WeatherRegistryCompat.Enabled)
			{
				WeatherRegistryCompat.SetCurrentWeather(Level, levelWeatherType);
				return;
			}
			EveryoneRpcTarget val = new EveryoneRpcTarget(NetworkManager.Singleton);
			NetworkSingleton<DawnNetworker>.Instance.ChangeWeatherToRpc(base.Key, levelWeatherType, RpcParams.op_Implicit((BaseRpcTarget)(object)val));
			((BaseRpcTarget)val).Dispose();
		}

		public void ChangeWeatherTo(DawnWeatherEffectInfo weatherEffectInfo)
		{
			ChangeWeatherTo((LevelWeatherType)MiscHelpers.IndexOf<WeatherEffect>((IEnumerable<WeatherEffect>)TimeOfDayRefs.Instance.effects, weatherEffectInfo.WeatherEffect));
		}

		private static string StripSpecialCharacters(string input)
		{
			string text = string.Empty;
			for (int i = 0; i < input.Length; i++)
			{
				char c = input[i];
				if (char.IsLetter(c))
				{
					text += c;
				}
			}
			return text;
		}
	}
	public class MoonGroup
	{
		public string GroupName = "";

		public List<DawnMoonInfo> Moons = new List<DawnMoonInfo>();
	}
	public interface IMoonFilterStep
	{
		IEnumerable<DawnMoonInfo> Filter(IEnumerable<DawnMoonInfo> input);
	}
	public interface IMoonOrderingStep
	{
		IOrderedEnumerable<DawnMoonInfo> ApplyInitial(IEnumerable<DawnMoonInfo> input, bool reverse = false);

		IOrderedEnumerable<DawnMoonInfo> ApplyNext(IOrderedEnumerable<DawnMoonInfo> input, bool reverse = false);
	}
	public interface IMoonGroupingAlgorithm
	{
		List<MoonGroup> Group(IEnumerable<DawnMoonInfo> input);
	}
	public class VisibleFilterStep : IMoonFilterStep
	{
		public IEnumerable<DawnMoonInfo> Filter(IEnumerable<DawnMoonInfo> input)
		{
			return input.Where((DawnMoonInfo moon) => !(moon.DawnPurchaseInfo.PurchasePredicate.CanPurchase() is TerminalPurchaseResult.HiddenPurchaseResult));
		}
	}
	public class TagFilterStep : IMoonFilterStep
	{
		[CompilerGenerated]
		private NamespacedKey <tag>P;

		public TagFilterStep(NamespacedKey tag)
		{
			<tag>P = tag;
			base..ctor();
		}

		public IEnumerable<DawnMoonInfo> Filter(IEnumerable<DawnMoonInfo> input)
		{
			return input.Where((DawnMoonInfo moon) => moon.HasTag(<tag>P));
		}
	}
	public class FixedGroupSizeGroupingAlgorithm : IMoonGroupingAlgorithm
	{
		[CompilerGenerated]
		private int <groupSize>P;

		public FixedGroupSizeGroupingAlgorithm(int groupSize = 3)
		{
			<groupSize>P = groupSize;
			base..ctor();
		}

		public List<MoonGroup> Group(IEnumerable<DawnMoonInfo> input)
		{
			MoonGroup moonGroup = new MoonGroup();
			MoonGroup moonGroup2 = new MoonGroup();
			List<MoonGroup> list = new List<MoonGroup>(1) { moonGroup2 };
			int num = 0;
			foreach (DawnMoonInfo item in input)
			{
				if (item.HasTag(Tags.Company))
				{
					moonGroup.Moons.Add(item);
					continue;
				}
				moonGroup2.Moons.Add(item);
				if (!(item.DawnPurchaseInfo.PurchasePredicate.CanPurchase() is TerminalPurchaseResult.HiddenPurchaseResult))
				{
					num++;
				}
				if (num == <groupSize>P)
				{
					moonGroup2 = new MoonGroup();
					num = 0;
					list.Add(moonGroup2);
				}
			}
			list.RemoveAll((MoonGroup group) => group.Moons.Count == 0);
			if (moonGroup.Moons.Count > 0)
			{
				list.Insert(0, moonGroup);
			}
			return list;
		}
	}
	public class RankOrderingStep : IMoonOrderingStep
	{
		private static readonly string[] RiskIndexes = new string[8] { "F", "E", "D", "C", "B", "A", "S", "UNKNOWN" };

		public IOrderedEnumerable<DawnMoonInfo> ApplyInitial(IEnumerable<DawnMoonInfo> input, bool reverse = false)
		{
			if (!reverse)
			{
				return input.OrderBy(GetRiskIndex);
			}
			return input.OrderByDescending(GetRiskIndex);
		}

		public IOrderedEnumerable<DawnMoonInfo> ApplyNext(IOrderedEnumerable<DawnMoonInfo> input, bool reverse = false)
		{
			if (!reverse)
			{
				return input.ThenBy(GetRiskIndex);
			}
			return input.ThenByDescending(GetRiskIndex);
		}

		private int GetRiskIndex(DawnMoonInfo moonInfo)
		{
			string input = moonInfo.Level.riskLevel ?? "UNKNOWN";
			input = input.StripSpecialCharacters();
			int num = Array.IndexOf(RiskIndexes, input);
			if (num < 0)
			{
				return RiskIndexes.Length - 1;
			}
			return num;
		}
	}
	public class PriceOrderingStep : IMoonOrderingStep
	{
		public IOrderedEnumerable<DawnMoonInfo> ApplyInitial(IEnumerable<DawnMoonInfo> input, bool reverse = false)
		{
			if (!reverse)
			{
				return input.OrderBy(GetPrice);
			}
			return input.OrderByDescending(GetPrice);
		}

		public IOrderedEnumerable<DawnMoonInfo> ApplyNext(IOrderedEnumerable<DawnMoonInfo> input, bool reverse = false)
		{
			if (!reverse)
			{
				return input.ThenBy(GetPrice);
			}
			return input.ThenByDescending(GetPrice);
		}

		private int GetPrice(DawnMoonInfo moonInfo)
		{
			return moonInfo.DawnPurchaseInfo.Cost.Provide();
		}
	}
	public class IndexBasedOrderingStep : IMoonOrderingStep
	{
		public IOrderedEnumerable<DawnMoonInfo> ApplyInitial(IEnumerable<DawnMoonInfo> input, bool reverse = false)
		{
			if (!reverse)
			{
				return input.OrderBy(GetIndex);
			}
			return input.OrderByDescending(GetIndex);
		}

		public IOrderedEnumerable<DawnMoonInfo> ApplyNext(IOrderedEnumerable<DawnMoonInfo> input, bool reverse = false)
		{
			if (!reverse)
			{
				return input.ThenBy(GetIndex);
			}
			return input.ThenByDescending(GetIndex);
		}

		private int GetIndex(DawnMoonInfo moonInfo)
		{
			return LethalContent.Moons.Values.ToList().IndexOf(moonInfo);
		}
	}
	public class MainGroupAlgorithm
	{
		public List<IMoonFilterStep> FilterSteps = new List<IMoonFilterStep>(1)
		{
			new VisibleFilterStep()
		};

		public List<IMoonOrderingStep> OrderingSteps = new List<IMoonOrderingStep>(3)
		{
			new RankOrderingStep(),
			new PriceOrderingStep(),
			new IndexBasedOrderingStep()
		};

		public IMoonGroupingAlgorithm GroupingAlgorithm = new FixedGroupSizeGroupingAlgorithm();

		public List<MoonGroup> Group(IEnumerable<DawnMoonInfo> input, bool reverse = false)
		{
			IEnumerable<DawnMoonInfo> enumerable = input;
			foreach (IMoonFilterStep filterStep in FilterSteps)
			{
				enumerable = filterStep.Filter(enumerable);
			}
			IOrderedEnumerable<DawnMoonInfo> orderedEnumerable = null;
			for (int i = 0; i < OrderingSteps.Count; i++)
			{
				IMoonOrderingStep moonOrderingStep = OrderingSteps[i];
				orderedEnumerable = ((i == 0) ? moonOrderingStep.ApplyInitial(enumerable, reverse) : moonOrderingStep.ApplyNext(orderedEnumerable, reverse));
			}
			IEnumerable<DawnMoonInfo> enumerable2 = orderedEnumerable;
			IEnumerable<DawnMoonInfo> input2 = enumerable2 ?? enumerable;
			return GroupingAlgorithm.Group(input2);
		}
	}
	public class MoonInfoBuilder : BaseInfoBuilder<DawnMoonInfo, SelectableLevel, MoonInfoBuilder>
	{
		private TerminalNode? _routeNode;

		private TerminalNode? _receiptNode;

		private TerminalKeyword? _nameKeyword;

		private List<IMoonSceneInfo> _scenes = new List<IMoonSceneInfo>();

		private IProvider<int>? _costOverride;

		private ITerminalPurchasePredicate? _purchasePredicate;

		private float _outsideEnemiesProbabilityRange = 3f;

		public MoonInfoBuilder(NamespacedKey<DawnMoonInfo> key, SelectableLevel value)
			: base(key, value)
		{
		}

		public MoonInfoBuilder OverrideRouteNode(TerminalNode node)
		{
			_routeNode = node;
			return this;
		}

		public MoonInfoBuilder CreateNameKeyword(string wordOverride)
		{
			if (string.IsNullOrWhiteSpace(wordOverride))
			{
				wordOverride = base.value.PlanetName.ToLowerInvariant().Replace(' ', '-');
			}
			_nameKeyword = new TerminalKeywordBuilder(base.value.PlanetName + "NameKeyword", wordOverride, (DawnKeywordType)3).Build();
			_nameKeyword.compatibleNouns = Array.Empty<CompatibleNoun>();
			return this;
		}

		public MoonInfoBuilder AddScene(NamespacedKey<IMoonSceneInfo> sceneKey, AnimationClip shipLandingOverrideAnimation, AnimationClip shipTakeoffOverrideAnimation, ProviderTable<int?, DawnMoonInfo, SpawnWeightContext> weight, string assetBundlePath, string scenePath)
		{
			_scenes.Add(new CustomMoonSceneInfo(sceneKey, shipLandingOverrideAnimation, shipTakeoffOverrideAnimation, weight, assetBundlePath, scenePath));
			return this;
		}

		private static string StripSpecialCharacters(string input)
		{
			string text = string.Empty;
			for (int i = 0; i < input.Length; i++)
			{
				char c = input[i];
				if (char.IsLetter(c))
				{
					text += c;
				}
			}
			return text;
		}

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

		public MoonInfoBuilder OverrideTimeMultiplier(float multiplier)
		{
			base.value.DaySpeedMultiplier = multiplier;
			return this;
		}

		public MoonInfoBuilder OverrideMinMaxScrap(BoundedRange range)
		{
			base.value.minScrap = (int)range.Min;
			base.value.maxScrap = (int)range.Max;
			return this;
		}

		public MoonInfoBuilder OverrideEnemyPowerCount(int maxInsidePowerCount, int maxOutsidePowerCount, int maxDaytimePowerCount)
		{
			base.value.maxEnemyPowerCount = maxInsidePowerCount;
			base.value.maxOutsideEnemyPowerCount = maxOutsidePowerCount;
			base.value.maxDaytimeEnemyPowerCount = maxDaytimePowerCount;
			return this;
		}

		public MoonInfoBuilder OverrideEnemySpawnCurves(AnimationCurve insideAnimationCurve, AnimationCurve outsideAnimationCurve, AnimationCurve daytimeAnimationCurve)
		{
			base.value.enemySpawnChanceThroughoutDay = insideAnimationCurve;
			base.value.outsideEnemySpawnChanceThroughDay = outsideAnimationCurve;
			base.value.daytimeEnemySpawnChanceThroughDay = daytimeAnimationCurve;
			return this;
		}

		public MoonInfoBuilder OverrideEnemySpawnRanges(float insideSpawnRange, float outsideSpawnRange, float daytimeSpawnRange)
		{
			base.value.spawnProbabilityRange = insideSpawnRange;
			_outsideEnemiesProbabilityRange = outsideSpawnRange;
			base.value.daytimeEnemiesProbabilityRange = daytimeSpawnRange;
			return this;
		}

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

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

		internal override DawnMoonInfo Build()
		{
			if ((Object)(object)_routeNode == (Object)null)
			{
				_routeNode = new TerminalNodeBuilder(base.value.PlanetName + "RouteNode").SetDisplayText("The cost to route to " + base.value.PlanetName + " is [totalCost]. It is \ncurrently [currentPlanetTime] on this moon.\n\nPlease CONFIRM or DENY.\n\n").SetClearPreviousText(clearPreviousText: true).SetMaxCharactersToType(25)
					.Build();
			}
			if ((Object)(object)_receiptNode == (Object)null)
			{
				_receiptNode = new TerminalNodeBuilder(base.value.PlanetName + "RecieptNode").SetDisplayText("Routing autopilot to " + base.value.PlanetName + ".\nYour new balance is [playerCredits].\n\nPlease enjoy your flight.\n\n").SetClearPreviousText(clearPreviousText: true).SetMaxCharactersToType(25)
					.Build();
			}
			if ((Object)(object)_nameKeyword == (Object)null)
			{
				CreateNameKeyword(StripSpecialCharacters(base.value.PlanetName).ToLowerInvariant());
			}
			if (_scenes.Count == 0)
			{
				DawnPlugin.Logger.LogError((object)$"Moon: '{base.key}' has 0 scenes.");
			}
			if (_purchasePredicate == null)
			{
				_purchasePredicate = ITerminalPurchasePredicate.AlwaysSuccess();
			}
			if (_costOverride == null)
			{
				_costOverride = new SimpleProvider<int>(_routeNode.itemCost);
			}
			return new DawnMoonInfo(base.key, tags, base.value, _outsideEnemiesProbabilityRange, _scenes, _routeNode, _receiptNode, _nameKeyword, new DawnPurchaseInfo(_costOverride, _purchasePredicate), customData);
		}
	}
	public interface IMoonSceneInfo : INamespaced<IMoonSceneInfo>, INamespaced
	{
		string SceneName { get; }

		ProviderTable<int?, DawnMoonInfo, SpawnWeightContext> Weight { get; }
	}
	public class VanillaMoonSceneInfo : IMoonSceneInfo, INamespaced<IMoonSceneInfo>, INamespaced
	{
		public string SceneName { get; private set; }

		public ProviderTable<int?, DawnMoonInfo, SpawnWeightContext> Weight { get; private set; } = new WeightTableBuilder<DawnMoonInfo, SpawnWeightContext>().SetGlobalWeight(100).Build();


		public NamespacedKey Key => TypedKey;

		public NamespacedKey<IMoonSceneInfo> TypedKey { get; }

		internal VanillaMoonSceneInfo(NamespacedKey<IMoonSceneInfo> key, string sceneName)
		{
			SceneName = sceneName;
			TypedKey = key;
		}

		public int GetWeight()
		{
			return 100;
		}
	}
	public class CustomMoonSceneInfo : IMoonSceneInfo, INamespaced<IMoonSceneInfo>, INamespaced
	{
		internal string AssetBundlePath;

		public string SceneName { get; }

		public string ScenePath { get; }

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

		public AnimationClip? ShipLandingOverrideAnimation { get; private set; }

		public AnimationClip? ShipTakeoffOverrideAnimation { get; private set; }

		public NamespacedKey Key => TypedKey;

		public NamespacedKey<IMoonSceneInfo> TypedKey { get; }

		internal CustomMoonSceneInfo(NamespacedKey<IMoonSceneInfo> key, AnimationClip? shipLandingOverrideAnimation, AnimationClip? shipTakeoffOverrideAnimation, ProviderTable<int?, DawnMoonInfo, SpawnWeightContext> weight, string assetBundlePath, string scenePath)
		{
			AssetBundlePath = assetBundlePath;
			Weight = weight;
			TypedKey = key;
			ShipLandingOverrideAnimation = shipLandingOverrideAnimation;
			ShipTakeoffOverrideAnimation = shipTakeoffOverrideAnimation;
			ScenePath = scenePath;
			SceneName = DawnNetworkSceneManager.GetSceneNameFromPath(scenePath);
			DawnLib.RegisterNetworkScene(scenePath);
		}
	}
	public static class SelectableLevelExtensions
	{
		public static DawnMoonInfo GetDawnInfo(this SelectableLevel selectableLevel)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return (DawnMoonInfo)((IDawnObject)selectableLevel).DawnInfo;
		}

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

		internal static void SetDawnInfo(this SelectableLevel level, DawnMoonInfo moonInfo)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			((IDawnObject)level).DawnInfo = moonInfo;
		}
	}
	public class RegistryFrozenException : Exception
	{
		public RegistryFrozenException()
			: base("Registry is frozen")
		{
		}
	}
	public class Registry<T> : IReadOnlyDictionary<NamespacedKey<T>, T>, IEnumerable<KeyValuePair<NamespacedKey<T>, T>>, IEnumerable, IReadOnlyCollection<KeyValuePair<NamespacedKey<T>, T>> where T : INamespaced<T>
	{
		private readonly Dictionary<NamespacedKey<T>, T> _dictionary = new Dictionary<NamespacedKey<T>, T>();

		public bool IsFrozen { get; private set; }

		public int Count => _dictionary.Count;

		public T this[NamespacedKey<T> key] => _dictionary[key];

		public IEnumerable<NamespacedKey<T>> Keys => _dictionary.Keys;

		public IEnumerable<T> Values => _dictionary.Values;

		public event Action BeforeFreeze
		{
			add
			{
				Action value2 = value;
				_beforeFreeze += delegate
				{
					try
					{
						value2();
					}
					catch (Exception arg)
					{
						DawnPlugin.Logger.LogError((object)$"(BeforeFreeze) An exception occured in firing an event for a registry:\n{arg}");
					}
				};
			}
			remove
			{
				DawnPlugin.Logger.LogError((object)"Registry.BeforeFreeze -= is not supported.");
			}
		}

		public event Action OnFreeze
		{
			add
			{
				Action value2 = value;
				_onFreeze += delegate
				{
					try
					{
						value2();
					}
					catch (Exception arg)
					{
						DawnPlugin.Logger.LogError((object)$"(OnFreeze) An exception occured in firing an event for a registry:\n{arg}");
					}
				};
			}
			remove
			{
				DawnPlugin.Logger.LogError((object)"Registry.OnFreeze -= is not supported.");
			}
		}

		public event Action _onFreeze = delegate
		{
		};

		public event Action _beforeFreeze = delegate
		{
		};

		internal virtual void Freeze()
		{
			if (IsFrozen)
			{
				throw new RegistryFrozenException();
			}
			this._beforeFreeze();
			IsFrozen = true;
			foreach (T value in Values)
			{
				if ((object)value is IRegistryEvents registryEvents)
				{
					registryEvents.OnFrozen();
				}
			}
			this._onFreeze();
		}

		internal virtual void Register(T value)
		{
			if (IsFrozen)
			{
				throw new RegistryFrozenException();
			}
			NamespacedKey<T> typedKey = value.TypedKey;
			if (ContainsKey(typedKey))
			{
				throw new ArgumentException($"'{typedKey}' has already been added to this registry.");
			}
			_dictionary[typedKey] = value;
		}

		public IEnumerator<KeyValuePair<NamespacedKey<T>, T>> GetEnumerator()
		{
			return _dictionary.GetEnumerator();
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return GetEnumerator();
		}

		public bool ContainsKey(NamespacedKey<T> key)
		{
			return _dictionary.ContainsKey(key);
		}

		public bool TryGetValue(NamespacedKey<T> key, out T value)
		{
			return _dictionary.TryGetValue(key, out value);
		}

		public bool TryGetValue(NamespacedKey key, out T value)
		{
			return TryGetValue(key.AsTyped<T>(), out value);
		}
	}
	public interface IRegistryEvents
	{
		void OnFrozen();
	}
	internal static class StoryLogRegistrationHandler
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static hook_Start <0>__CollectAllStoryLogs;

			public static hook_Start <1>__RegisterStoryLogs;
		}

		private static List<GameObject> _networkPrefabStoryLogTypes = new List<GameObject>();

		internal static void Init()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Expected O, but got Unknown
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Expected O, but got Unknown
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Expected O, but got Unknown
			DetourContext val = new DetourContext(int.MaxValue);
			try
			{
				object obj = <>O.<0>__CollectAllStoryLogs;
				if (obj == null)
				{
					hook_Start val2 = CollectAllStoryLogs;
					<>O.<0>__CollectAllStoryLogs = val2;
					obj = (object)val2;
				}
				GameNetworkManager.Start += (hook_Start)obj;
			}
			finally
			{
				((IDisposable)val)?.Dispose();
			}
			object obj2 = <>O.<1>__RegisterStoryLogs;
			if (obj2 == null)
			{
				hook_Start val3 = RegisterStoryLogs;
				<>O.<1>__RegisterStoryLogs = val3;
				obj2 = (object)val3;
			}
			Terminal.Start += (hook_Start)obj2;
		}

		private static void RegisterStoryLogs(orig_Start orig, Terminal self)
		{
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Expected O, but got Unknown
			orig.Invoke(self);
			_ = TerminalRefs.Instance;
			List<CompatibleNoun> list = TerminalRefs.ViewKeyword.compatibleNouns.ToList();
			List<TerminalKeyword> list2 = TerminalRefs.Instance.terminalNodes.allKeywords.ToList();
			foreach (DawnStoryLogInfo value2 in LethalContent.StoryLogs.Values)
			{
				if (!value2.ShouldSkipIgnoreOverride())
				{
					self.logEntryFiles.Add(value2.StoryLogTerminalNode);
					if (!LethalContent.StoryLogs.IsFrozen)
					{
						value2.StoryLogTerminalKeyword.defaultVerb = TerminalRefs.ViewKeyword;
						int num = self.logEntryFiles.Count - 1;
						value2.StoryLogGameObject.GetComponent<StoryLog>().SetStoryLogID(num);
						value2.StoryLogTerminalNode.storyLogFileID = num;
						CompatibleNoun item = new CompatibleNoun(value2.StoryLogTerminalKeyword, value2.StoryLogTerminalNode);
						list.Add(item);
						list2.Add(value2.StoryLogTerminalKeyword);
					}
				}
			}
			if (LethalContent.StoryLogs.IsFrozen)
			{
				return;
			}
			TerminalRefs.Instance.terminalNodes.allKeywords = list2.ToArray();
			TerminalRefs.ViewKeyword.compatibleNouns = list.ToArray();
			foreach (CompatibleNoun item2 in TerminalRefs.ViewKeyword.compatibleNouns.Where((CompatibleNoun x) => (Object)(object)x.result != (Object)null && x.result.storyLogFileID > -1))
			{
				string name = NamespacedKey.NormalizeStringForNamespacedKey(item2.result.creatureName, CSharpName: true);
				NamespacedKey<DawnStoryLogInfo> namespacedKey = StoryLogKeys.GetByReflection(name);
				if (namespacedKey == null)
				{
					namespacedKey = NamespacedKey<DawnStoryLogInfo>.From("unknown_lib", item2.result.creatureName);
				}
				if (LethalContent.StoryLogs.ContainsKey(namespacedKey))
				{
					DawnPlugin.Logger.LogWarning((object)("StoryLog " + item2.result.creatureName + " is already registered by the same creator to LethalContent. This is likely to cause issues."));
					continue;
				}
				GameObject storyLogGameObject = null;
				foreach (GameObject networkPrefabStoryLogType in _networkPrefabStoryLogTypes)
				{
					if (networkPrefabStoryLogType.GetComponent<StoryLog>().storyLogID == item2.result.storyLogFileID)
					{
						storyLogGameObject = networkPrefabStoryLogType;
						break;
					}
				}
				DawnStoryLogInfo value = new DawnStoryLogInfo(namespacedKey, new HashSet<NamespacedKey> { DawnLibTags.IsExternal }, storyLogGameObject, item2.result, item2.noun, null);
				LethalContent.StoryLogs.Register(value);
			}
			LethalContent.StoryLogs.Freeze();
		}

		private static void CollectAllStoryLogs(orig_Start orig, GameNetworkManager self)
		{
			orig.Invoke(self);
			StoryLog val = default(StoryLog);
			foreach (NetworkPrefab prefab in NetworkManager.Singleton.NetworkConfig.Prefabs.Prefabs)
			{
				if (prefab.Prefab.TryGetComponent<StoryLog>(ref val) && !_networkPrefabStoryLogTypes.Contains(prefab.Prefab))
				{
					_networkPrefabStoryLogTypes.Add(prefab.Prefab);
				}
			}
		}
	}
	public sealed class DawnStoryLogInfo : DawnBaseInfo<DawnStoryLogInfo>
	{
		public GameObject? StoryLogGameObject { get; }

		public TerminalNode StoryLogTerminalNode { get; }

		public TerminalKeyword StoryLogTerminalKeyword { get; }

		internal DawnStoryLogInfo(NamespacedKey<DawnStoryLogInfo> key, HashSet<NamespacedKey> tags, GameObject? storyLogGameObject, TerminalNode storyLogTerminalNode, TerminalKeyword storyLogTerminalKeyword, IDataContainer? customData)
			: base(key, tags, customData)
		{
			StoryLogGameObject = storyLogGameObject;
			StoryLogTerminalNode = storyLogTerminalNode;
			StoryLogTerminalKeyword = storyLogTerminalKeyword;
		}
	}
	public class StoryLogInfoBuilder : BaseInfoBuilder<DawnStoryLogInfo, GameObject, StoryLogInfoBuilder>
	{
		private TerminalNode? _storyLogTerminalNode;

		private string _storyLogTitle;

		private string _storyLogKeyword;

		private string _storyLogDescription = "The developer of this story log left this empty!";

		public StoryLogInfoBuilder(NamespacedKey<DawnStoryLogInfo> key, GameObject value)
			: base(key, value)
		{
		}

		public StoryLogInfoBuilder OverrideTerminalNode(TerminalNode? terminalNode)
		{
			_storyLogTerminalNode = terminalNode;
			return this;
		}

		public StoryLogInfoBuilder SetDescription(string description)
		{
			_storyLogDescription = description;
			return this;
		}

		public StoryLogInfoBuilder SetTitle(string title)
		{
			_storyLogTitle = title;
			return this;
		}

		public StoryLogInfoBuilder SetKeyword(string keyword)
		{
			_storyLogKeyword = keyword.ToLowerInvariant();
			return this;
		}

		internal override DawnStoryLogInfo Build()
		{
			if ((Object)(object)_storyLogTerminalNode == (Object)null)
			{
				_storyLogTerminalNode = new TerminalNodeBuilder($"{base.key}TerminalNode").SetClearPreviousText(clearPreviousText: true).SetCreatureName(_storyLogTitle).SetMaxCharactersToType(35)
					.SetDisplayText(_storyLogDescription)
					.Build();
			}
			if (string.IsNullOrEmpty(_storyLogKeyword))
			{
				DawnPlugin.Logger.LogWarning((object)$"StoryLog: '{base.key}' didn't set keyword, please call .SetKeyword on the builder.");
			}
			TerminalKeyword storyLogTerminalKeyword = new TerminalKeywordBuilder($"{base.key}TerminalKeyword", _storyLogKeyword, (DawnKeywordType)7).Build();
			return new DawnStoryLogInfo(base.key, tags, base.value, _storyLogTerminalNode, storyLogTerminalKeyword, customData);
		}
	}
	[HarmonyPatch]
	internal static class SurfaceRegistrationHandler
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static hook_Awake <0>__RegisterDawnSurfaces;

			public static Manipulator <1>__PlayerGetCurrentMaterialStandingOn;

			public static Manipulator <2>__EditGravityDirection;

			public static Manipulator <3>__EditFallValueForGravity;

			public static Manipulator <4>__EditUncappedFallValueForGravity;

			public static Manipulator <5>__AllowCustomSurfacesInQuicksand;

			public static Manipulator <6>__AllowEmergingAtCustomSurfaces;

			public static UnityAction<Scene, LoadSceneMode> <7>__OnVowOrMarchLoaded;

			public static UnityAction<Scene, LoadSceneMode> <8>__TryFixMoonTerrainFootsteps;

			public static hook_Start <9>__AddCrouchingFootsteps;

			public static Action<Action<PlayerAnimationEvents>, PlayerAnimationEvents> <10>__PlayCrouchFootstepSound;
		}

		private static readonly List<AnimationEventData> CrouchingAnimationEvents = new List<AnimationEventData>
		{
			new AnimationEventData
			{
				AnimationEventName = "PlayCrouchFootstepSound",
				Time = 0.33f
			},
			new AnimationEventData
			{
				AnimationEventName = "PlayCrouchFootstepSound",
				Time = 0.66f
			}
		};

		private static bool addedCrouchingSteps = false;

		internal static void Init()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Expected O, but got Unknown
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Expected O, but got Unknown
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Expected O, but got Unknown
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Expected O, but got Unknown
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Expected O, but got Unknown
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Expected O, but got Unknown
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Expected O, but got Unknown
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: Expected O, but got Unknown
			//IL_016f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0174: Unknown result type (might be due to invalid IL or missing references)
			//IL_017a: Expected O, but got Unknown
			//IL_01b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bf: Expected O, but got Unknown
			DetourContext val = new DetourContext(int.MaxValue);
			try
			{
				object obj = <>O.<0>__RegisterDawnSurfaces;
				if (obj == null)
				{
					hook_Awake val2 = RegisterDawnSurfaces;
					<>O.<0>__RegisterDawnSurfaces = val2;
					obj = (object)val2;
				}
				StartOfRound.Awake += (hook_Awake)obj;
			}
			finally
			{
				((IDisposable)val)?.Dispose();
			}
			object obj2 = <>O.<1>__PlayerGetCurrentMaterialStandingOn;
			if (obj2 == null)
			{
				Manipulator val3 = PlayerGetCurrentMaterialStandingOn;
				<>O.<1>__PlayerGetCurrentMaterialStandingOn = val3;
				obj2 = (object)val3;
			}
			PlayerControllerB.GetCurrentMaterialStandingOn += (Manipulator)obj2;
			object obj3 = <>O.<2>__EditGravityDirection;
			if (obj3 == null)
			{
				Manipulator val4 = EditGravityDirection;
				<>O.<2>__EditGravityDirection = val4;
				obj3 = (object)val4;
			}
			PlayerControllerB.Update += (Manipulator)obj3;
			object obj4 = <>O.<3>__EditFallValueForGravity;
			if (obj4 == null)
			{
				Manipulator val5 = EditFallValueForGravity;
				<>O.<3>__EditFallValueForGravity = val5;
				obj4 = (object)val5;
			}
			PlayerControllerB.Update += (Manipulator)obj4;
			object obj5 = <>O.<4>__EditUncappedFallValueForGravity;
			if (obj5 == null)
			{
				Manipulator val6 = EditUncappedFallValueForGravity;
				<>O.<4>__EditUncappedFallValueForGravity = val6;
				obj5 = (object)val6;
			}
			PlayerControllerB.Update += (Manipulator)obj5;
			PlayerControllerB.PlayFootstepSound += EditFootstepSound(typeof(PlayerControllerB));
			MaskedPlayerEnemy.PlayFootstepSound += EditFootstepSound(typeof(MaskedPlayerEnemy));
			object obj6 = <>O.<5>__AllowCustomSurfacesInQuicksand;
			if (obj6 == null)
			{
				Manipulator val7 = AllowCustomSurfacesInQuicksand;
				<>O.<5>__AllowCustomSurfacesInQuicksand = val7;
				obj6 = (object)val7;
			}
			PlayerControllerB.CheckConditionsForSinkingInQuicksand += (Manipulator)obj6;
			object obj7 = <>O.<6>__AllowEmergingAtCustomSurfaces;
			if (obj7 == null)
			{
				Manipulator val8 = AllowEmergingAtCustomSurfaces;
				<>O.<6>__AllowEmergingAtCustomSurfaces = val8;
				obj7 = (object)val8;
			}
			SandWormAI.StartEmergeAnimation += (Manipulator)obj7;
			SceneManager.sceneLoaded += OnVowOrMarchLoaded;
			SceneManager.sceneLoaded += TryFixMoonTerrainFootsteps;
			object obj8 = <>O.<9>__AddCrouchingFootsteps;
			if (obj8 == null)
			{
				hook_Start val9 = AddCrouchingFootsteps;
				<>O.<9>__AddCrouchingFootsteps = val9;
				obj8 = (object)val9;
			}
			PlayerControllerB.Start += (hook_Start)obj8;
			DawnPlugin.Hooks.Add(new Hook((MethodBase)AccessTools.DeclaredMethod(typeof(PlayerAnimationEvents), "PlayCrouchFootstepSound", (Type[])null, (Type[])null), (Delegate)new Action<Action<PlayerAnimationEvents>, PlayerAnimationEvents>(PlayCrouchFootstepSound)));
		}

		private static void PlayCrouchFootstepSound(Action<PlayerAnimationEvents> orig, PlayerAnimationEvents self)
		{
			PlayerControllerB thisPlayerController = self.thisPlayerController;
			if (thisPlayerController.isClimbingLadder || thisPlayerController.inSpecialInteractAnimation)
			{
				orig.Invoke(self);
				return;
			}
			if ((((NetworkBehaviour)thisPlayerController).IsOwner && thisPlayerController.slipperyFloor > 0.5f) || (!((NetworkBehaviour)thisPlayerController).IsOwner && thisPlayerController.slimeSlipAudioVolumeSync > 0f))
			{
				thisPlayerController.currentFootstepSurfaceIndex = 12;
			}
			else
			{
				thisPlayerController.GetCurrentMaterialStandingOn(false);
			}
			DawnSurfaceInfo dawnInfo = StartOfRound.Instance.footstepSurfaces[thisPlayerController.currentFootstepSurfaceIndex].GetDawnInfo();
			if (dawnInfo == null || dawnInfo.CrouchClips == null || dawnInfo.CrouchClips.Count == 0)
			{
				orig.Invoke(self);
				return;
			}
			int num = Random.Range(0, dawnInfo.CrouchClips.Count);
			if (num == thisPlayerController.previousFootstepClip)
			{
				num = (num + 1) % dawnInfo.CrouchClips.Count;
			}
			thisPlayerController.movementAudio.pitch = Random.Range(0.93f, 1.07f);
			float num2 = 0.3f;
			num2 *= dawnInfo.Volume;
			thisPlayerController.movementAudio.PlayOneShot(dawnInfo.CrouchClips[num], num2);
			thisPlayerController.previousFootstepClip = num;
			WalkieTalkie.TransmitOneShotAudio(thisPlayerController.movementAudio, dawnInfo.CrouchClips[num], num2);
			orig.Invoke(self);
		}

		private static void AddCrouchingFootsteps(orig_Start orig, PlayerControllerB self)
		{
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Expected O, but got Unknown
			orig.Invoke(self);
			if (addedCrouchingSteps)
			{
				return;
			}
			addedCrouchingSteps = true;
			AnimationClip val = null;
			AnimationClip[] animationClips = self.playerBodyAnimator.runtimeAnimatorController.animationClips;
			foreach (AnimationClip val2 in animationClips)
			{
				if (((Object)val2).name == "CrouchWalk")
				{
					val = val2;
					break;
				}
			}
			foreach (AnimationEventData crouchingAnimationEvent in CrouchingAnimationEvents)
			{
				AnimationEvent val3 = new AnimationEvent
				{
					functionName = crouchingAnimationEvent.AnimationEventName,
					time = crouchingAnimationEvent.Time
				};
				val.AddEvent(val3);
			}
		}

		private static Manipulator EditFootstepSound(Type type)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Expected O, but got Unknown
			Type type2 = type;
			return (Manipulator)delegate(ILContext il)
			{
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				//IL_000d: Expected O, but got Unknown
				//IL_0143: Unknown result type (might be due to invalid IL or missing references)
				//IL_017b: Unknown result type (might be due to invalid IL or missing references)
				ILCursor val = new ILCursor(il);
				int location = -1;
				if (!val.TryGotoNext((MoveType)0, new Func<Instruction, bool>[6]
				{
					(Instruction i) => ILPatternMatchingExt.MatchStloc(i, ref location),
					(Instruction i) => ILPatternMatchingExt.MatchLdarg(i, 0),
					(Instruction i) => ILPatternMatchingExt.MatchLdfld(i, type2, "movementAudio"),
					(Instruction i) => ILPatternMatchingExt.MatchCall<StartOfRound>(i, "get_Instance"),
					(Instruction i) => ILPatternMatchingExt.MatchLdfld<StartOfRound>(i, "footstepSurfaces"),
					(Instruction i) => ILPatternMatchingExt.MatchLdarg(i, 0)
				}))
				{
					DawnPlugin.Logger.LogWarning((object)("Failed to apply " + type2.Name + ".PlayFootstepSound patch (0)!"));
				}
				else
				{
					val.GotoNext((MoveType)2, new Func<Instruction, bool>[1]
					{
						(Instruction i) => ILPatternMatchingExt.MatchLdarg(i, 0)
					});
					val.EmitLdfld(type2, "currentFootstepSurfaceIndex");
					val.Emit(OpCodes.Ldloca, location);
					val.EmitDelegate<<>A{00000008}<int, float>>((<>A{00000008}<int, float>)delegate(int currentFootstepSurfaceIndex, ref float volume)
					{
						FootstepSurface surface = StartOfRound.Instance.footstepSurfaces[currentFootstepSurfaceIndex];
						DawnSurfaceInfo dawnInfo = surface.GetDawnInfo();
						if (dawnInfo != null)
						{
							volume *= dawnInfo.Volume;
						}
					});
					val.Emit(OpCodes.Ldarg_0);
				}
			};
		}

		private static void AllowEmergingAtCustomSurfaces(ILContext il)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			//IL_0186: Unknown result type (might be due to invalid IL or missing references)
			//IL_0192: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c5: Unknown result type (might be due to invalid IL or missing references)
			ILCursor val = new ILCursor(il);
			ILLabel val3 = default(ILLabel);
			if (!val.TryGotoNext((MoveType)0, new Func<Instruction, bool>[5]
			{
				(Instruction i) => ILPatternMatchingExt.MatchLdloc(i, 2),
				(Instruction i) => ILPatternMatchingExt.MatchBrfalse(i, ref val3),
				(Instruction i) => ILPatternMatchingExt.MatchLdloc(i, 5),
				(Instruction i) => ILPatternMatchingExt.MatchLdcI4(i, 1),
				(Instruction i) => ILPatternMatchingExt.MatchAdd(i)
			}))
			{
				DawnPlugin.Logger.LogWarning((object)"Failed to apply SandWormAI.StartEmergeAnimation patch (0)!");
				return;
			}
			ILLabel val2 = val.DefineLabel();
			val.MarkLabel(val2);
			if (!val.TryGotoPrev((MoveType)0, new Func<Instruction, bool>[4]
			{
				(Instruction i) => ILPatternMatchingExt.MatchLdcI4(i, 0),
				(Instruction i) => ILPatternMatchingExt.MatchStloc(i, 2),
				(Instruction i) => ILPatternMatchingExt.MatchCall<Terrain>(i, "get_activeTerrain"),
				(Instruction i) => ILPatternMatchingExt.MatchLdnull(i)
			}))
			{
				DawnPlugin.Logger.LogWarning((object)"Failed to apply SandWormAI.StartEmergeAnimation patch (1)!");
				return;
			}
			val.Emit(OpCodes.Ldloc_1);
			val.Emit(OpCodes.Ldloca, 2);
			val.EmitDelegate<<>F{00000008}<RaycastHit, bool, bool>>((<>F{00000008}<RaycastHit, bool, bool>)delegate(RaycastHit hit, ref bool flag)
			{
				//IL_0015: Unknown result type (might be due to invalid IL or missing references)
				DawnSurface dawnSurface = default(DawnSurface);
				if (!((Component)((RaycastHit)(ref hit)).collider).TryGetComponent<DawnSurface>(ref dawnSurface))
				{
					return false;
				}
				if (!dawnSurface.TryGetFootstepIndex(((RaycastHit)(ref hit)).point, checkStandingOnTerrain: true, out var footstepIndex) || footstepIndex == -1)
				{
					return false;
				}
				DawnSurfaceInfo dawnSurfaceInfo = null;
				foreach (DawnSurfaceInfo value in LethalContent.Surfaces.Values)
				{
					if (value.SurfaceIndex == footstepIndex)
					{
						dawnSurfaceInfo = value;
						break;
					}
				}
				if (dawnSurfaceInfo == null)
				{
					return false;
				}
				if (StartOfRoundRefs.Instance.currentLevel.GetDawnInfo() == LethalContent.Moons[MoonKeys.Embrion] && dawnSurfaceInfo == LethalContent.Surfaces[SurfaceKeys.Rock])
				{
					flag = true;
					return true;
				}
				if (dawnSurfaceInfo.IsNatural)
				{
					flag = true;
					return true;
				}
				return true;
			});
			val.Emit(OpCodes.Brtrue_S, (object)val2);
		}

		private static void AllowCustomSurfacesInQuicksand(ILContext il)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Expected O, but got Unknown
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			ILCursor val = new ILCursor(il);
			ILLabel branchLabel = null;
			if (!val.TryGotoNext((MoveType)0, new Func<Instruction, bool>[4]
			{
				(Instruction i) => ILPatternMatchingExt.MatchLdarg(i, 0),
				(Instruction i) => ILPatternMatchingExt.MatchLdfld<PlayerControllerB>(i, "currentFootstepSurfaceIndex"),
				(Instruction i) => ILPatternMatchingExt.MatchLdcI4(i, 1),
				(Instruction i) => ILPatternMatchingExt.MatchBeq(i, ref branchLabel)
			}))
			{
				DawnPlugin.Logger.LogWarning((object)"Failed to apply PlayerControllerB.CheckConditionsForSinkingInQuicksand patch (0)!");
				return;
			}
			val.Emit(OpCodes.Ldarg_0);
			val.Emit(OpCodes.Ldfld, AccessTools.Field(typeof(PlayerControllerB), "currentFootstepSurfaceIndex"));
			val.EmitDelegate<Func<int, bool>>((Func<int, bool>)delegate(int currentFootstepSurfaceIndex)
			{
				foreach (DawnSurfaceInfo value in LethalContent.Surfaces.Values)
				{
					if (!value.ShouldSkipIgnoreOverride() && value.SurfaceIndex == currentFootstepSurfaceIndex)
					{
						if (value.QuicksandCompatible)
						{
							return true;
						}
						return false;
					}
				}
				return false;
			});
			val.Emit(OpCodes.Brtrue_S, (object)branchLabel);
		}

		private static void TryFixMoonTerrainFootsteps(Scene arg0, LoadSceneMode arg1)
		{
			if ((Object)(object)StartOfRound.Instance == (Object)null || (Object)(object)StartOfRound.Instance.currentLevel == (Object)null)
			{
				return;
			}
			if (LethalLevelLoaderCompat.Enabled && Version.Parse("1.6.9") < Chainloader.PluginInfos["imabatby.lethallevelloader"].Metadata.Version)
			{
				SceneManager.sceneLoaded -= TryFixMoonTerrainFootsteps;
				return;
			}
			DawnMoonInfo dawnInfo = StartOfRound.Instance.currentLevel.GetDawnInfo();
			if (dawnInfo == null || dawnInfo.TypedKey.IsVanilla())
			{
				return;
			}
			Terrain[] activeTerrains = Terrain.activeTerrains;
			DawnSurface dawnSurface = default(DawnSurface);
			foreach (Terrain val in activeTerrains)
			{
				TerrainData terrainData = val.terrainData;
				int num = terrainData.GetAlphamaps(0, 0, terrainData.alphamapWidth, terrainData.alphamapHeight).Length / (terrainData.alphamapWidth * terrainData.alphamapHeight);
				if (num == 0)
				{
					break;
				}
				if (((Component)val).CompareTag("Untagged"))
				{
					continue;
				}
				if (((Component)val).TryGetComponent<DawnSurface>(ref dawnSurface))
				{
					break;
				}
				dawnSurface = ((Component)val).gameObject.AddComponent<DawnSurface>();
				foreach (DawnSurfaceInfo value in LethalContent.Surfaces.Values)
				{
					if (value.Surface.surfaceTag.Equals(((Component)val).tag, StringComparison.OrdinalIgnoreCase))
					{
						for (int j = 0; j < num; j++)
						{
							dawnSurface.NamespacedKeysForTerrain.Add(value.Key);
						}
					}
				}
			}
		}

		private static void OnVowOrMarchLoaded(Scene arg0, LoadSceneMode arg1)
		{
			if (!((Object)(object)StartOfRound.Instance == (Object)null))
			{
				SelectableLevel currentLevel = RoundManager.Instance.currentLevel;
				if ((Object)(object)currentLevel == (Object)(object)LethalContent.Moons[MoonKeys.March].Level)
				{
					GameObject gameObject = ((Component)GameObject.FindGameObjectWithTag("OutsideLevelNavMesh").transform.Find("Map/MarchTerrainNew")).gameObject;
					DawnSurface dawnSurface = gameObject.AddComponent<DawnSurface>();
					dawnSurface.NamespacedKeysForTerrain.AddRange(new <>z__ReadOnlyArray<NamespacedKey>(new NamespacedKey[3]
					{
						SurfaceKeys.Grass,
						SurfaceKeys.Rock,
						SurfaceKeys.Gravel
					}));
				}
				else if ((Object)(object)currentLevel == (Object)(object)LethalContent.Moons[MoonKeys.Vow].Level)
				{
					GameObject gameObject2 = ((Component)GameObject.FindGameObjectWithTag("OutsideLevelNavMesh").transform.Find("VowTerrain")).gameObject;
					DawnSurface dawnSurface2 = gameObject2.AddComponent<DawnSurface>();
					dawnSurface2.NamespacedKeysForTerrain.AddRange(new <>z__ReadOnlyArray<NamespacedKey>(new NamespacedKey[3]
					{
						SurfaceKeys.Grass,
						SurfaceKeys.Gravel,
						SurfaceKeys.Rock
					}));
				}
			}
		}

		private static void PlayerGetCurrentMaterialStandingOn(ILContext il)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0140: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: Unknown result type (might be due to invalid IL or missing references)
			ILCursor val = new ILCursor(il);
			ILLabel val3 = default(ILLabel);
			if (!val.TryGotoNext((MoveType)2, new Func<Instruction, bool>[5]
			{
				(Instruction instr) => ILPatternMatchingExt.MatchCall(instr, (MethodBase)AccessTools.Method(typeof(StartOfRound), "get_Instance", (Type[])null, (Type[])null)),
				(Instruction instr) => ILPatternMatchingExt.MatchLdfld(instr, AccessTools.Field(typeof(StartOfRound), "walkableSurfacesMask")),
				(Instruction instr) => ILPatternMatchingExt.MatchLdcI4(instr, 1),
				(Instruction instr) => ILPatternMatchingExt.MatchCall(instr, (MethodBase)AccessTools.Method(typeof(Physics), "Raycast", new Type[5]
				{
					typeof(Ray),
					typeof(RaycastHit).MakeByRefType(),
					typeof(float),
					typeof(int),
					typeof(QueryTriggerInteraction)
				}, (Type[])null)),
				(Instruction instr) => ILPatternMatchingExt.MatchBrfalse(instr, ref val3)
			}))
			{
				DawnPlugin.Logger.LogError((object)"Couldn't match GameNetcodeStuff.PlayerControllerB.GetCurrentMaterialStandingOn IL.");
				return;
			}
			ILLabel val2 = val.DefineLabel();
			val.Emit(OpCodes.Ldarg_0);
			val.Emit(OpCodes.Ldarg_1);
			val.Emit(OpCodes.Ldarg_0);
			val.EmitLdflda<PlayerControllerB>("hit");
			val.Emit(OpCodes.Ldarg_0);
			val.EmitLdflda<PlayerControllerB>("currentFootstepSurfaceIndex");
			val.Emit(OpCodes.Call, (MethodBase)AccessTools.Method(typeof(SurfaceRegistrationHandler), "TryGetAndSetDawnSurfaceIndexPlayer", (Type[])null, (Type[])null));
			val.Emit(OpCodes.Brfalse, (object)val2);
			val.Emit(OpCodes.Ret);
			val.MarkLabel(val2);
		}

		private static void EditUncappedFallValueForGravity(ILContext il)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			//IL_00f3: 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_020c: Unknown result type (might be due to invalid IL or missing references)
			//IL_022e: Unknown result type (might be due to invalid IL or missing references)
			ILCursor val = new ILCursor(il);
			if (!val.TryGotoNext((MoveType)2, new Func<Instruction, bool>[6]
			{
				(Instruction instr) => ILPatternMatchingExt.MatchLdarg(instr, 0),
				(Instruction instr) => ILPatternMatchingExt.MatchLdarg(instr, 0),
				(Instruction instr) => ILPatternMatchingExt.MatchLdfld<PlayerControllerB>(instr, "fallValueUncapped"),
				(Instruction instr) => ILPatternMatchingExt.MatchLdcR4(instr, 26f),
				(Instruction instr) => ILPatternMatchingExt.MatchCall<Time>(instr, "get_deltaTime"),
				(Instruction instr) => ILPatternMatchingExt.MatchMul(instr)
			}))
			{
				DawnPlugin.Logger.LogError((object)"Couldn't match GameNetcodeStuff.PlayerControllerB.Update IL for normal gravity strength control 1.");
				return;
			}
			val.Emit(OpCodes.Call, (MethodBase)AccessTools.Method(typeof(SurfaceRegistrationHandler), "GetGravityStrength", (Type[])null, (Type[])null));
			val.Emit(OpCodes.Mul);
			if (!val.TryGotoNext((MoveType)2, new Func<Instruction, bool>[6]
			{
				(Instruction instr) => ILPatternMatchingExt.MatchLdarg(instr, 0),
				(Instruction instr) => ILPatternMatchingExt.MatchLdarg(instr, 0),
				(Instruction instr) => ILPatternMatchingExt.MatchLdfld<PlayerControllerB>(instr, "fallValueUncapped"),
				(Instruction instr) => ILPatternMatchingExt.MatchLdcR4(instr, 38f),
				(Instruction instr) => ILPatternMatchingExt.MatchCall<Time>(instr, "get_deltaTime"),
				(Instruction instr) => ILPatternMatchingExt.MatchMul(instr)
			}))
			{
				DawnPlugin.Logger.LogError((object)"Couldn't match GameNetcodeStuff.PlayerControllerB.Update IL for uncapped gravity strength control 2.");
				return;
			}
			val.Emit(OpCodes.Call, (MethodBase)AccessTools.Method(typeof(SurfaceRegistrationHandler), "GetGravityStrength", (Type[])null, (Type[])null));
			val.Emit(OpCodes.Mul);
		}

		private static void EditFallValueForGravity(ILContext il)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			//IL_00f3: 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)
			ILCursor val = new ILCursor(il);
			if (!val.TryGotoNext((MoveType)2, new Func<Instruction, bool>[6]
			{
				(Instruction instr) => ILPatternMatchingExt.MatchLdarg(instr, 0),
				(Instruction instr) => ILPatternMatchingExt.MatchLdarg(instr, 0),
				(Instruction instr) => ILPatternMatchingExt.MatchLdfld<PlayerControllerB>(instr, "fallValue"),
				(Instruction instr) => ILPatternMatchingExt.MatchLdcR4(instr, 38f),
				(Instruction instr) => ILPatternMatchingExt.MatchCall(instr, typeof(Time), "get_deltaTime"),
				(Instruction instr) => ILPatternMatchingExt.MatchMul(instr)
			}))
			{
				DawnPlugin.Logger.LogError((object)"Couldn't match GameNetcodeStuff.PlayerControllerB.Update IL for normal gravity strength control.");
				return;
			}
			val.Emit(OpCodes.Call, (MethodBase)AccessTools.Method(typeof(SurfaceRegistrationHandler), "GetGravityStrength", (Type[])null, (Type[])null));
			val.Emit(OpCodes.Mul);
		}

		private static float GetGravityStrength()
		{
			float result = 1f;
			if (GameNetworkManager.Instance.localPlayerController.TryGetCurrentDawnSurface(out DawnSurface dawnSurface))
			{
				result = dawnSurface.GravityStrength;
			}
			return result;
		}

		private static void EditGravityDirection(ILContext il)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			//IL_0142: Unknown result type (might be due to invalid IL or missing references)
			//IL_014f: Unknown result type (might be due to invalid IL or missing references)
			//IL_015b: Unknown result type (might be due to invalid IL or missing references)
			//IL_017b: Unknown result type (might be due to invalid IL or missing references)
			ILCursor val = new ILCursor(il);
			if (!val.TryGotoNext((MoveType)0, new Func<Instruction, bool>[5]
			{
				(Instruction instr) => ILPatternMatchingExt.MatchLdcR4(instr, 0f),
				(Instruction instr) => ILPatternMatchingExt.MatchLdarg(instr, 0),
				(Instruction instr) => ILPatternMatchingExt.MatchLdfld<PlayerControllerB>(instr, "fallValue"),
				(Instruction instr) => ILPatternMatchingExt.MatchLdcR4(instr, 0f),
				(Instruction instr) => ILPatternMatchingExt.MatchNewobj(instr, typeof(Vector3))
			}))
			{
				DawnPlugin.Logger.LogError((object)"Couldn't match GameNetcodeStuff.PlayerControllerB.Update IL for gravity direction control.");
				return;
			}
			val.RemoveRange(5);
			MethodInfo methodInfo = AccessTools.Method(typeof(Vector3), "op_Multiply", new Type[2]
			{
				typeof(Vector3),
				typeof(float)
			}, (Type[])null);
			val.Emit(OpCodes.Call, (MethodBase)AccessTools.Method(typeof(SurfaceRegistrationHandler), "GetGravityDirection", (Type[])null, (Type[])null));
			val.Emit(OpCodes.Ldc_R4, -1f);
			val.Emit(OpCodes.Call, (MethodBase)methodInfo);
			val.Emit(OpCodes.Ldarg_0);
			val.Emit(OpCodes.Ldfld, AccessTools.Field(typeof(PlayerControllerB), "fallValue"));
			val.Emit(OpCodes.Call, (MethodBase)methodInfo);
		}

		private static Vector3 GetGravityDirection()
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			if (!GameNetworkManager.Instance.localPlayerController.TryGetCurrentDawnSurface(out DawnSurface dawnSurface) || (Object)(object)dawnSurface.GravityCenter == (Object)null)
			{
				return Vector3.down;
			}
			Vector3 val = dawnSurface.GravityCenter.transform.position - ((Component)GameNetworkManager.Instance.localPlayerController).transform.position;
			return ((Vector3)(ref val)).normalized;
		}

		private static void RegisterDawnSurfaces(orig_Awake orig, StartOfRound self)
		{
			CollectVanillaSurfaces(self);
			List<FootstepSurface> list = self.footstepSurfaces.ToList();
			foreach (DawnSurfaceInfo value in LethalContent.Surfaces.Values)
			{
				if (!value.ShouldSkipIgnoreOverride())
				{
					value.SurfaceIndex = list.Count;
					list.Add(value.Surface);
				}
			}
			self.footstepSurfaces = list.ToArray();
			orig.Invoke(self);
		}

		private static void CollectVanillaSurfaces(StartOfRound startOfRound)
		{
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			for (int i = 0; i < startOfRound.footstepSurfaces.Length; i++)
			{
				FootstepSurface val = startOfRound.footstepSurfaces[i];
				if (val == null || val.HasDawnInfo())
				{
					continue;
				}
				string name = NamespacedKey.NormalizeStringForNamespacedKey(val.surfaceTag, CSharpName: true);
				NamespacedKey<DawnSurfaceInfo> namespacedKey = SurfaceKeys.GetByReflection(name);
				if (namespacedKey == null)
				{
					namespacedKey = NamespacedKey<DawnSurfaceInfo>.From("unknown_lib", val.surfaceTag);
				}
				if (LethalContent.Surfaces.ContainsKey(namespacedKey))
				{
					if (!LethalContent.Surfaces.IsFrozen)
					{
						DawnPlugin.Logger.LogWarning((object)("Surface " + val.surfaceTag + " is already registered by the same creator to LethalContent. This is likely to cause issues."));
					}
					LethalContent.Surfaces[namespacedKey].Surface = val;
					val.SetDawnInfo(LethalContent.Surfaces[namespacedKey]);
					continue;
				}
				List<int> list = new List<int>(5) { 1, 4, 5, 7, 8 };
				bool isNatural = startOfRound.naturalSurfaceTags.Contains(val.surfaceTag);
				bool quicksandCompatible = list.Contains(i);
				DawnSurfaceInfo dawnSurfaceInfo = new DawnSurfaceInfo(namespacedKey, new HashSet<NamespacedKey> { DawnLibTags.IsExternal }, val, new List<AudioClip>(), 1f, isNatural, quicksandCompatible, null, Vector3.zero, i, null);
				LethalContent.Surfaces.Register(dawnSurfaceInfo);
				val.SetDawnInfo(dawnSurfaceInfo);
			}
			if (!LethalContent.Surfaces.IsFrozen)
			{
				LethalContent.Surfaces.Freeze();
			}
		}

		[HarmonyPatch(typeof(MaskedPlayerEnemy), "GetMaterialStandingOn")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> GetMaterialStandingOn(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Expected O, but got Unknown
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Expected O, but got Unknown
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Expected O, but got Unknown
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Expected O, but got Unknown
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Expected O, but got Unknown
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Expected O, but got Unknown
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Expected O, but got Unknown
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Expected O, but got Unknown
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Expected O, but got Unknown
			//IL_013a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0140: Expected O, but got Unknown
			//IL_015d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0163: Expected O, but got Unknown
			//IL_0170: Unknown result type (might be due to invalid IL or missing references)
			//IL_0176: Expected O, but got Unknown
			//IL_017e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0184: Expected O, but got Unknown
			Label label = default(Label);
			return new CodeMatcher(instructions, generator).MatchForward(false, (CodeMatch[])(object)new CodeMatch[5]
			{
				new CodeMatch((OpCode?)OpCodes.Ldarg_0, (object)null, (string)null),
				new CodeMatch((OpCode?)OpCodes.Ldflda, (object)AccessTools.Field(typeof(MaskedPlayerEnemy), "enemyRayHit"), (string)null),
				new CodeMatch((OpCode?)OpCodes.Call, (object)AccessTools.Method(typeof(RaycastHit), "get_collider", (Type[])null, (Type[])null), (string)null),
				new CodeMatch((OpCode?)OpCodes.Call, (object)AccessTools.Method(typeof(StartOfRound), "get_Instance", (Type[])null, (Type[])null), (string)null),
				new CodeMatch((OpCode?)OpCodes.Ldfld, (object)AccessTools.Field(typeof(StartOfRound), "footstepSurfaces"), (string)null)
			}).CreateLabel(ref label).Insert((CodeInstruction[])(object)new CodeInstruction[8]
			{
				new CodeInstruction(OpCodes.Ldarg_0, (object)null),
				new CodeInstruction(OpCodes.Ldarg_0, (object)null),
				new CodeInstruction(OpCodes.Ldflda, (object)AccessTools.Field(typeof(MaskedPlayerEnemy), "enemyRayHit")),
				new CodeInstruction(OpCodes.Ldarg_0, (object)null),
				new CodeInstruction(OpCodes.Ldflda, (object)AccessTools.Field(typeof(MaskedPlayerEnemy), "currentFootstepSurfaceIndex")),
				new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(SurfaceRegistrationHandler), "TryGetAndSetDawnSurfaceIndexMasked", (Type[])null, (Type[])null)),
				new CodeInstruction(OpCodes.Brfalse_S, (object)label),
				new CodeInstruction(OpCodes.Ret, (object)null)
			})
				.InstructionEnumeration();
		}

		private static bool TryGetAndSetDawnSurfaceIndexPlayer(PlayerControllerB playerControllerB, bool checkStandingOnTerrain, ref RaycastHit hit, ref int currentFootstepSurfaceIndex)
		{
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			DawnSurface dawnSurface = default(DawnSurface);
			if (((Component)((RaycastHit)(ref hit)).collider).TryGetComponent<DawnSurface>(ref dawnSurface) && (dawnSurface.SurfaceIndex > -1 || dawnSurface.TerrainIndices.Count > 0))
			{
				playerControllerB.SetCurrentDawnSurface(dawnSurface);
				if (dawnSurface.TryGetFootstepIndex(((RaycastHit)(ref playerControllerB.hit)).point, checkStandingOnTerrain, out var footstepIndex, playerControllerB))
				{
					currentFootstepSurfaceIndex = footstepIndex;
				}
				DawnSurfaceInfo dawnInfo = StartOfRound.Instance.footstepSurfaces[currentFootstepSurfaceIndex].GetDawnInfo();
				if ((Object)(object)dawnInfo.SurfaceVFXPrefab != (Object)null)
				{
					Singleton<FootstepVFXPool>.Instance.Play(dawnInfo.SurfaceVFXPrefab, ((RaycastHit)(ref hit)).point, ((RaycastHit)(ref hit)).normal, dawnInfo.SurfaceVFXOffset, 1f);
				}
				return true;
			}
			playerControllerB.SetCurrentDawnSurface(null);
			return false;
		}

		private static bool TryGetAndSetDawnSurfaceIndexMasked(MaskedPlayerEnemy maskedPlayerEnemy, ref RaycastHit hit, ref int currentFootstepSurfaceIndex)
		{
			//IL_0021: 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_0067: 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)
			DawnSurface dawnSurface = default(DawnSurface);
			if (((Component)((RaycastHit)(ref hit)).collider).TryGetComponent<DawnSurface>(ref dawnSurface) && dawnSurface.SurfaceIndex > -1)
			{
				maskedPlayerEnemy.SetCurrentDawnSurface(dawnSurface);
				if (dawnSurface.TryGetFootstepIndex(((RaycastHit)(ref hit)).point, checkStandingOnTerrain: false, out var footstepIndex))
				{
					currentFootstepSurfaceIndex = footstepIndex;
				}
				DawnSurfaceInfo dawnInfo = StartOfRound.Instance.footstepSurfaces[currentFootstepSurfaceIndex].GetDawnInfo();
				if ((Object)(object)dawnInfo.SurfaceVFXPrefab != (Object)null)
				{
					Singleton<FootstepVFXPool>.Instance.Play(dawnInfo.SurfaceVFXPrefab, ((RaycastHit)(ref hit)).point, ((RaycastHit)(ref hit)).normal, dawnInfo.SurfaceVFXOffset, 1f);
				}
				return true;
			}
			maskedPlayerEnemy.SetCurrentDawnSurface(null);
			return false;
		}

		[HarmonyPatch(typeof(Shovel), "HitShovel")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> HitShovel(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Expected O, but got Unknown
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Expected O, but got Unknown
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Expected O, but got Unknown
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Expected O, but got Unknown
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Expected O, but got Unknown
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Expected O, but got Unknown
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Expected O, but got Unknown
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Expected O, but got Unknown
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Expected O, but got Unknown
			//IL_0130: Unknown result type (might be due to invalid IL or missing references)
			//IL_0136: Expected O, but got Unknown
			//IL_0153: Unknown result type (might be due to invalid IL or missing references)
			//IL_0159: Expected O, but got Unknown
			//IL_0161: Unknown result type (might be due to invalid IL or missing references)
			//IL_0167: Expected O, but got Unknown
			//IL_016f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0175: Expected O, but got Unknown
			//IL_017d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0183: Expected O, but got Unknown
			//IL_0191: Unknown result type (might be due to invalid IL or missing references)
			//IL_0197: Expected O, but got Unknown
			//IL_019f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a5: Expected O, but got Unknown
			CodeMatcher val = new CodeMatcher(instructions, generator).End().MatchBack(true, (CodeMatch[])(object)new CodeMatch[5]
			{
				new CodeMatch((OpCode?)OpCodes.Ldc_I4_1, (object)null, (string)null),
				new CodeMatch((OpCode?)OpCodes.Stloc_0, (object)null, (string)null),
				new CodeMatch((OpCode?)OpCodes.Ldarg_0, (object)null, (string)null),
				new CodeMatch((OpCode?)OpCodes.Ldfld, (object)AccessTools.Field(typeof(Shovel), "objectsHitByShovelList"), (string)null),
				new CodeMatch((OpCode?)OpCodes.Ldloc_S, (object)null, (string)null)
			});
			object operand = val.Operand;
			int num = val.Pos - 2;
			object operand2 = val.MatchForward(true, (CodeMatch[])(object)new CodeMatch[2]
			{
				new CodeMatch((OpCode?)OpCodes.Stloc_3, (object)null, (string)null),
				new CodeMatch((OpCode?)OpCodes.Br, (object)null, (string)null)
			}).Operand;
			Label label = default(Label);
			return val.Advance(num - val.Pos).CreateLabel(ref label).Insert((CodeInstruction[])(object)new CodeInstruction[9]
			{
				new CodeInstruction(OpCodes.Ldarg_0, (object)null),
				new CodeInstruction(OpCodes.Ldfld, (object)AccessTools.Field(typeof(Shovel), "objectsHitByShovelList")),
				new CodeInstruction(OpCodes.Ldloc_S, operand),
				new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(SurfaceRegistrationHandler), "GetDawnSurfaceIndex", (Type[])null, (Type[])null)),
				new CodeInstruction(OpCodes.Stloc_3, (object)null),
				new CodeInstruction(OpCodes.Ldloc_3, (object)null),
				new CodeInstruction(OpCodes.Ldc_I4_M1, (object)null),
				new CodeInstruction(OpCodes.Beq_S, (object)label),
				new CodeInstruction(OpCodes.Br_S, operand2)
			})
				.InstructionEnumeration();
		}

		[HarmonyPatch(typeof(KnifeItem), "HitKnife")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> HitKnife(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Expected O, but got Unknown
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Expected O, but got Unknown
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Expected O, but got Unknown
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Expected O, but got Unknown
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Expected O, but got Unknown
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Expected O, but got Unknown
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Expected O, but got Unknown
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Expected O, but got Unknown
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Expected O, but got Unknown
			//IL_0130: Unknown result type (might be due to invalid IL or missing references)
			//IL_0136: Expected O, but got Unknown
			//IL_0153: Unknown result type (might be due to invalid IL or missing references)
			//IL_0159: Expected O, but got Unknown
			//IL_0161: Unknown result type (might be due to invalid IL or missing references)
			//IL_0167: Expected O, but got Unknown
			//IL_016f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0175: Expected O, but got Unknown
			//IL_017d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0183: Expected O, but got Unknown
			//IL_0191: Unknown result type (might be due to invalid IL or missing references)
			//IL_0197: Expected O, but got Unknown
			//IL_019f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a5: Expected O, but got Unknown
			CodeMatcher val = new CodeMatcher(instructions, generator).End().MatchBack(true, (CodeMatch[])(object)new CodeMatch[5]
			{
				new CodeMatch((OpCode?)OpCodes.Ldc_I4_1, (object)null, (string)null),
				new CodeMatch((OpCode?)OpCodes.Stloc_0, (object)null, (string)null),
				new CodeMatch((OpCode?)OpCodes.Ldarg_0, (object)null, (string)null),
				new CodeMatch((OpCode?)OpCodes.Ldfld, (object)AccessTools.Field(typeof(KnifeItem), "objectsHitByKnifeList"), (string)null),
				new CodeMatch((OpCode?)OpCodes.Ldloc_S, (object)null, (string)null)
			});
			object operand = val.Operand;
			int num = val.Pos - 2;
			object operand2 = val.MatchForward(true, (CodeMatch[])(object)new CodeMatch[2]
			{
				new CodeMatch((OpCode?)OpCodes.Stloc_2, (object)null, (string)null),
				new CodeMatch((OpCode?)OpCodes.Br, (object)null, (string)null)
			}).Operand;
			Label label = default(Label);
			return val.Advance(num - val.Pos).CreateLabel(ref label).Insert((CodeInstruction[])(object)new CodeInstruction[9]
			{
				new CodeInstruction(OpCodes.Ldarg_0, (object)null),
				new CodeInstruction(OpCodes.Ldfld, (object)AccessTools.Field(typeof(KnifeItem), "objectsHitByKnifeList")),
				new CodeInstruction(OpCodes.Ldloc_S, operand),
				new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(SurfaceRegistrationHandler), "GetDawnSurfaceIndex", (Type[])null, (Type[])null)),
				new CodeInstruction(OpCodes.Stloc_2, (object)null),
				new CodeInstruction(OpCodes.Ldloc_2, (object)null),
				new CodeInstruction(OpCodes.Ldc_I4_M1, (object)null),
				new CodeInstruction(OpCodes.Beq_S, (object)label),
				new CodeInstruction(OpCodes.Br_S, operand2)
			})
				.InstructionEnumeration();
		}

		private static int GetDawnSurfaceIndex(List<RaycastHit> objectsHitList, int objectHitIndex)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			RaycastHit val = objectsHitList[objectHitIndex];
			Collider collider = ((RaycastHit)(ref val)).collider;
			DawnSurface dawnSurface = default(DawnSurface);
			if ((Object)(object)collider != (Object)null && ((Component)collider).TryGetComponent<DawnSurface>(ref dawnSurface))
			{
				return dawnSurface.SurfaceIndex;
			}
			return -1;
		}
	}
	public sealed class DawnSurfaceInfo : DawnBaseInfo<DawnSurfaceInfo>
	{
		public FootstepSurface Surface { get; internal set; }

		public List<AudioClip> CrouchClips { get; }

		public float Volume { get; }

		public bool IsNatural { get; }

		public bool QuicksandCompatible { get; }

		public GameObject? SurfaceVFXPrefab { get; }

		public Vector3 SurfaceVFXOffset { get; }

		public int SurfaceIndex { get; internal set; } = -1;


		internal DawnSurfaceInfo(NamespacedKey<DawnSurfaceInfo> key, HashSet<NamespacedKey> tags, FootstepSurface surface, List<AudioClip> crouchClips, float volume, bool isNatural, bool quicksandCompatible, GameObject? surfaceVFXPrefab, Vector3 surfaceVFXOffset, int surfaceIndex, IDataContainer? customData)
			: base(key, tags, customData)
		{
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			Surface = surface;
			CrouchClips = crouchClips;
			Volume = volume;
			IsNatural = isNatural;
			QuicksandCompatible = quicksandCompatible;
			SurfaceVFXPrefab = surfaceVFXPrefab;
			SurfaceVFXOffset = surfaceVFXOffset;
			SurfaceIndex = surfaceIndex;
		}
	}
	public sealed class FootstepVFXPool : Singleton<FootstepVFXPool>
	{
		private readonly Dictionary<int, ObjectPool<PooledFootstepVFX>> _pools = new Dictionary<int, ObjectPool<PooledFootstepVFX>>();

		public void Play(GameObject prefab, Vector3 position, Vector3 normal, Vector3 offset, float scale)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)prefab == (Object)null))
			{
				ObjectPool<PooledFootstepVFX> orCreatePool = GetOrCreatePool(prefab);
				PooledFootstepVFX pooledFootstepVFX = orCreatePool.Get();
				Transform transform = ((Component)pooledFootstepVFX).transform;
				transform.position = position + offset;
				transform.rotation = Quaternion.FromToRotation(Vector3.up, normal);
				transform.localScale = Vector3.one * Mathf.Max(0.0001f, scale);
				pooledFootstepVFX.Play(orCreatePool);
			}
		}

		private ObjectPool<PooledFootstepVFX> GetOrCreatePool(GameObject prefab)
		{
			GameObject prefab2 = prefab;
			int instanceID = ((Object)prefab2).GetInstanceID();
			if (_pools.TryGetValue(instanceID, out ObjectPool<PooledFootstepVFX> value))
			{
				return value;
			}
			ObjectPool<PooledFootstepVFX> val = new ObjectPool<PooledFootstepVFX>((Func<PooledFootstepVFX>)delegate
			{
				GameObject val2 = Object.Instantiate<GameObject>(prefab2, ((Component)this).transform);
				PooledFootstepVFX pooledFootstepVFX = val2.GetComponent<PooledFootstepVFX>() ?? val2.AddComponent<PooledFootstepVFX>();
				pooledFootstepVFX.Initialize(prefab2);
				val2.SetActive(false);
				return pooledFootstepVFX;
			}, (Action<PooledFootstepVFX>)delegate(PooledFootstepVFX vfx)
			{
				((Component)vfx).gameObject.SetActive(true);
			}, (Action<PooledFootstepVFX>)delegate(PooledFootstepVFX vfx)
			{
				((Component)vfx).gameObject.SetActive(false);
				((Component)vfx).transform.SetParent(((Component)this).transform, false);
			}, (Action<PooledFootstepVFX>)delegate(PooledFootstepVFX vfx)
			{
				if ((Object)(object)vfx != (Object)null)
				{
					Object.Destroy((Object)(object)((Component)vfx).gameObject);
				}
			}, false, 32, 256);
			_pools[instanceID] = val;
			return val;
		}
	}
	public sealed class PooledFootstepVFX : MonoBehaviour
	{
		private ParticleSystem[] _systems;

		private ObjectPool<PooledFootstepVFX>? _ownerPool;

		private GameObject _prefab;

		public void Initialize(GameObject prefab)
		{
			_prefab = prefab;
			_systems = ((Component)this).GetComponentsInChildren<ParticleSystem>(true);
		}

		public void Play(ObjectPool<PooledFootstepVFX> ownerPool)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			_ownerPool = ownerPool;
			for (int i = 0; i < _systems.Length; i++)
			{
				MainModule main = _systems[i].main;
				((MainModule)(ref main)).stopAction = (ParticleSystemStopAction)3;
				_systems[i].Stop(true, (ParticleSystemStopBehavior)1);
				_systems[i].Play(true);
			}
		}

		private void OnParticleSystemStopped()
		{
			for (int i = 0; i < _systems.Length; i++)
			{
				if (_systems[i].IsAlive(true))
				{
					return;
				}
			}
			_ownerPool?.Release(this);
		}
	}
	public static class MaskedPlayerEnemyExtensions
	{
		public static bool TryGetCurrentDawnSurface(this MaskedPlayerEnemy maskedEnemy, [NotNullWhen(true)] out DawnSurface? dawnSurface)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			dawnSurface = (DawnSurface)((IDawnSurface)maskedEnemy).CurrentDawnSurface;
			return (Object)(object)dawnSurface != (Object)null;
		}

		public static void SetCurrentDawnSurface(this MaskedPlayerEnemy maskedEnemy, DawnSurface? dawnSurface)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			((IDawnSurface)maskedEnemy).CurrentDawnSurface = dawnSurface;
		}
	}
	public static class PlayerControllerBExtensions
	{
		public static bool TryGetCurrentDawnSurface(this PlayerControllerB player, [NotNullWhen(true)] out DawnSurface? dawnSurface)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			dawnSurface = (DawnSurface)((IDawnSurface)player).CurrentDawnSurface;
			return (Object)(object)dawnSurface != (Object)null;
		}

		public static void SetCurrentDawnSurface(this PlayerControllerB player, DawnSurface? dawnSurface)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			((IDawnSurface)player).CurrentDawnSurface = dawnSurface;
		}
	}
	public static class SurfaceExtensions
	{
		internal static DawnSurfaceInfo GetDawnInfo(this FootstepSurface surface)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return (DawnSurfaceInfo)((IDawnObject)surface).DawnInfo;
		}

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

		internal static void SetDawnInfo(this FootstepSurface surface, DawnSurfaceInfo surfaceInfo)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			((IDawnObject)surface).DawnInfo = surfaceInfo;
		}
	}
	public class SurfaceInfoBuilder : BaseInfoBuilder<DawnSurfaceInfo, FootstepSurface, SurfaceInfoBuilder>
	{
		private GameObject? _surfaceVFXPrefab;

		private Vector3 _surfaceVFXOffset = Vector3.zero;

		private bool _isNatural;

		private bool _quicksandCompatible;

		private List<AudioClip> _crouchClips = new List<AudioClip>();

		private float _volume = 1f;

		internal SurfaceInfoBuilder(NamespacedKey<DawnSurfaceInfo> key, FootstepSurface value)
			: base(key, value)
		{
		}//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		//IL_0006: Unknown result type (might be due to invalid IL or missing references)


		public SurfaceInfoBuilder SetSurfaceVFXPrefab(GameObject? surfaceVFXPrefab)
		{
			_surfaceVFXPrefab = surfaceVFXPrefab;
			return this;
		}

		public SurfaceInfoBuilder OverrideSurfaceVFXOffset(Vector3 surfaceVFXOffset)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			_surfaceVFXOffset = surfaceVFXOffset;
			return this;
		}

		public SurfaceInfoBuilder OverrideIsNatural(bool isNatural)
		{
			_isNatural = isNatural;
			return this;
		}

		public SurfaceInfoBuilder OverrideQuicksandCompatible(bool quicksandCompatible)
		{
			_quicksandCompatible = quicksandCompatible;
			return this;
		}

		public SurfaceInfoBuilder SetCrouchClips(List<AudioClip> crouchClips)
		{
			_crouchClips = crouchClips;
			return this;
		}

		public SurfaceInfoBuilder OverrideVolume(float volume)
		{
			_volume = volume;
			return this;
		}

		internal override DawnSurfaceInfo Build()
		{
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			base.value.surfaceTag = "AnomalyObject";
			return new DawnSurfaceInfo(base.key, new HashSet<NamespacedKey>(), base.value, _crouchClips, _volume, _isNatural, _quicksandCompatible, _surfaceVFXPrefab, _surfaceVFXOffset, -1, customData);
		}
	}
	public class TaggedRegistry<T> : Registry<T> where T : DawnBaseInfo<T>
	{
		private List<IAutoTagger<T>> _autoTaggers = new List<IAutoTagger<T>>(3)
		{
			new VanillaAutoTagger<T>(),
			new CustomAutoTagger<T>(),
			new AllAutoTagger<T>()
		};

		public event Action AfterTagging = delegate
		{
		};

		public void AddAutoTaggers(params IAutoTagger<T>[] taggers)
		{
			foreach (IAutoTagger<T> tagger in taggers)
			{
				AddAutoTagger(tagger);
			}
		}

		public void AddAutoTagger(IAutoTagger<T> tagger)
		{
			_autoTaggers.Add(tagger);
		}

		internal override void Freeze()
		{
			base.Freeze();
			foreach (T value in base.Values)
			{
				foreach (IAutoTagger<T> autoTagger in _autoTaggers)
				{
					try
					{
						if (autoTagger.ShouldApply(value))
						{
							value.Internal_AddTag(autoTagger.Tag);
						}
					}
					catch (Exception arg)
					{
						DawnPlugin.Logger.LogError((object)$"Exception while applying tag: {autoTagger.Tag}\n{arg}");
					}
				}
			}
			this.AfterTagging();
		}
	}
	public class AllAutoTagger<T> : IAutoTagger<T> where T : INamespaced<T>, ITaggable
	{
		public NamespacedKey Tag => Tags.All;

		public bool ShouldApply(T info)
		{
			return true;
		}
	}
	public class CustomAutoTagger<T> : IAutoTagger<T> where T : INamespaced<T>, ITaggable
	{
		public NamespacedKey Tag => Tags.Custom;

		public bool ShouldApply(T info)
		{
			return !info.Key.IsVanilla();
		}
	}
	public interface IAutoTagger<T> where T : INamespaced<T>, ITaggable
	{
		NamespacedKey Tag { get; }

		bool ShouldApply(T info);
	}
	public interface ITaggable
	{
		bool HasTag(NamespacedKey tag);

		IEnumerable<NamespacedKey> AllTags();
	}
	public class SimpleAutoTagger<T> : IAutoTagger<T> where T : DawnBaseInfo<T>
	{
		[CompilerGenerated]
		private NamespacedKey <tag>P;

		[CompilerGenerated]
		private Func<T, bool> <predicate>P;

		public NamespacedKey Tag => <tag>P;

		public SimpleAutoTagger(NamespacedKey tag, Func<T, bool> predicate)
		{
			<tag>P = tag;
			<predicate>P = predicate;
			base..ctor();
		}

		public bool ShouldApply(T info)
		{
			return <predicate>P(info);
		}
	}
	[GeneratedCode("DawnLib", "0.9.21")]
	public static class Tags
	{
		public static NamespacedKey All = NamespacedKey.Vanilla("all");

		public static NamespacedKey Cold = NamespacedKey.Vanilla("cold");

		public static NamespacedKey Custom = NamespacedKey.Vanilla("custom");

		public static NamespacedKey Abandoned = NamespacedKey.Vanilla("abandoned");

		public static NamespacedKey Artificial = NamespacedKey.Vanilla("artifical");

		public static NamespacedKey Bunker = NamespacedKey.Vanilla("bunker");

		public static NamespacedKey Catacomb = NamespacedKey.Vanilla("catacomb");

		public static NamespacedKey Cavern = NamespacedKey.Vanilla("cavern");

		public static NamespacedKey Claustrophobic = NamespacedKey.Vanilla("claustrophobic");

		public static NamespacedKey Dusty = NamespacedKey.Vanilla("dusty");

		public static NamespacedKey Eerie = NamespacedKey.Vanilla("eerie");

		public static NamespacedKey Factory = NamespacedKey.Vanilla("factory");

		public static NamespacedKey Flooded = NamespacedKey.Vanilla("flooded");

		public static NamespacedKey Gothic = NamespacedKey.Vanilla("gothic");

		public static NamespacedKey Grand = NamespacedKey.Vanilla("grand");

		public static NamespacedKey Industrial = NamespacedKey.Vanilla("industrial");

		public static NamespacedKey Lavish = NamespacedKey.Vanilla("lavish");

		public static NamespacedKey Maze = NamespacedKey.Vanilla("maze");

		public static NamespacedKey Mechanical = NamespacedKey.Vanilla("mechanical");

		public static NamespacedKey Monotone = NamespacedKey.Vanilla("monotone");

		public static NamespacedKey Ornate = NamespacedKey.Vanilla("ornate");

		public static NamespacedKey Quarry = NamespacedKey.Vanilla("quarry");

		public static NamespacedKey Reactor = NamespacedKey.Vanilla("reactor");

		public static NamespacedKey Ruins = NamespacedKey.Vanilla("ruins");

		public static NamespacedKey Storage = NamespacedKey.Vanilla("storage");

		public static NamespacedKey Withered = NamespacedKey.Vanilla("withered");

		public static NamespacedKey Biped = NamespacedKey.Vanilla("biped");

		public static NamespacedKey Hostile = NamespacedKey.Vanilla("hostile");

		public static NamespacedKey Killable = NamespacedKey.Vanilla("killable");

		public static NamespacedKey Large = NamespacedKey.Vanilla("large");

		public static NamespacedKey Medium = NamespacedKey.Vanilla("medium");

		public static NamespacedKey Neutral = NamespacedKey.Vanilla("neutral");

		public static NamespacedKey Organic = NamespacedKey.Vanilla("organic");

		public static NamespacedKey Passive = NamespacedKey.Vanilla("passive");

		public static NamespacedKey Quadruped = NamespacedKey.Vanilla("quadruped");

		public static NamespacedKey Small = NamespacedKey.Vanilla("small");

		public static NamespacedKey Hot = NamespacedKey.Vanilla("hot");

		public static NamespacedKey BeastByproduct = NamespacedKey.Vanilla("beast_byproduct");

		public static NamespacedKey BodyParts = NamespacedKey.Vanilla("body_parts");

		public static NamespacedKey Chargeable = NamespacedKey.Vanilla("chargeable");

		public static NamespacedKey Communicative = NamespacedKey.Vanilla("communicative");

		public static NamespacedKey Conductive = NamespacedKey.Vanilla("conductive");

		public static NamespacedKey Consumable = NamespacedKey.Vanilla("consumable");

		public static NamespacedKey GeneralItemClassGroup = NamespacedKey.Vanilla("general_item_class_group");

		public static NamespacedKey Harmful = NamespacedKey.Vanilla("harmful");

		public static NamespacedKey HeavyWeight = NamespacedKey.Vanilla("heavy_weight");

		public static NamespacedKey HighValue = NamespacedKey.Vanilla("high_value");

		public static NamespacedKey Household = NamespacedKey.Vanilla("household");

		public static NamespacedKey Information = NamespacedKey.Vanilla("information");

		public static NamespacedKey Interactable = NamespacedKey.Vanilla("interactable");

		public static NamespacedKey LightWeight = NamespacedKey.Vanilla("light_weight");

		public static NamespacedKey LowValue = NamespacedKey.Vanilla("low_value");

		public static NamespacedKey Luminescent = NamespacedKey.Vanilla("luminescent");

		public static NamespacedKey MachinePart = NamespacedKey.Vanilla("machine_part");

		public static NamespacedKey MediumValue = NamespacedKey.Vanilla("medium_value");

		public static NamespacedKey MediumWeight = NamespacedKey.Vanilla("medium_weight");

		public static NamespacedKey Metal = NamespacedKey.Vanilla("metal");

		public static NamespacedKey Noisy = NamespacedKey.Vanilla("noisy");

		public static NamespacedKey NonInteractable = NamespacedKey.Vanilla("non_interactable");

		public static NamespacedKey OneHanded = NamespacedKey.Vanilla("one_handed");

		public static NamespacedKey Scrap = NamespacedKey.Vanilla("scrap");

		public static NamespacedKey SmallItemsGroup = NamespacedKey.Vanilla("small_items_group");

		public static NamespacedKey TabletopItemsGroup = NamespacedKey.Vanilla("tabletop_items_group");

		public static NamespacedKey TestItemGroup = NamespacedKey.Vanilla("test_item_group");

		public static NamespacedKey Tool = NamespacedKey.Vanilla("tool");

		public static NamespacedKey Transportation = NamespacedKey.Vanilla("transportation");

		public static NamespacedKey TwoHanded = NamespacedKey.Vanilla("two_handed");

		public static NamespacedKey Weapon = NamespacedKey.Vanilla("weapon");

		public static NamespacedKey Military = NamespacedKey.Vanilla("military");

		public static NamespacedKey Amethyst = NamespacedKey.Vanilla("amethyst");

		public static NamespacedKey Canyon = NamespacedKey.Vanilla("canyon");

		public static NamespacedKey Company = NamespacedKey.Vanilla("company");

		public static NamespacedKey Desert = NamespacedKey.Vanilla("desert");

		public static NamespacedKey Forest = NamespacedKey.Vanilla("forest");

		public static NamespacedKey Free = NamespacedKey.Vanilla("free");

		public static NamespacedKey Habitable = NamespacedKey.Vanilla("habitable");

		public static NamespacedKey Inhabited = NamespacedKey.Vanilla("inhabited");

		public static NamespacedKey Marsh = NamespacedKey.Vanilla("marsh");

		public static NamespacedKey Plains = NamespacedKey.Vanilla("plains");

		public static NamespacedKey Rocky = NamespacedKey.Vanilla("rocky");

		public static NamespacedKey Temperate = NamespacedKey.Vanilla("temperate");

		public static NamespacedKey Tundra = NamespacedKey.Vanilla("tundra");

		public static NamespacedKey Valley = NamespacedKey.Vanilla("valley");

		public static NamespacedKey Wasteland = NamespacedKey.Vanilla("wasteland");

		public static NamespacedKey Wet = NamespacedKey.Vanilla("wet");

		public static NamespacedKey Natural = NamespacedKey.Vanilla("natural");

		public static NamespacedKey Paid = NamespacedKey.Vanilla("paid");

		public static NamespacedKey Unimplemented = NamespacedKey.Vanilla("unimplemented");

		public static NamespacedKey Vanilla = NamespacedKey.Vanilla("vanilla");

		internal static void AddToList(this HashSet<NamespacedKey> namespacedKeys, IEnumerable<(string @namespace, string key)> tagsWithModNames, DebugLogSource? debugLogSource = null, string? objectName = null)
		{
			foreach (var tagsWithModName in tagsWithModNames)
			{
				string item = tagsWithModName.@namespace;
				string item2 = tagsWithModName.key;
				string text = NamespacedKey.NormalizeStringForNamespacedKey(item, CSharpName: false);
				string text2 = NamespacedKey.NormalizeStringForNamespacedKey(item2, CSharpName: false);
				if (text == "lethalcompany")
				{
					text = "lethal_level_loader";
				}
				if (objectName != null)
				{
					debugLogSource?.Log("Adding tag " + text + ":" + text2 + " to " + objectName);
				}
				namespacedKeys.Add(NamespacedKey.From(text, text2));
			}
		}
	}
	public class VanillaAutoTagger<T> : IAutoTagger<T> where T : INamespaced<T>, ITaggable
	{
		public NamespacedKey Tag => Tags.Vanilla;

		public bool ShouldApply(T info)
		{
			return info.Key.IsVanilla();
		}
	}
	public sealed class DawnPurchaseInfo : ITerminalPurchase
	{
		public IProvider<int> Cost { get; private set; }

		public ITerminalPurchasePredicate PurchasePredicate { get; private set; }

		internal DawnPurchaseInfo(IProvider<int> cost, ITerminalPurchasePredicate purchasePredicate)
		{
			Cost = cost;
			PurchasePredicate = purchasePredicate;
		}
	}
	public interface ITerminalPurchase
	{
		IProvider<int> Cost { get; }

		ITerminalPurchasePredicate PurchasePredicate { get; }
	}
	public interface ITerminalPurchasePredicate
	{
		TerminalPurchaseResult CanPurchase();

		static ITerminalPurchasePredicate AlwaysSuccess()
		{
			return new ConstantTerminalPredicate(TerminalPurchaseResult.Success());
		}

		static ITerminalPurchasePredicate AlwaysHide()
		{
			return new ConstantTerminalPredicate(TerminalPurchaseResult.Hidden());
		}

		static ITerminalPurchasePredicate AlwaysFail(TerminalNode fail)
		{
			return new ConstantTerminalPredicate(TerminalPurchaseResult.Fail(fail));
		}
	}
	internal class ConstantTerminalPredicate : ITerminalPurchasePredicate
	{
		[CompilerGenerated]
		private TerminalPurchaseResult <result>P;

		public ConstantTerminalPredicate(TerminalPurchaseResult result)
		{
			<result>P = result;
			base..ctor();
		}

		public TerminalPurchaseResult CanPurchase()
		{
			return <result>P;
		}
	}
	internal class LethalLevelLoaderTerminalPredicate : ITerminalPurchasePredicate
	{
		[CompilerGenerated]
		private object <extendedLevelObject>P;

		private TerminalNode? _failNode;

		public LethalLevelLoaderTerminalPredicate(object extendedLevelObject)
		{
			<extendedLevelObject>P = extendedLevelObject;
			base..ctor();
		}

		public TerminalPurchaseResult CanPurchase()
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Expected O, but got Unknown
			object obj = <extendedLevelObject>P;
			SelectableLevel val = (SelectableLevel)((obj is SelectableLevel) ? obj : null);
			if (val != null)
			{
				<extendedLevelObject>P = LevelManager.GetExtendedLevel(val);
			}
			ExtendedLevel val2 = (ExtendedLevel)<extendedLevelObject>P;
			if (val2.IsRouteLocked && val2.IsRouteHidden)
			{
				return TerminalPurchaseResult.Hidden().SetFailure(isFailure: true);
			}
			if (val2.IsRouteHidden)
			{
				return TerminalPurchaseResult.Hidden().SetFailure(isFailure: false);
			}
			if (val2.IsRouteLocked)
			{
				if ((Object)(object)_failNode == (Object)null)
				{
					_failNode = new TerminalNodeBuilder(string.Format("{0}LethalLevelLoaderTerminalPredicateFail", ((Object)val2).name.Replace(" ", "").SkipWhile((char x) => !char.IsLetter(x)).ToArray())).SetDisplayText(val2.LockedRouteNodeText ?? "").Build();
				}
				return TerminalPurchaseResult.Fail(_failNode);
			}
			return TerminalPurchaseResult.Success();
		}
	}
	public class TerminalKeywordBuilder
	{
		private static List<TerminalKeyword> _keywordsAdded = new List<TerminalKeyword>();

		private TerminalKeyword _keyword;

		internal static List<TerminalKeyword> AllTerminalKeywords
		{
			get
			{
				if (_keywordsAdded.Count == 0)
				{
					_keywordsAdded = Resources.FindObjectsOfTypeAll<TerminalKeyword>().ToList();
				}
				return _keywordsAdded;
			}
			private set
			{
				_keywordsAdded = value;
			}
		}

		private static bool WordAlreadyExists(string word, [NotNullWhen(true)] out TerminalKeyword? existingKeyword)
		{
			if ((Object)(object)TerminalRefs.Instance == (Object)null)
			{
				existingKeyword = null;
				foreach (TerminalKeyword allTerminalKeyword in AllTerminalKeywords)
				{
					if (word.CompareStringsInvariant(allTerminalKeyword.word))
					{
						existingKeyword = allTerminalKeyword;
					}
				}
				return (Object)(object)existingKeyword != (Object)null;
			}
			TerminalRefs.Instance.TryGetKeyword(word, out existingKeyword);
			return (Object)(object)existingKeyword != (Object)null;
		}

		internal TerminalKeywordBuilder(string name, string word)
		{
			if (WordAlreadyExists(word, out TerminalKeyword existingKeyword))
			{
				_keyword = existingKeyword;
				DawnPlugin.Logger.LogWarning((object)("Keyword Override! Replacing keyword [" + _keyword.word + "] results"));
				((Object)_keyword).name = name;
			}
			else
			{
				_keyword = ScriptableObject.CreateInstance<TerminalKeyword>();
				((Object)_keyword).name = name;
				OverrideWord(word);
				AllTerminalKeywords.Add(_keyword);
			}
		}

		internal TerminalKeywordBuilder(string name, string word, DawnKeywordType keywordPriority)
		{
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			if (WordAlreadyExists(word, out TerminalKeyword existingKeyword))
			{
				DawnKeywordType keywordPriority2 = existingKeyword.GetKeywordPriority();
				if (keywordPriority2 <= keywordPriority)
				{
					DawnPlugin.Logger.LogWarning((object)$"'{word}' already has an existing TerminalKeyword with a higher priority [ {keywordPriority2} ]");
					_keyword = ScriptableObject.CreateInstance<TerminalKeyword>();
					((Object)_keyword).name = name;
					_keyword.SetKeywordPriority(keywordPriority);
					OverrideWord(word + ((object)_keyword).GetHashCode());
					AllTerminalKeywords.Add(_keyword);
					DawnPlugin.Logger.LogWarning((object)("TerminalKeyword word set to " + _keyword.word));
				}
				else
				{
					_keyword = existingKeyword;
					DawnPlugin.Logger.LogWarning((object)$"Replacing keyword [{_keyword.word}] with priority [ {keywordPriority2} ] due to new keyword with the same word at a higher priority [ {keywordPriority} ]");
					((Object)_keyword).name = name;
					_keyword.SetKeywordPriority(keywordPriority);
				}
			}
			else
			{
				_keyword = ScriptableObject.CreateInstance<TerminalKeyword>();
				((Object)_keyword).name = name;
				_keyword.SetKeywordPriority(keywordPriority);
				OverrideWord(word);
				AllTerminalKeywords.Add(_keyword);
			}
		}

		public TerminalKeywordBuilder OverrideWord(string word)
		{
			_keyword.word = word;
			return this;
		}

		[Obsolete("Use OverrideWord()")]
		public TerminalKeywordBuilder SetWord(string word)
		{
			return OverrideWord(word);
		}

		public TerminalKeywordBuilder SetIsVerb(bool isVerb)
		{
			_keyword.isVerb = isVerb;
			return this;
		}

		public TerminalKeywordBuilder AddCompatibleNoun(CompatibleNoun compatibleNoun)
		{
			List<CompatibleNoun> list = _keyword.compatibleNouns.ToList();
			list.Add(compatibleNoun);
			_keyword.compatibleNouns = list.ToArray();
			return this;
		}

		public TerminalKeywordBuilder SetSpecialKeywordResult(TerminalNode specialKeywordResult)
		{
			_keyword.specialKeywordResult = specialKeywordResult;
			return this;
		}

		public TerminalKeywordBuilder SetAccessTerminalObjects(bool accessTerminalObjects)
		{
			_keyword.accessTerminalObjects = accessTerminalObjects;
			return this;
		}

		public TerminalKeywordBuilder SetDefaultVerb(TerminalKeyword defaultVerb)
		{
			_keyword.defaultVerb = defaultVerb;
			return this;
		}

		public TerminalKeywordBuilder SetAcceptInput(bool value)
		{
			_keyword.SetKeywordAcceptInput(value);
			return this;
		}

		public TerminalKeyword Build()
		{
			return _keyword;
		}
	}
	public class TerminalNodeBuilder
	{
		internal static List<TerminalNode> _terminalNodes = new List<TerminalNode>();

		private TerminalNode _node;

		internal TerminalNodeBuilder(string name)
		{
			_node = ScriptableObject.CreateInstance<TerminalNode>();
			((Object)_node).name = name;
			_terminalNodes.Add(_node);
		}

		public TerminalNodeBuilder SetBuyItemIndex(int index)
		{
			_node.buyItemIndex = index;
			return this;
		}

		public TerminalNodeBuilder SetBuyVehicleIndex(int index)
		{
			_node.buyVehicleIndex = index;
			return this;
		}

		public TerminalNodeBuilder SetShipUnlockableIndex(int index)
		{
			_node.shipUnlockableID = index;
			return this;
		}

		public TerminalNodeBuilder SetDisplayText(string text)
		{
			_node.displayText = text;
			return this;
		}

		public TerminalNodeBuilder SetDynamicDisplayText(Func<string> func)
		{
			_node.SetDynamicDisplayText(func);
			return this;
		}

		public TerminalNodeBuilder SetClearPreviousText(bool clearPreviousText)
		{
			_node.clearPreviousText = clearPreviousText;
			return this;
		}

		public TerminalNodeBuilder SetMaxCharactersToType(int maxCharacters)
		{
			_node.maxCharactersToType = maxCharacters;
			return this;
		}

		public TerminalNodeBuilder SetItemCost(int cost)
		{
			_node.itemCost = cost;
			return this;
		}

		public TerminalNodeBuilder SetCreatureName(string creatureName)
		{
			_node.creatureName = creatureName;
			return this;
		}

		public TerminalNodeBuilder SetOverrideOptions(bool overrideOptions)
		{
			_node.overrideOptions = overrideOptions;
			return this;
		}

		public TerminalNodeBuilder SetTerminalOptions(CompatibleNoun[] terminalOptions)
		{
			_node.terminalOptions = terminalOptions;
			return this;
		}

		public TerminalNodeBuilder SetIsConfirmationNode(bool isConfirmationNode)
		{
			_node.isConfirmationNode = isConfirmationNode;
			return this;
		}

		public TerminalNodeBuilder SetBuyUnlockable(bool buyUnlockable)
		{
			_node.buyUnlockable = buyUnlockable;
			return this;
		}

		public TerminalNodeBuilder SetPlaySyncedClip(int clipIndex)
		{
			_node.playSyncedClip = clipIndex;
			return this;
		}

		public TerminalNode Build()
		{
			return _node;
		}
	}
	public abstract class TerminalPurchaseResult
	{
		public class SuccessPurchaseResult : TerminalPurchaseResult
		{
			internal static SuccessPurchaseResult Instance { get; } = new SuccessPurchaseResult();


			private SuccessPurchaseResult()
			{
			}
		}

		public class FailedPurchaseResult : TerminalPurchaseResult
		{
			public string? OverrideName { get; private set; }

			public TerminalNode ReasonNode { get; }

			internal FailedPurchaseResult(TerminalNode node)
			{
				ReasonNode = node;
			}

			public FailedPurchaseResult SetOverrideName(string name)
			{
				if (string.IsNullOrWhiteSpace(name))
				{
					return this;
				}
				OverrideName = name;
				return this;
			}
		}

		public class HiddenPurchaseResult : TerminalPurchaseResult
		{
			private static TerminalNode _defaultNode = new TerminalNodeBuilder("HiddenPurchaseResult").SetDisplayText("This content is hidden and made inaccessible.").Build();

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


			public TerminalNode ReasonNode { get; private set; }

			internal HiddenPurchaseResult()
			{
				ReasonNode = _defaultNode;
			}

			public HiddenPurchaseResult SetFailure(bool isFailure)
			{
				IsFailure = isFailure;
				return this;
			}

			public HiddenPurchaseResult SetFailNode(TerminalNode terminalNode)
			{
				ReasonNode = terminalNode;
				return this;
			}
		}

		public static SuccessPurchaseResult Success()
		{
			return SuccessPurchaseResult.Instance;
		}

		public static HiddenPurchaseResult Hidden()
		{
			return new HiddenPurchaseResult();
		}

		public static FailedPurchaseResult Fail(TerminalNode node)
		{
			return new FailedPurchaseResult(node);
		}
	}
	public enum MatchIndex
	{
		First,
		Last,
		All
	}
	[Flags]
	public enum MatchInsert
	{
		ReplaceMatch = 0,
		Before = 1,
		After = 2
	}
	public class TerminalTextModifier
	{
		private string TextToFind;

		private IProvider<string> AddedTextProvider;

		private bool RegexPattern;

		private TerminalNode? NodeToProcess;

		private string? NodeKeyword;

		private MatchIndex IndexStyle = MatchIndex.All;

		private MatchInsert InsertStyle;

		public TerminalTextModifier(string textToFind, IProvider<string> additionalTextProvider)
		{
			TextToFind = textToFind;
			AddedTextProvider = additionalTextProvider;
			TerminalPatches.OnProcessNodeText += Process;
		}

		public TerminalTextModifier ChangeTextToFind(string textToFind)
		{
			TextToFind = textToFind;
			return this;
		}

		public TerminalTextModifier ChangeAddedTextProvider(IProvider<string> addedTextProvider)
		{
			AddedTextProvider = addedTextProvider;
			return this;
		}

		public TerminalTextModifier SetInsertStyle(MatchInsert style)
		{
			InsertStyle = style;
			return this;
		}

		public TerminalTextModifier SetIndexStyle(MatchIndex indexStyle)
		{
			IndexStyle = indexStyle;
			return this;
		}

		public TerminalTextModifier SetNodeDirect(TerminalNode node)
		{
			NodeToProcess = node;
			return this;
		}

		public TerminalTextModifier SetNodeFromKeyword(string keyword)
		{
			NodeKeyword = keyword;
			return this;
		}

		public TerminalTextModifier UseRegexPattern(bool value)
		{
			RegexPattern = value;
			return this;
		}

		internal void Process(ref string currentText, TerminalNode terminalNode)
		{
			if (!string.IsNullOrEmpty(NodeKeyword) && (Object)(object)NodeToProcess == (Object)null)
			{
				NodeToProcess = GetNodeFromWord(NodeKeyword);
			}
			if (!((Object)(object)NodeToProcess != (Object)null) || !((Object)(object)terminalNode != (Object)(object)NodeToProcess))
			{
				string text = AddedTextProvider.Provide();
				if (RegexPattern)
				{
					Regex regex = new Regex(TextToFind);
					Debuggers.Terminal?.Log($"Processing text modifier (regex) on node - {terminalNode}\nRegex ({TextToFind}) matches found {regex.Matches(TextToFind).Count}\nAddedText - {text} (before regex format conversion)");
					currentText = regex.Replace(currentText, text);
				}
				else
				{
					Debuggers.Terminal?.Log($"Processing text modifier (non-regex) on node - {terminalNode}\nIndexStyle - {IndexStyle}\nTextToFind - {TextToFind}\nAddedText - {text}");
					currentText = currentText.TextModify(IndexStyle, InsertStyle, TextToFind, text);
				}
			}
		}

		private static TerminalNode GetNodeFromWord(string word)
		{
			if (TerminalRefs.Instance.TryGetKeyword(word, out TerminalKeyword terminalKeyword))
			{
				if (!((Object)(object)terminalKeyword.specialKeywordResult == (Object)null))
				{
					return terminalKeyword.specialKeywordResult;
				}
				CompatibleNoun val = ((IEnumerable<CompatibleNoun>)terminalKeyword.defaultVerb.compatibleNouns).FirstOrDefault((Func<CompatibleNoun, bool>)((CompatibleNoun k) => (Object)(object)k.noun == (Object)(object)terminalKeyword));
				if (val != null)
				{
					return val.result;
				}
			}
			return null;
		}
	}
	[HarmonyPatch]
	internal static class TerminalCommandRegistration
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static hook_Awake <0>__RegisterDawnTerminalCommands;

			public static hook_Awake <1>__GrabVanillaTerminalCommands;

			public static hook_LoadNewNode <2>__AssignNodeProperDisplayText;

			public static hook_LoadNewNode <3>__HandleQueryEventAndContinueCondition;

			public static hook_Start <4>__AssignTerminalPriorites;

			public static hook_CheckForExactSentences <5>__CheckForExactSentencesPrefix;

			public static hook_ParseWord <6>__ParseWordPrefix;
		}

		private static readonly Dictionary<string, string> _internalToHumanRouteNames = new Dictionary<string, string>
		{
			{ "5route", "EmbrionRoute" },
			{ "7route", "DineRoute" },
			{ "8route", "TitanRoute" },
			{ "20route", "AdamanceRoute" },
			{ "21route", "OffenseRoute" },
			{ "41route", "ExperimentationRoute" },
			{ "56route", "VowRoute" },
			{ "61route", "MarchRoute" },
			{ "68route", "ArtificeRoute" },
			{ "85route", "RendRoute" },
			{ "220route", "AssuranceRoute" }
		};

		internal static void Init()
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Expected O, but got Unknown
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Expected O, but got Unknown
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Expected O, but got Unknown
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Expected O, but got Unknown
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Expected O, but got Unknown
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Expected O, but got Unknown
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Expected O, but got Unknown
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Expected O, but got Unknown
			//IL_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: Expected O, but got Unknown
			DetourContext val = new DetourContext(0);
			try
			{
				object obj = <>O.<0>__RegisterDawnTerminalCommands;
				if (obj == null)
				{
					hook_Awake val2 = RegisterDawnTerminalCommands;
					<>O.<0>__RegisterDawnTerminalCommands = val2;
					obj = (object)val2;
				}
				Terminal.Awake += (hook_Awake)obj;
			}
			finally
			{
				((IDisposable)val)?.Dispose();
			}
			DetourContext val3 = new DetourContext(1);
			try
			{
				object obj2 = <>O.<1>__GrabVanillaTerminalCommands;
				if (obj2 == null)
				{
					hook_Awake val4 = GrabVanillaTerminalCommands;
					<>O.<1>__GrabVanillaTerminalCommands = val4;
					obj2 = (object)val4;
				}
				Terminal.Awake += (hook_Awake)obj2;
			}
			finally
			{
				((IDisposable)val3)?.Dispose();
			}
			DetourContext val5 = new DetourContext(-9999);
			try
			{
				object obj3 = <>O.<2>__AssignNodeProperDisplayText;
				if (obj3 == null)
				{
					hook_LoadNewNode val6 = AssignNodeProperDisplayText;
					<>O.<2>__AssignNodeProperDisplayText = val6;
					obj3 = (object)val6;
				}
				Terminal.LoadNewNode += (hook_LoadNewNode)obj3;
			}
			finally
			{
				((IDisposable)val5)?.Dispose();
			}
			object obj4 = <>O.<3>__HandleQueryEventAndContinueCondition;
			if (obj4 == null)
			{
				hook_LoadNewNode val7 = HandleQueryEventAndContinueCondition;
				<>O.<3>__HandleQueryEventAndContinueCondition = val7;
				obj4 = (object)val7;
			}
			Terminal.LoadNewNode += (hook_LoadNewNode)obj4;
			object obj5 = <>O.<4>__AssignTerminalPriorites;
			if (obj5 == null)
			{
				hook_Start val8 = AssignTerminalPriorites;
				<>O.<4>__AssignTerminalPriorites = val8;
				obj5 = (object)val8;
			}
			Terminal.Start += (hook_Start)obj5;
			object obj6 = <>O.<5>__CheckForExactSentencesPrefix;
			if (obj6 == null)
			{
				hook_CheckForExactSentences val9 = CheckForExactSentencesPrefix;
				<>O.<5>__CheckForExactSentencesPrefix = val9;
				obj6 = (object)val9;
			}
			Terminal.CheckForExactSentences += (hook_CheckForExactSentences)obj6;
			object obj7 = <>O.<6>__ParseWordPrefix;
			if (obj7 == null)
			{
				hook_ParseWord val10 = ParseWordPrefix;
				<>O.<6>__ParseWordPrefix = val10;
				obj7 = (object)val10;
			}
			Terminal.ParseWord += (hook_ParseWord)obj7;
		}

		[HarmonyPatch(typeof(Terminal), "RunTerminalEvents")]
		[HarmonyPrefix]
		private static bool RunDawnLibTerminalEvents(Terminal __instance, TerminalNode node)
		{
			if (node.TryGetDawnInfo(out DawnTerminalCommandInfo terminalCommandInfo) && !terminalCommandInfo.ShouldSkipIgnoreOverride())
			{
				terminalCommandInfo.EventDrivenCommandInfo?.OnTerminalEvent(__instance, node);
				return false;
			}
			return true;
		}

		private static void AssignNodeProperDisplayText(orig_LoadNewNode orig, Terminal self, TerminalNode node)
		{
			node.displayText = node.GetDisplayText();
			orig.Invoke(self, node);
		}

		private static void GrabVanillaTerminalCommands(orig_Awake orig, Terminal self)
		{
			if (LethalContent.TerminalCommands.IsFrozen)
			{
				orig.Invoke(self);
				return;
			}
			TerminalKeyword[] allKeywords = self.terminalNodes.allKeywords;
			foreach (TerminalKeyword val in allKeywords)
			{
				if (val.accessTerminalObjects)
				{
					DawnTerminalObjectCommandInfo terminalObjectCommandInfo = new DawnTerminalObjectCommandInfo();
					string text = FormatNodeName(((Object)val).name);
					NamespacedKey<DawnTerminalCommandInfo> namespacedKey = TerminalCommandKeys.GetByReflection(text);
					if (namespacedKey == null)
					{
						namespacedKey = NamespacedKey<DawnTerminalCommandInfo>.From("unknown_lib", text);
					}
					if (!LethalContent.TerminalCommands.ContainsKey(namespacedKey))
					{
						HashSet<NamespacedKey> tags = new HashSet<NamespacedKey> { DawnLibTags.IsExternal };
						TerminalCommandBasicInformation commandBasicInformation = new TerminalCommandBasicInformation(text.ToCapitalized() + "Command", "Vanilla Command", "Terminal Object Command.", ClearText.None);
						DawnTerminalCommandInfo value = new DawnTerminalCommandInfo(namespacedKey, commandBasicInformation, new List<TerminalKeyword>(1) { val }, buildOnTerminalAwake: true, tags, null, null, null, null, terminalObjectCommandInfo, null, null, null);
						LethalContent.TerminalCommands.Register(value);
					}
					continue;
				}
				if (val.isVerb && val.compatibleNouns.Length != 0)
				{
					List<TerminalNode> list = new List<TerminalNode>();
					List<TerminalKeyword> list2 = new List<TerminalKeyword>();
					CompatibleNoun[] compatibleNouns = val.compatibleNouns;
					foreach (CompatibleNoun val2 in compatibleNouns)
					{
						if (!((Object)(object)val2.result == (Object)null) && !((Object)(object)val2.noun == (Object)null))
						{
							list.Add(val2.result);
							list2.Add(val2.noun);
						}
					}
					Debuggers.Terminal?.Log("Getting ComplexCommand with base terminalKeyword " + ((Object)val).name);
					DawnComplexCommandInfo dawnComplexCommandInfo = new DawnComplexCommandInfo(list, list2);
					string text2 = FormatNodeName(((Object)val).name);
					NamespacedKey<DawnTerminalCommandInfo> namespacedKey2 = TerminalCommandKeys.GetByReflection(text2);
					if (namespacedKey2 == null)
					{
						namespacedKey2 = NamespacedKey<DawnTerminalCommandInfo>.From("unknown_lib", text2);
					}
					if (LethalContent.TerminalCommands.ContainsKey(namespacedKey2))
					{
						continue;
					}
					HashSet<NamespacedKey> tags2 = new HashSet<NamespacedKey> { DawnLibTags.IsExternal };
					ClearText clearText = ClearText.None;
					if (dawnComplexCommandInfo.ResultNodes.Any((TerminalNode x) => x.clearPreviousText))
					{
						clearText |= ClearText.Result;
					}
					TerminalCommandBasicInformation commandBasicInformation2 = new TerminalCommandBasicInformation(text2.ToCapitalized() + "Command", "Vanilla Command", "Complex Command.", clearText);
					DawnTerminalCommandInfo dawnTerminalCommandInfo = new DawnTerminalCommandInfo(namespacedKey2, commandBasicInformation2, new List<TerminalKeyword>(1) { val }, buildOnTerminalAwake: true, tags2, null, null, dawnComplexCommandInfo, null, null, null, null, null);
					LethalContent.TerminalCommands.Register(dawnTerminalCommandInfo);
					foreach (TerminalNode item in list)
					{
						item.SetDawnInfo(dawnTerminalCommandInfo);
						if (item.terminalOptions == null || item.terminalOptions.Length != 2 || ((Object)item).name == "FileCabinet1" || ((Object)item).name == "Cupboard1" || ((Object)item).name == "Bunkbeds1")
						{
							continue;
						}
						Debuggers.Terminal?.Log("Getting SimpleQueryCommand from " + ((Object)item).name + " with base terminalKeyword " + ((Object)val).name);
						TerminalNode result = item.terminalOptions[0].result;
						TerminalNode result2 = item.terminalOptions[1].result;
						TerminalKeyword noun = item.terminalOptions[0].noun;
						TerminalKeyword noun2 = item.terminalOptions[1].noun;
						if (item.terminalOptions[0].noun.word == "deny")
						{
							Debuggers.Terminal?.Log("Switcharoo because deny is suddenly on top instead of bottom!");
							result = item.terminalOptions[1].result;
							result2 = item.terminalOptions[0].result;
							noun = item.terminalOptions[1].noun;
							noun2 = item.terminalOptions[0].noun;
						}
						text2 = FormatNodeName(((Object)result).name);
						NamespacedKey<DawnTerminalCommandInfo> namespacedKey3 = TerminalCommandKeys.GetByReflection(text2);
						if (namespacedKey3 == null)
						{
							namespacedKey3 = NamespacedKey<DawnTerminalCommandInfo>.From("unknown_lib", text2);
						}
						if (!LethalContent.TerminalCommands.ContainsKey(namespacedKey3))
						{
							DawnSimpleQueryCommandInfo dawnSimpleQueryCommandInfo = new DawnSimpleQueryCommandInfo(result, item, item.terminalOptions[1].result, item.terminalOptions[0].noun, item.terminalOptions[1].noun, () => true, delegate
							{
							});
							HashSet<NamespacedKey> tags3 = new HashSet<NamespacedKey> { DawnLibTags.IsExternal };
							ClearText clearText2 = ClearText.None;
							if (dawnSimpleQueryCommandInfo.ResultNode.clearPreviousText)
							{
								clearText2 |= ClearText.Result;
							}
							if (dawnSimpleQueryCommandInfo.ContinueOrCancelNode.clearPreviousText)
							{
								clearText2 |= ClearText.Query;
							}
							if (dawnSimpleQueryCommandInfo.CancelNode.clearPreviousText)
							{
								clearText2 |= ClearText.Cancel;
							}
							TerminalCommandBasicInformation commandBasicInformation3 = new TerminalCommandBasicInformation(text2.ToCapitalized() + "Command", "Vanilla Command", "Complex Command.", clearText2);
							DawnTerminalCommandInfo dawnTerminalCommandInfo2 = new DawnTerminalCommandInfo(namespacedKey3, commandBasicInformation3, new List<TerminalKeyword>(1) { val }, buildOnTerminalAwake: true, tags3, null, dawnSimpleQueryCommandInfo, null, null, null, null, null, null);
							LethalContent.TerminalCommands.Register(dawnTerminalCommandInfo2);
							result.SetDawnInfo(dawnTerminalCommandInfo2);
						}
					}
				}
				List<TerminalNode> allNodesRelatedToAKeyword = GetAllNodesRelatedToAKeyword(val);
				foreach (TerminalNode item2 in allNodesRelatedToAKeyword)
				{
					if (TryGetEventCommandFromNode(item2, out DawnEventDrivenCommandInfo eventDrivenCommandInfo))
					{
						Debuggers.Terminal?.Log("Getting EventDrivenCommand from " + ((Object)item2).name + " with base terminalKeyword " + ((Object)val).name);
						string text3 = FormatNodeName(((Object)item2).name);
						NamespacedKey<DawnTerminalCommandInfo> namespacedKey4 = TerminalCommandKeys.GetByReflection(text3);
						if (namespacedKey4 == null)
						{
							namespacedKey4 = NamespacedKey<DawnTerminalCommandInfo>.From("unknown_lib", text3);
						}
						if (!LethalContent.TerminalCommands.ContainsKey(namespacedKey4))
						{
							HashSet<NamespacedKey> tags4 = new HashSet<NamespacedKey> { DawnLibTags.IsExternal };
							TerminalCommandBasicInformation commandBasicInformation4 = new TerminalCommandBasicInformation(text3.ToCapitalized() + "Command", "Vanilla Command", "Event Driven Command.", eventDrivenCommandInfo.ResultNode.clearPreviousText ? ClearText.Result : ClearText.None);
							DawnTerminalCommandInfo dawnTerminalCommandInfo3 = new DawnTerminalCommandInfo(namespacedKey4, commandBasicInformation4, new List<TerminalKeyword>(1) { val }, buildOnTerminalAwake: true, tags4, null, null, null, null, null, eventDrivenCommandInfo, null, null);
							LethalContent.TerminalCommands.Register(dawnTerminalCommandInfo3);
							item2.SetDawnInfo(dawnTerminalCommandInfo3);
						}
					}
				}
			}
			LethalContent.TerminalCommands.Freeze();
			orig.Invoke(self);
		}

		private static string FormatNodeName(string terminalNodeName)
		{
			string input = terminalNodeName;
			input = ReplaceInternalLevelNames(input);
			return NamespacedKey.NormalizeStringForNamespacedKey(input, CSharpName: true);
		}

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

		private static bool TryGetEventCommandFromNode(TerminalNode node, [NotNullWhen(true)] out DawnEventDrivenCommandInfo? eventDrivenCommandInfo)
		{
			eventDrivenCommandInfo = null;
			if (!string.IsNullOrEmpty(node.terminalEvent))
			{
				Action<Terminal, TerminalNode> action = null;
				switch (node.terminalEvent)
				{
				case "switchCamera":
					action = VanillaTerminalEvents.SwitchCameraEvent;
					break;
				case "setUpTerminal":
					action = VanillaTerminalEvents.SetUpTerminalEvent;
					break;
				case "ejectPlayers":
					action = VanillaTerminalEvents.EjectPlayersEvent;
					break;
				case "cheat_ResetCredits":
					action = VanillaTerminalEvents.Cheat_ResetCreditsEvent;
					break;
				}
				if (action == null)
				{
					return false;
				}
				eventDrivenCommandInfo = new DawnEventDrivenCommandInfo(node, action);
				return true;
			}
			return false;
		}

		private static List<TerminalNode> GetAllNodesRelatedToAKeyword(TerminalKeyword keyword)
		{
			List<TerminalNode> list = new List<TerminalNode>();
			if ((Object)(object)keyword.specialKeywordResult != (Object)null)
			{
				list.Add(keyword.specialKeywordResult);
				if (keyword.specialKeywordResult.terminalOptions != null)
				{
					CompatibleNoun[] terminalOptions = keyword.specialKeywordResult.terminalOptions;
					foreach (CompatibleNoun val in terminalOptions)
					{
						if (!((Object)(object)val.result == (Object)null))
						{
							list.Add(val.result);
						}
					}
				}
			}
			return list;
		}

		private static void RegisterDawnTerminalCommands(orig_Awake orig, Terminal self)
		{
			foreach (DawnTerminalCommandInfo value in LethalContent.TerminalCommands.Values)
			{
				if (!value.ShouldSkipIgnoreOverride() && value.BuildOnTerminalAwake)
				{
					value.InjectCommandIntoTerminal(self);
				}
			}
			orig.Invoke(self);
		}

		private static void HandleQueryEventAndContinueCondition(orig_LoadNewNode orig, Terminal self, TerminalNode node)
		{
			TerminalNode val = node;
			if (val.HasDawnInfo())
			{
				DawnTerminalCommandInfo dawnInfo = val.GetDawnInfo();
				if (dawnInfo.SimpleQueryCommandInfo != null && (Object)(object)dawnInfo.SimpleQueryCommandInfo.ResultNode == (Object)(object)node)
				{
					if (!dawnInfo.SimpleQueryCommandInfo.ContinueCondition())
					{
						val = dawnInfo.SimpleQueryCommandInfo.CancelNode;
						dawnInfo.SimpleQueryCommandInfo.OnContinuedEvent(obj: false);
					}
					else
					{
						dawnInfo.SimpleQueryCommandInfo.OnContinuedEvent(obj: true);
					}
				}
				else if (dawnInfo.ComplexQueryCommandInfo != null)
				{
					for (int i = 0; i < dawnInfo.ComplexQueryCommandInfo.ResultNodes.Count; i++)
					{
						if (!((Object)(object)dawnInfo.ComplexQueryCommandInfo.ResultNodes[i] == (Object)(object)node))
						{
							continue;
						}
						if (!dawnInfo.ComplexQueryCommandInfo.ContinueConditions[i]())
						{
							if ((Object)(object)dawnInfo.ComplexQueryCommandInfo.CancelNode != (Object)null)
							{
								val = dawnInfo.ComplexQueryCommandInfo.CancelNode;
							}
							dawnInfo.ComplexQueryCommandInfo.OnContinuedEvents[i](obj: false);
						}
						else
						{
							dawnInfo.ComplexQueryCommandInfo.OnContinuedEvents[i](obj: true);
						}
						break;
					}
				}
			}
			orig.Invoke(self, val);
		}

		private static TerminalKeyword CheckForExactSentencesPrefix(orig_CheckForExactSentences orig, Terminal self, string playerWord)
		{
			self.SetLastCommand(string.Empty);
			self.SetLastVerb(null);
			self.SetLastNoun(null);
			if (self.DawnTryResolveKeyword(playerWord, out TerminalKeyword word))
			{
				self.UpdateLastKeywordParsed(word);
				self.SetLastCommand(playerWord.GetExactMatch(word.word));
				return word;
			}
			TerminalKeyword val = orig.Invoke(self, playerWord);
			self.UpdateLastKeywordParsed(val);
			self.SetLastCommand(playerWord);
			return val;
		}

		private static TerminalKeyword ParseWordPrefix(orig_ParseWord orig, Terminal self, string playerWord, int specificityRequired)
		{
			if (self.DawnTryResolveKeyword(playerWord, out TerminalKeyword word))
			{
				self.UpdateLastKeywordParsed(word);
				self.SetLastCommand(playerWord.GetExactMatch(word.word));
				return word;
			}
			TerminalKeyword val = orig.Invoke(self, playerWord, specificityRequired);
			self.UpdateLastKeywordParsed(val);
			return val;
		}

		private static void AssignTerminalPriorites(orig_Start orig, Terminal self)
		{
			//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)
			orig.Invoke(self);
			TerminalKeyword[] allKeywords = self.terminalNodes.allKeywords;
			foreach (TerminalKeyword val in allKeywords)
			{
				val.TryAssignType();
				if (string.IsNullOrEmpty(val.GetKeywordCategory()))
				{
					DawnKeywordType keywordPriority = val.GetKeywordPriority();
					val.SetKeywordCategory(((object)(DawnKeywordType)(ref keywordPriority)).ToString());
				}
				if (string.IsNullOrEmpty(val.GetKeywordDescription()))
				{
					if (val.TryGetKeywordInfoText(out string text))
					{
						val.SetKeywordDescription(text.Trim());
					}
					else
					{
						val.SetKeywordDescription("No information on the terminal keyword [ " + val.word + " ]");
					}
				}
			}
		}
	}
	public static class DawnCommands
	{
		public static void Init()
		{
			CreateSimulateCommand();
			CreateFilterCommand();
		}

		private static void CreateSimulateCommand()
		{
			TerminalCommandBasicInformation commandBasicInformation = new TerminalCommandBasicInformation("DawnLibSimulate", "DawnCommand", "Takes the player's input, checks if there's any moons or interiors with that name and simulates their weights.", ClearText.Result | ClearText.Query);
			DawnLib.DefineTerminalCommand(NamespacedKey<DawnTerminalCommandInfo>.From("dawn_lib", "simulate_command"), commandBasicInformation, delegate(TerminalCommandInfoBuilder builder)
			{
				builder.SetKeywords(new List<string>(1) { "simulate" });
				builder.DefineInputCommand(delegate(TerminalCommandInfoBuilder.InputCommandBuilder inputBuilder)
				{
					inputBuilder.SetResultDisplayText(SimulateCommand);
				});
			});
		}

		private static string SimulateCommand(string userInput)
		{
			if (string.IsNullOrEmpty(userInput))
			{
				return "Please enter a moon or interior name.\n\n";
			}
			if (userInput.Length <= 2)
			{
				return "Please enter a name for an interior or moon longer than 2 characters.\n\n";
			}
			DawnMoonInfo dawnMoonInfo = null;
			foreach (DawnMoonInfo value7 in LethalContent.Moons.Values)
			{
				if (value7.GetNumberlessPlanetName().StartsWith(userInput, StringComparison.OrdinalIgnoreCase))
				{
					dawnMoonInfo = value7;
					break;
				}
			}
			DawnDungeonInfo dawnDungeonInfo = null;
			foreach (DawnDungeonInfo value8 in LethalContent.Dungeons.Values)
			{
				if (value8.Key.Key.StartsWith(userInput, StringComparison.OrdinalIgnoreCase))
				{
					dawnDungeonInfo = value8;
					break;
				}
			}
			if (dawnMoonInfo == null && dawnDungeonInfo == null)
			{
				return "No moons or interiors found with the user input '" + userInput + "'.\n\n";
			}
			bool flag = true;
			if (userInput.EndsWith("-w"))
			{
				flag = false;
			}
			int num = 20;
			StringBuilder stringBuilder = new StringBuilder();
			if (dawnMoonInfo != null)
			{
				stringBuilder.Append("Simulating arrival to " + dawnMoonInfo.Level.PlanetName + "\nAnalyzing potential remnants found on surface.\nChecking the Weather forecast.\nListing generated probabilities below.\n\n");
				stringBuilder.Append("----------------------------\n\n");
				stringBuilder.Append("POSSIBLE STRUCTURES:\n");
				List<DawnDungeonInfo> list = new List<DawnDungeonInfo>();
				List<float> list2 = new List<float>();
				foreach (DawnDungeonInfo value9 in LethalContent.Dungeons.Values)
				{
					SpawnWeightContext ctx2 = new SpawnWeightContext(dawnMoonInfo, null, (!flag) ? null : TimeOfDayRefs.GetCurrentWeatherEffect(dawnMoonInfo.Level)?.GetDawnInfo()).WithExtra(SpawnWeightExtraKeys.RoutingPriceKey, dawnMoonInfo.DawnPurchaseInfo.Cost.Provide());
					int valueOrDefault = value9.Weights.GetFor(in ctx2).GetValueOrDefault();
					if (valueOrDefault > 0)
					{
						list.Add(value9);
						list2.Add(valueOrDefault);
					}
				}
				for (int i = 0; i < list.Count; i++)
				{
					for (int j = i + 1; j < list.Count; j++)
					{
						if (list2[i] < list2[j])
						{
							List<DawnDungeonInfo> list3 = list;
							int index = i;
							int index2 = j;
							DawnDungeonInfo value = list[j];
							DawnDungeonInfo value2 = list[i];
							list3[index] = value;
							list[index2] = value2;
							List<float> list4 = list2;
							index2 = i;
							index = j;
							float value3 = list2[j];
							float value4 = list2[i];
							list4[index2] = value3;
							list2[index] = value4;
						}
					}
				}
				float num2 = list2.Sum();
				for (int k = 0; k < list.Count; k++)
				{
					string text = list[k].Key.Key.RemoveLeadingNumbers().ToCapitalized().ReplaceNumbersWithWords()
						.Replace(" ", "_");
					int count = Mathf.Max(num - text.Length, 0);
					stringBuilder.Append("* " + text + new string(' ', count));
					stringBuilder.Append("// Chance: ");
					float num3 = list2[k] / num2 * 100f;
					if (num3 < 10f)
					{
						stringBuilder.Append(" ");
					}
					stringBuilder.Append($"{num3:F2}%\n");
				}
			}
			if (dawnDungeonInfo != null)
			{
				string text2 = dawnDungeonInfo.Key.Key.RemoveLeadingNumbers().ToCapitalized().ReplaceNumbersWithWords()
					.Replace(" ", "_");
				stringBuilder.Append("Simulating the structure " + text2 + "\nAnalyzing the pathways of the structure.\nChecking the Weather forecast.\nListing generated probabilities below.\n\n");
				stringBuilder.Append("----------------------------\n\n");
				stringBuilder.Append("POSSIBLE MOONS:\n");
				List<DawnMoonInfo> list5 = new List<DawnMoonInfo>();
				List<float> list6 = new List<float>();
				foreach (DawnMoonInfo value10 in LethalContent.Moons.Values)
				{
					if (value10.HasTag(Tags.Unimplemented))
					{
						continue;
					}
					SpawnWeightContext ctx = new SpawnWeightContext(value10, null, TimeOfDayRefs.GetCurrentWeatherEffect(value10.Level)?.GetDawnInfo()).WithExtra(SpawnWeightExtraKeys.RoutingPriceKey, value10.DawnPurchaseInfo.Cost.Provide());
					float num4 = dawnDungeonInfo.Weights.GetFor(in ctx).GetValueOrDefault();
					if (!(num4 <= 0f))
					{
						float num5 = LethalContent.Dungeons.Values.Sum((DawnDungeonInfo d) => d.Weights.GetFor(in ctx).GetValueOrDefault());
						float item = num4 / num5 * 100f;
						list5.Add(value10);
						list6.Add(item);
					}
				}
				for (int l = 0; l < list5.Count; l++)
				{
					for (int m = l + 1; m < list5.Count; m++)
					{
						if (list6[l] < list6[m])
						{
							List<DawnMoonInfo> list7 = list5;
							int index = l;
							int index2 = m;
							DawnMoonInfo value5 = list5[m];
							DawnMoonInfo value6 = list5[l];
							list7[index] = value5;
							list5[index2] = value6;
							List<float> list4 = list6;
							index2 = l;
							index = m;
							float value4 = list6[m];
							float value3 = list6[l];
							list4[index2] = value4;
							list6[index] = value3;
						}
					}
				}
				for (int n = 0; n < list5.Count; n++)
				{
					string text3 = list5[n].Key.Key.RemoveLeadingNumbers().ToCapitalized().ReplaceNumbersWithWords()
						.Replace(" ", "_");
					int count2 = Mathf.Max(num - text3.Length, 0);
					stringBuilder.Append("* " + text3 + new string(' ', count2));
					stringBuilder.Append("// Chance: ");
					float num6 = list6[n];
					if (num6 < 10f)
					{
						stringBuilder.Append(" ");
					}
					stringBuilder.Append($"{num6:F2}%\n");
				}
			}
			return stringBuilder.ToString();
		}

		private static void CreateFilterCommand()
		{
			TerminalCommandBasicInformation commandBasicInformation = new TerminalCommandBasicInformation("DawnLibFilter", "DawnCommand", "Takes the player's input, filters the moon list for that tag.", ClearText.Result | ClearText.Query);
			DawnLib.DefineTerminalCommand(NamespacedKey<DawnTerminalCommandInfo>.From("dawn_lib", "filter_command"), commandBasicInformation, delegate(TerminalCommandInfoBuilder builder)
			{
				builder.SetKeywords(new List<string>(1) { "filter" });
				builder.DefineInputCommand(delegate(TerminalCommandInfoBuilder.InputCommandBuilder inputBuilder)
				{
					inputBuilder.SetResultDisplayText(FilterCommand);
				});
			});
		}

		private static string FilterCommand(string userInput)
		{
			if (string.IsNullOrWhiteSpace(userInput))
			{
				return "Please enter a valid tag to filter for (type `filter none` or `filter reset` to remove all filters).\n\n";
			}
			if (userInput.Equals("none", StringComparison.OrdinalIgnoreCase) || userInput.Equals("reset", StringComparison.OrdinalIgnoreCase))
			{
				MoonRegistrationHandler.MoonGroupAlgorithm.FilterSteps.Clear();
				MoonRegistrationHandler.MoonGroupAlgorithm.FilterSteps.Add(new VisibleFilterStep());
				return "Removed Filters.\n\n";
			}
			HashSet<NamespacedKey> hashSet = new HashSet<NamespacedKey>();
			foreach (DawnMoonInfo value in LethalContent.Moons.Values)
			{
				foreach (NamespacedKey item in value.AllTags())
				{
					if (item.Key.StartsWith(userInput, StringComparison.OrdinalIgnoreCase))
					{
						hashSet.Add(item);
					}
				}
			}
			if (hashSet.Count == 0)
			{
				return "Please enter a valid tag to filter for (type `filter none` or `filter reset` to remove all filters).\n\n";
			}
			foreach (NamespacedKey item2 in hashSet)
			{
				MoonRegistrationHandler.MoonGroupAlgorithm.FilterSteps.Add(new TagFilterStep(item2));
			}
			string text = string.Join(", ", (from tag in hashSet
				select tag.Key into tag
				orderby tag
				select tag).ToArray());
			string text2 = ((hashSet.Count == 1) ? string.Empty : "s");
			return "Filtering for the following tag" + text2 + ": " + text + "\n\n";
		}
	}
	public sealed class DawnComplexCommandInfo
	{
		public DawnTerminalCommandInfo ParentInfo { get; internal set; }

		public List<TerminalNode> ResultNodes { get; }

		public List<TerminalKeyword> SecondaryTerminalKeywords { get; }

		internal DawnComplexCommandInfo(List<TerminalNode> resultNodes, List<TerminalKeyword> secondaryTerminalKeywords)
		{
			ResultNodes = resultNodes;
			SecondaryTerminalKeywords = secondaryTerminalKeywords;
		}

		internal void SetupComplexCommand()
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Expected O, but got Unknown
			CompatibleNoun[] array = (CompatibleNoun[])(object)new CompatibleNoun[SecondaryTerminalKeywords.Count];
			for (int i = 0; i < SecondaryTerminalKeywords.Count; i++)
			{
				array[i] = new CompatibleNoun(SecondaryTerminalKeywords[i], ResultNodes[i]);
			}
			foreach (TerminalKeyword commandKeyword in ParentInfo.CommandKeywords)
			{
				commandKeyword.compatibleNouns = array;
				commandKeyword.isVerb = true;
			}
			foreach (TerminalNode resultNode in ResultNodes)
			{
				resultNode.SetDawnInfo(ParentInfo);
			}
		}

		internal void InjectCommandIntoTerminal(Terminal terminal)
		{
			TerminalKeyword[] allKeywords = terminal.terminalNodes.allKeywords;
			List<TerminalKeyword> commandKeywords = ParentInfo.CommandKeywords;
			int num = 0;
			TerminalKeyword[] array = (TerminalKeyword[])(object)new TerminalKeyword[allKeywords.Length + commandKeywords.Count];
			ReadOnlySpan<TerminalKeyword> readOnlySpan = new ReadOnlySpan<TerminalKeyword>(allKeywords);
			readOnlySpan.CopyTo(new Span<TerminalKeyword>(array).Slice(num, readOnlySpan.Length));
			num += readOnlySpan.Length;
			foreach (TerminalKeyword item in commandKeywords)
			{
				array[num] = item;
				num++;
			}
			TerminalKeyword[] allKeywords2 = array;
			terminal.terminalNodes.allKeywords = allKeywords2;
		}
	}
	public sealed class DawnComplexQueryCommandInfo
	{
		public DawnTerminalCommandInfo ParentInfo { get; internal set; }

		public List<TerminalKeyword> ContinueKeywords { get; }

		public TerminalKeyword? CancelKeyword { get; }

		public List<Func<bool>> ContinueConditions { get; private set; }

		public List<Action<bool>> OnContinuedEvents { get; private set; }

		public List<TerminalNode> ResultNodes { get; }

		public TerminalNode ContinueOrCancelNode { get; }

		public TerminalNode? CancelNode { get; }

		internal DawnComplexQueryCommandInfo(List<TerminalNode> resultNodes, TerminalNode continueOrCancelNode, TerminalNode? cancelNode, List<TerminalKeyword> continueKeywords, TerminalKeyword? cancelKeyword, List<Func<bool>> continueConditions, List<Action<bool>> onContinuedEvents)
		{
			ResultNodes = resultNodes;
			ContinueOrCancelNode = continueOrCancelNode;
			CancelNode = cancelNode;
			ContinueKeywords = continueKeywords;
			CancelKeyword = cancelKeyword;
			ContinueConditions = continueConditions;
			OnContinuedEvents = onContinuedEvents;
		}

		internal void SetupComplexQueryCommand()
		{
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Expected O, but got Unknown
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Expected O, but got Unknown
			foreach (TerminalKeyword commandKeyword in ParentInfo.CommandKeywords)
			{
				commandKeyword.specialKeywordResult = ContinueOrCancelNode;
			}
			ContinueOrCancelNode.overrideOptions = true;
			CompatibleNoun[] array = (CompatibleNoun[])(object)new CompatibleNoun[ContinueKeywords.Count + (((Object)(object)CancelKeyword != (Object)null) ? 1 : 0)];
			for (int i = 0; i < ContinueKeywords.Count; i++)
			{
				array[i] = new CompatibleNoun(ContinueKeywords[i], ResultNodes[i]);
			}
			if ((Object)(object)CancelKeyword != (Object)null)
			{
				array[^1] = new CompatibleNoun(CancelKeyword, CancelNode);
			}
			ContinueOrCancelNode.terminalOptions = array;
			foreach (TerminalNode resultNode in ResultNodes)
			{
				resultNode.SetDawnInfo(ParentInfo);
			}
		}

		internal void InjectCommandIntoTerminal(Terminal terminal)
		{
			TerminalKeyword[] allKeywords = terminal.terminalNodes.allKeywords;
			List<TerminalKeyword> commandKeywords = ParentInfo.CommandKeywords;
			List<TerminalKeyword> continueKeywords = ContinueKeywords;
			List<TerminalKeyword> list = new List<TerminalKeyword>(allKeywords.Length + commandKeywords.Count + continueKeywords.Count);
			list.AddRange(allKeywords);
			list.AddRange(commandKeywords);
			list.AddRange(continueKeywords);
			List<TerminalKeyword> list2 = list;
			if ((Object)(object)CancelKeyword != (Object)null)
			{
				list2.Add(CancelKeyword);
			}
			terminal.terminalNodes.allKeywords = list2.ToArray();
		}
	}
	public sealed class DawnEventDrivenCommandInfo
	{
		public DawnTerminalCommandInfo ParentInfo { get; internal set; }

		public TerminalNode ResultNode { get; }

		public Action<Terminal, TerminalNode> OnTerminalEvent { get; }

		internal DawnEventDrivenCommandInfo(TerminalNode resultNode, Action<Terminal, TerminalNode> onTerminalEvent)
		{
			ResultNode = resultNode;
			OnTerminalEvent = onTerminalEvent;
		}

		internal void SetupEventDrivenCommand()
		{
			foreach (TerminalKeyword commandKeyword in ParentInfo.CommandKeywords)
			{
				commandKeyword.specialKeywordResult = ResultNode;
			}
			ResultNode.SetDawnInfo(ParentInfo);
		}

		internal void InjectCommandIntoTerminal(Terminal terminal)
		{
			TerminalKeyword[] allKeywords = terminal.terminalNodes.allKeywords;
			List<TerminalKeyword> commandKeywords = ParentInfo.CommandKeywords;
			int num = 0;
			TerminalKeyword[] array = (TerminalKeyword[])(object)new TerminalKeyword[allKeywords.Length + commandKeywords.Count];
			ReadOnlySpan<TerminalKeyword> readOnlySpan = new ReadOnlySpan<TerminalKeyword>(allKeywords);
			readOnlySpan.CopyTo(new Span<TerminalKeyword>(array).Slice(num, readOnlySpan.Length));
			num += readOnlySpan.Length;
			foreach (TerminalKeyword item in commandKeywords)
			{
				array[num] = item;
				num++;
			}
			TerminalKeyword[] allKeywords2 = array;
			terminal.terminalNodes.allKeywords = allKeywords2;
		}
	}
	public sealed class DawnInputCommandInfo
	{
		public DawnTerminalCommandInfo ParentInfo { get; internal set; }

		public Func<string, string> DynamicInputTextResult { get; }

		public TerminalNode ResultNode { get; }

		public TerminalKeyword InputKeyword { get; }

		internal DawnInputCommandInfo(TerminalNode resultNode, Func<string, string> dynamicInputTextResult)
		{
			ResultNode = resultNode;
			DynamicInputTextResult = dynamicInputTextResult;
		}

		internal void SetupInputCommand()
		{
			foreach (TerminalKeyword commandKeyword in ParentInfo.CommandKeywords)
			{
				commandKeyword.specialKeywordResult = ResultNode;
				commandKeyword.SetKeywordAcceptInput(value: true);
			}
			ResultNode.SetDawnInfo(ParentInfo);
		}

		internal void InjectCommandIntoTerminal(Terminal terminal)
		{
			TerminalKeyword[] allKeywords = terminal.terminalNodes.allKeywords;
			List<TerminalKeyword> commandKeywords = ParentInfo.CommandKeywords;
			int num = 0;
			TerminalKeyword[] array = (TerminalKeyword[])(object)new TerminalKeyword[allKeywords.Length + commandKeywords.Count];
			ReadOnlySpan<TerminalKeyword> readOnlySpan = new ReadOnlySpan<TerminalKeyword>(allKeywords);
			readOnlySpan.CopyTo(new Span<TerminalKeyword>(array).Slice(num, readOnlySpan.Length));
			num += readOnlySpan.Length;
			foreach (TerminalKeyword item in commandKeywords)
			{
				array[num] = item;
				num++;
			}
			TerminalKeyword[] allKeywords2 = array;
			terminal.terminalNodes.allKeywords = allKeywords2;
		}

		public static string GetLastUserInput()
		{
			if ((Object)(object)TerminalRefs.Instance == (Object)null)
			{
				return "Terminal not Initialized yet";
			}
			string text = TerminalRefs.Instance.screenText.text;
			int textAdded = TerminalRefs.Instance.textAdded;
			int length = text.Length;
			int num = length - textAdded;
			string text2 = text.Substring(num, length - num);
			if (string.IsNullOrEmpty(TerminalRefs.Instance.GetLastCommand()))
			{
				return string.Empty;
			}
			return text2.Replace(TerminalRefs.Instance.GetLastCommand(), "").Trim();
		}
	}
	public sealed class DawnSimpleCommandInfo
	{
		public DawnTerminalCommandInfo ParentInfo { get; internal set; }

		public TerminalNode ResultNode { get; }

		internal DawnSimpleCommandInfo(TerminalNode resultNode)
		{
			ResultNode = resultNode;
		}

		internal void SetupSimpleCommand()
		{
			foreach (TerminalKeyword commandKeyword in ParentInfo.CommandKeywords)
			{
				commandKeyword.specialKeywordResult = ResultNode;
			}
			ResultNode.SetDawnInfo(ParentInfo);
		}

		internal void InjectCommandIntoTerminal(Terminal terminal)
		{
			TerminalKeyword[] allKeywords = terminal.terminalNodes.allKeywords;
			List<TerminalKeyword> commandKeywords = ParentInfo.CommandKeywords;
			int num = 0;
			TerminalKeyword[] array = (TerminalKeyword[])(object)new TerminalKeyword[allKeywords.Length + commandKeywords.Count];
			ReadOnlySpan<TerminalKeyword> readOnlySpan = new ReadOnlySpan<TerminalKeyword>(allKeywords);
			readOnlySpan.CopyTo(new Span<TerminalKeyword>(array).Slice(num, readOnlySpan.Length));
			num += readOnlySpan.Length;
			foreach (TerminalKeyword item in commandKeywords)
			{
				array[num] = item;
				num++;
			}
			TerminalKeyword[] allKeywords2 = array;
			terminal.terminalNodes.allKeywords = allKeywords2;
		}
	}
	public sealed class DawnSimpleQueryCommandInfo
	{
		public DawnTerminalCommandInfo ParentInfo { get; internal set; }

		public TerminalKeyword ContinueKeyword { get; }

		public TerminalKeyword CancelKeyword { get; }

		public Func<bool> ContinueCondition { get; private set; }

		public Action<bool> OnContinuedEvent { get; private set; }

		public TerminalNode ResultNode { get; }

		public TerminalNode ContinueOrCancelNode { get; }

		public TerminalNode CancelNode { get; }

		internal DawnSimpleQueryCommandInfo(TerminalNode resultNode, TerminalNode continueOrCancelNode, TerminalNode cancelNode, TerminalKeyword continueKeyword, TerminalKeyword cancelKeyword, Func<bool> continueCondition, Action<bool> onContinuedEvent)
		{
			ResultNode = resultNode;
			ContinueOrCancelNode = continueOrCancelNode;
			CancelNode = cancelNode;
			ContinueKeyword = continueKeyword;
			CancelKeyword = cancelKeyword;
			ContinueCondition = continueCondition;
			OnContinuedEvent = onContinuedEvent;
		}

		internal void SetupSimpleQueryCommand()
		{
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Expected O, but got Unknown
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Expected O, but got Unknown
			foreach (TerminalKeyword commandKeyword in ParentInfo.CommandKeywords)
			{
				commandKeyword.specialKeywordResult = ContinueOrCancelNode;
			}
			ContinueOrCancelNode.overrideOptions = true;
			ContinueOrCancelNode.terminalOptions = (CompatibleNoun[])(object)new CompatibleNoun[2]
			{
				new CompatibleNoun(ContinueKeyword, ResultNode),
				new CompatibleNoun(CancelKeyword, CancelNode)
			};
			ResultNode.SetDawnInfo(ParentInfo);
		}

		internal void InjectCommandIntoTerminal(Terminal terminal)
		{
			TerminalKeyword[] allKeywords = terminal.terminalNodes.allKeywords;
			List<TerminalKeyword> commandKeywords = ParentInfo.CommandKeywords;
			int num = 0;
			TerminalKeyword[] array = (TerminalKeyword[])(object)new TerminalKeyword[2 + (allKeywords.Length + commandKeywords.Count)];
			ReadOnlySpan<TerminalKeyword> readOnlySpan = new ReadOnlySpan<TerminalKeyword>(allKeywords);
			readOnlySpan.CopyTo(new Span<TerminalKeyword>(array).Slice(num, readOnlySpan.Length));
			num += readOnlySpan.Length;
			foreach (TerminalKeyword item in commandKeywords)
			{
				array[num] = item;
				num++;
			}
			array[num] = ContinueKeyword;
			num++;
			array[num] = CancelKeyword;
			TerminalKeyword[] allKeywords2 = array;
			terminal.terminalNodes.allKeywords = allKeywords2;
		}
	}
	public sealed class DawnTerminalCommandInfo : DawnBaseInfo<DawnTerminalCommandInfo>
	{
		public TerminalCommandBasicInformation CommandBasicInformation { get; }

		public List<TerminalKeyword> CommandKeywords { get; }

		public bool BuildOnTerminalAwake { get; }

		public DawnComplexQueryCommandInfo? ComplexQueryCommandInfo { get; }

		public DawnSimpleQueryCommandInfo? SimpleQueryCommandInfo { get; }

		public DawnComplexCommandInfo? ComplexCommandInfo { get; }

		public DawnSimpleCommandInfo? SimpleCommandInfo { get; }

		public DawnTerminalObjectCommandInfo? TerminalObjectCommandInfo { get; }

		public DawnEventDrivenCommandInfo? EventDrivenCommandInfo { get; }

		public DawnInputCommandInfo? InputCommandInfo { get; }

		public bool CommandInjected { get; private set; }

		internal DawnTerminalCommandInfo(NamespacedKey<DawnTerminalCommandInfo> key, TerminalCommandBasicInformation commandBasicInformation, List<TerminalKeyword> commandKeywords, bool buildOnTerminalAwake, HashSet<NamespacedKey> tags, DawnComplexQueryCommandInfo? complexQueryCommandInfo, DawnSimpleQueryCommandInfo? simpleQueryCommandInfo, DawnComplexCommandInfo? complexCommandInfo, DawnSimpleCommandInfo? simpleCommandInfo, DawnTerminalObjectCommandInfo? terminalObjectCommandInfo, DawnEventDrivenCommandInfo? eventDrivenCommandInfo, DawnInputCommandInfo? inputCommandInfo, IDataContainer? customData)
			: base(key, tags, customData)
		{
			CommandBasicInformation = commandBasicInformation;
			CommandKeywords = commandKeywords;
			BuildOnTerminalAwake = buildOnTerminalAwake;
			ComplexQueryCommandInfo = complexQueryCommandInfo;
			if (ComplexQueryCommandInfo != null)
			{
				ComplexQueryCommandInfo.ParentInfo = this;
				if (!ShouldSkipIgnoreOverride())
				{
					ComplexQueryCommandInfo.SetupComplexQueryCommand();
				}
			}
			SimpleQueryCommandInfo = simpleQueryCommandInfo;
			if (SimpleQueryCommandInfo != null)
			{
				SimpleQueryCommandInfo.ParentInfo = this;
				if (!ShouldSkipIgnoreOverride())
				{
					SimpleQueryCommandInfo.SetupSimpleQueryCommand();
				}
			}
			ComplexCommandInfo = complexCommandInfo;
			if (ComplexCommandInfo != null)
			{
				ComplexCommandInfo.ParentInfo = this;
				if (!ShouldSkipIgnoreOverride())
				{
					ComplexCommandInfo.SetupComplexCommand();
				}
			}
			SimpleCommandInfo = simpleCommandInfo;
			if (SimpleCommandInfo != null)
			{
				SimpleCommandInfo.ParentInfo = this;
				if (!ShouldSkipIgnoreOverride())
				{
					SimpleCommandInfo.SetupSimpleCommand();
				}
			}
			TerminalObjectCommandInfo = terminalObjectCommandInfo;
			if (TerminalObjectCommandInfo != null)
			{
				TerminalObjectCommandInfo.ParentInfo = this;
				if (!ShouldSkipIgnoreOverride())
				{
					TerminalObjectCommandInfo.SetupTerminalObjectCommand();
				}
			}
			EventDrivenCommandInfo = eventDrivenCommandInfo;
			if (EventDrivenCommandInfo != null)
			{
				EventDrivenCommandInfo.ParentInfo = this;
				if (!ShouldSkipIgnoreOverride())
				{
					EventDrivenCommandInfo.SetupEventDrivenCommand();
				}
			}
			InputCommandInfo = inputCommandInfo;
			if (InputCommandInfo != null)
			{
				InputCommandInfo.ParentInfo = this;
				if (!ShouldSkipIgnoreOverride())
				{
					InputCommandInfo.SetupInputCommand();
				}
			}
		}

		public void InjectCommandIntoTerminal(Terminal terminal)
		{
			if (CommandInjected)
			{
				DawnPlugin.Logger.LogWarning((object)$"Command {base.Key} already injected into terminal, yet tried to inject again.");
				return;
			}
			CommandInjected = true;
			if (ComplexQueryCommandInfo != null)
			{
				ComplexQueryCommandInfo.InjectCommandIntoTerminal(terminal);
			}
			if (SimpleQueryCommandInfo != null)
			{
				SimpleQueryCommandInfo.InjectCommandIntoTerminal(terminal);
			}
			if (ComplexCommandInfo != null)
			{
				ComplexCommandInfo.InjectCommandIntoTerminal(terminal);
			}
			if (SimpleCommandInfo != null)
			{
				SimpleCommandInfo.InjectCommandIntoTerminal(terminal);
			}
			if (TerminalObjectCommandInfo != null)
			{
				TerminalObjectCommandInfo.InjectCommandIntoTerminal(terminal);
			}
			if (EventDrivenCommandInfo != null)
			{
				EventDrivenCommandInfo.InjectCommandIntoTerminal(terminal);
			}
			if (InputCommandInfo != null)
			{
				InputCommandInfo.InjectCommandIntoTerminal(terminal);
			}
		}
	}
	public sealed class DawnTerminalObjectCommandInfo
	{
		public DawnTerminalCommandInfo ParentInfo { get; internal set; }

		internal DawnTerminalObjectCommandInfo()
		{
		}

		internal void SetupTerminalObjectCommand()
		{
			foreach (TerminalKeyword commandKeyword in ParentInfo.CommandKeywords)
			{
				commandKeyword.accessTerminalObjects = true;
			}
		}

		internal void InjectCommandIntoTerminal(Terminal terminal)
		{
			TerminalKeyword[] allKeywords = terminal.terminalNodes.allKeywords;
			List<TerminalKeyword> commandKeywords = ParentInfo.CommandKeywords;
			int num = 0;
			TerminalKeyword[] array = (TerminalKeyword[])(object)new TerminalKeyword[allKeywords.Length + commandKeywords.Count];
			ReadOnlySpan<TerminalKeyword> readOnlySpan = new ReadOnlySpan<TerminalKeyword>(allKeywords);
			readOnlySpan.CopyTo(new Span<TerminalKeyword>(array).Slice(num, readOnlySpan.Length));
			num += readOnlySpan.Length;
			foreach (TerminalKeyword item in commandKeywords)
			{
				array[num] = item;
				num++;
			}
			TerminalKeyword[] allKeywords2 = array;
			terminal.terminalNodes.allKeywords = allKeywords2;
		}
	}
	[Flags]
	public enum ClearText
	{
		None = 0,
		Result = 1,
		Query = 2,
		Cancel = 4
	}
	[Serializable]
	public class TerminalCommandBasicInformation
	{
		[field: SerializeField]
		public string CommandName { get; private set; }

		[field: SerializeField]
		public string CategoryName { get; private set; }

		[field: SerializeField]
		public string Description { get; private set; }

		[field: SerializeField]
		public ClearText ClearTextFlags { get; private set; }

		public TerminalCommandBasicInformation(string commandName, string categoryName, string description, ClearText clearTextFlags)
		{
			CommandName = commandName;
			CategoryName = categoryName;
			Description = description;
			ClearTextFlags = clearTextFlags;
			base..ctor();
		}
	}
	public class TerminalCommandInfoBuilder : BaseInfoBuilder<DawnTerminalCommandInfo, TerminalCommandBasicInformation, TerminalCommandInfoBuilder>
	{
		public class ComplexQueryCommandBuilder
		{
			private TerminalCommandInfoBuilder _parentBuilder;

			private List<Func<string>> _resultDisplayTexts;

			private Func<string> _continueOrCancelDisplayText;

			private Func<string>? _cancelDisplayText;

			private string _cancelKeyword;

			private List<string> _continueKeywords;

			private List<Func<bool>> _continueConditions = new List<Func<bool>>();

			private List<Action<bool>> _onQueryContinuedEvents = new List<Action<bool>>();

			internal ComplexQueryCommandBuilder(TerminalCommandInfoBuilder parent)
			{
				_parentBuilder = parent;
			}

			public ComplexQueryCommandBuilder SetResultDisplayTexts(List<Func<string>> resultDisplayTexts)
			{
				_resultDisplayTexts = resultDisplayTexts;
				return this;
			}

			public ComplexQueryCommandBuilder SetContinueOrCancelDisplayTexts(Func<string> continueOrCancelDisplayText)
			{
				_continueOrCancelDisplayText = continueOrCancelDisplayText;
				return this;
			}

			public ComplexQueryCommandBuilder SetCancelDisplayText(Func<string> cancelDisplayText)
			{
				_cancelDisplayText = cancelDisplayText;
				return this;
			}

			public ComplexQueryCommandBuilder SetContinueKeywords(List<string> continueKeywords)
			{
				_continueKeywords = continueKeywords;
				return this;
			}

			public ComplexQueryCommandBuilder SetCancelKeyword(string cancelKeyword)
			{
				_cancelKeyword = cancelKeyword;
				return this;
			}

			public ComplexQueryCommandBuilder SetContinueConditions(List<Func<bool>> continueConditions)
			{
				_continueConditions = continueConditions;
				return this;
			}

			public ComplexQueryCommandBuilder SetOnQueryContinuedEvents(List<Action<bool>> onQueryContinuedEvents)
			{
				_onQueryContinuedEvents = onQueryContinuedEvents;
				return this;
			}

			internal DawnComplexQueryCommandInfo Build()
			{
				TerminalNode val = new TerminalNodeBuilder($"{_parentBuilder.key}:ContinueNode").SetDisplayText(_continueOrCancelDisplayText()).SetClearPreviousText(_parentBuilder.value.ClearTextFlags.HasFlag(ClearText.Query)).SetMaxCharactersToType(35)
					.Build();
				val.SetDynamicDisplayText(_continueOrCancelDisplayText);
				TerminalNode val2 = null;
				if (_cancelDisplayText != null)
				{
					val2 = new TerminalNodeBuilder($"{_parentBuilder.key}:CancelNode").SetDisplayText(_cancelDisplayText()).SetClearPreviousText(_parentBuilder.value.ClearTextFlags.HasFlag(ClearText.Cancel)).SetMaxCharactersToType(35)
						.Build();
					val2.SetDynamicDisplayText(_cancelDisplayText);
				}
				TerminalKeyword cancelKeyword = null;
				if (!string.IsNullOrEmpty(_cancelKeyword))
				{
					cancelKeyword = new TerminalKeywordBuilder($"{_parentBuilder.key}:CancelKeyword", _cancelKeyword).Build();
				}
				List<TerminalNode> list = new List<TerminalNode>();
				List<TerminalKeyword> list2 = new List<TerminalKeyword>();
				for (int i = 0; i < _resultDisplayTexts.Count; i++)
				{
					TerminalNode val3 = new TerminalNodeBuilder($"{_parentBuilder.key}:ResultNode").SetDisplayText(_resultDisplayTexts[i]()).SetClearPreviousText(_parentBuilder.value.ClearTextFlags.HasFlag(ClearText.Result)).SetMaxCharactersToType(35)
						.Build();
					val3.SetDynamicDisplayText(_resultDisplayTexts[i]);
					list.Add(val3);
					if (_continueConditions.Count <= i)
					{
						_continueConditions.Add(() => true);
					}
					if (_onQueryContinuedEvents.Count <= i)
					{
						_onQueryContinuedEvents.Add(delegate
						{
						});
					}
					if (_continueKeywords.Count <= i)
					{
						_continueKeywords.Add("continue");
						DawnPlugin.Logger.LogWarning((object)$"Query '{_parentBuilder.key}' didn't set continue word. Defaulting to '{_continueKeywords}'");
					}
					TerminalKeyword item = new TerminalKeywordBuilder($"{_parentBuilder.key}:ContinueKeyword", _continueKeywords[i]).Build();
					list2.Add(item);
				}
				return new DawnComplexQueryCommandInfo(list, val, val2, list2, cancelKeyword, _continueConditions, _onQueryContinuedEvents);
			}
		}

		public class SimpleQueryCommandBuilder
		{
			private TerminalCommandInfoBuilder _parentBuilder;

			private Func<string> _resultDisplayText;

			private Func<string> _continueOrCancelDisplayText;

			private Func<string> _cancelDisplayText;

			private string _continueKeyword;

			private string _cancelKeyword;

			private Func<bool> _continueCondition;

			private Action<bool> _onQueryContinuedEvent;

			internal SimpleQueryCommandBuilder(TerminalCommandInfoBuilder parent)
			{
				_parentBuilder = parent;
			}

			public SimpleQueryCommandBuilder SetResult(Func<string> resultDisplayText)
			{
				_resultDisplayText = resultDisplayText;
				return this;
			}

			public SimpleQueryCommandBuilder SetContinueOrCancel(Func<string> continueOrCancelDisplayText)
			{
				_continueOrCancelDisplayText = continueOrCancelDisplayText;
				return this;
			}

			public SimpleQueryCommandBuilder SetCancel(Func<string> cancelDisplayText)
			{
				_cancelDisplayText = cancelDisplayText;
				return this;
			}

			public SimpleQueryCommandBuilder SetContinueConditions(Func<bool> continueProvider)
			{
				_continueCondition = continueProvider;
				return this;
			}

			public SimpleQueryCommandBuilder SetQueryEvent(Action<bool> onQueryContinuedEvent)
			{
				_onQueryContinuedEvent = onQueryContinuedEvent;
				return this;
			}

			public SimpleQueryCommandBuilder SetContinueWord(string continueKeyword)
			{
				_continueKeyword = continueKeyword;
				return this;
			}

			public SimpleQueryCommandBuilder SetCancelWord(string cancelKeyword)
			{
				_cancelKeyword = cancelKeyword;
				return this;
			}

			internal DawnSimpleQueryCommandInfo Build()
			{
				if (_continueCondition == null)
				{
					_continueCondition = () => true;
				}
				if (_onQueryContinuedEvent == null)
				{
					_onQueryContinuedEvent = delegate
					{
					};
				}
				TerminalNode val = new TerminalNodeBuilder($"{_parentBuilder.key}:ResultNode").SetDisplayText(_resultDisplayText()).SetClearPreviousText(_parentBuilder.value.ClearTextFlags.HasFlag(ClearText.Result)).SetMaxCharactersToType(35)
					.Build();
				val.SetDynamicDisplayText(_resultDisplayText);
				TerminalNode val2 = new TerminalNodeBuilder($"{_parentBuilder.key}:ContinueNode").SetDisplayText(_continueOrCancelDisplayText()).SetClearPreviousText(_parentBuilder.value.ClearTextFlags.HasFlag(ClearText.Query)).SetMaxCharactersToType(35)
					.Build();
				val2.SetDynamicDisplayText(_continueOrCancelDisplayText);
				TerminalNode val3 = new TerminalNodeBuilder($"{_parentBuilder.key}:CancelNode").SetDisplayText(_cancelDisplayText()).SetClearPreviousText(_parentBuilder.value.ClearTextFlags.HasFlag(ClearText.Cancel)).SetMaxCharactersToType(35)
					.Build();
				val3.SetDynamicDisplayText(_cancelDisplayText);
				if (string.IsNullOrEmpty(_cancelKeyword))
				{
					_cancelKeyword = "deny";
					DawnPlugin.Logger.LogWarning((object)$"Query '{_parentBuilder.key}' didn't set cancel word. Defaulting to '{_cancelKeyword}'");
				}
				if (string.IsNullOrEmpty(_continueKeyword))
				{
					_continueKeyword = "confirm";
					DawnPlugin.Logger.LogWarning((object)$"Query '{_parentBuilder.key}' didn't set continue word. Defaulting to '{_continueKeyword}'");
				}
				TerminalKeyword continueKeyword = new TerminalKeywordBuilder($"{_parentBuilder.key}:ContinueKeyword", _continueKeyword).Build();
				TerminalKeyword cancelKeyword = new TerminalKeywordBuilder($"{_parentBuilder.key}:CancelKeyword", _cancelKeyword).Build();
				return new DawnSimpleQueryCommandInfo(val, val2, val3, continueKeyword, cancelKeyword, _continueCondition, _onQueryContinuedEvent);
			}
		}

		public class ComplexCommandBuilder
		{
			private TerminalCommandInfoBuilder _parentBuilder;

			private List<string> _secondaryKeywords = new List<string>();

			private List<Func<string>> _resultDisplayTexts = new List<Func<string>>();

			internal ComplexCommandBuilder(TerminalCommandInfoBuilder parent)
			{
				_parentBuilder = parent;
			}

			public ComplexCommandBuilder SetSecondaryKeywords(List<string> secondaryKeywords)
			{
				_secondaryKeywords = secondaryKeywords;
				return this;
			}

			public ComplexCommandBuilder SetResultsDisplayText(List<Func<string>> resultDisplayTexts)
			{
				_resultDisplayTexts = resultDisplayTexts;
				return this;
			}

			internal DawnComplexCommandInfo Build()
			{
				if (_secondaryKeywords.Count <= 0)
				{
					throw new ArgumentException($"Command: '{_parentBuilder.key}' didn't set any keywords, this will cause issues.");
				}
				if (_secondaryKeywords.Count != _resultDisplayTexts.Count)
				{
					throw new ArgumentException($"Command: '{_parentBuilder.key}' didn't set the same amount of keywords as results.");
				}
				List<TerminalNode> list = new List<TerminalNode>();
				List<TerminalKeyword> list2 = new List<TerminalKeyword>();
				foreach (string secondaryKeyword in _secondaryKeywords)
				{
					TerminalKeyword item = new TerminalKeywordBuilder($"{_parentBuilder.key}:{secondaryKeyword}", secondaryKeyword).Build();
					list2.Add(item);
				}
				foreach (Func<string> resultDisplayText in _resultDisplayTexts)
				{
					TerminalNode val = new TerminalNodeBuilder($"{_parentBuilder.key}:ResultNode").SetClearPreviousText(_parentBuilder.value.ClearTextFlags.HasFlag(ClearText.Result)).SetDisplayText(resultDisplayText()).Build();
					val.SetDynamicDisplayText(resultDisplayText);
					list.Add(val);
				}
				return new DawnComplexCommandInfo(list, list2);
			}
		}

		public class SimpleCommandBuilder
		{
			private TerminalCommandInfoBuilder _parentBuilder;

			private Func<string> _resultDisplayText;

			internal SimpleCommandBuilder(TerminalCommandInfoBuilder parent)
			{
				_parentBuilder = parent;
			}

			public SimpleCommandBuilder SetResultDisplayText(Func<string> resultDisplayText)
			{
				_resultDisplayText = resultDisplayText;
				return this;
			}

			internal DawnSimpleCommandInfo Build()
			{
				TerminalNode val = new TerminalNodeBuilder($"{_parentBuilder.key}:ResultNode").SetClearPreviousText(_parentBuilder.value.ClearTextFlags.HasFlag(ClearText.Result)).SetDisplayText(_resultDisplayText()).Build();
				val.SetDynamicDisplayText(_resultDisplayText);
				return new DawnSimpleCommandInfo(val);
			}
		}

		public class TerminalObjectCommandBuilder
		{
			private TerminalCommandInfoBuilder _parentBuilder;

			internal TerminalObjectCommandBuilder(TerminalCommandInfoBuilder parent)
			{
				_parentBuilder = parent;
			}

			internal DawnTerminalObjectCommandInfo Build()
			{
				return new DawnTerminalObjectCommandInfo();
			}
		}

		public class EventDrivenCommandBuilder
		{
			private TerminalCommandInfoBuilder _parentBuilder;

			private Func<string> _resultNodeDisplayText;

			private TerminalNode _resultNode;

			private Action<Terminal, TerminalNode> _onTerminalEvent;

			internal EventDrivenCommandBuilder(TerminalCommandInfoBuilder parent)
			{
				_parentBuilder = parent;
			}

			public EventDrivenCommandBuilder SetResultNodeDisplayText(Func<string> resultNodeDisplayText)
			{
				_resultNodeDisplayText = resultNodeDisplayText;
				return this;
			}

			public EventDrivenCommandBuilder OverrideResultNode(TerminalNode resultNode)
			{
				_resultNode = resultNode;
				return this;
			}

			public EventDrivenCommandBuilder SetOnTerminalEvent(Action<Terminal, TerminalNode> onTerminalEvent)
			{
				_onTerminalEvent = onTerminalEvent;
				return this;
			}

			internal DawnEventDrivenCommandInfo Build()
			{
				if ((Object)(object)_resultNode == (Object)null)
				{
					_resultNode = new TerminalNodeBuilder($"{_parentBuilder.key}:ResultNode").SetClearPreviousText(_parentBuilder.value.ClearTextFlags.HasFlag(ClearText.Result)).SetDisplayText(_resultNodeDisplayText()).Build();
					_resultNode.SetDynamicDisplayText(_resultNodeDisplayText);
				}
				if (_onTerminalEvent == null)
				{
					throw new ArgumentException($"Event driven command: '{_parentBuilder.key}' didn't set onTerminalEvent.");
				}
				return new DawnEventDrivenCommandInfo(_resultNode, _onTerminalEvent);
			}
		}

		public class InputCommandBuilder
		{
			private TerminalCommandInfoBuilder _parentBuilder;

			private Func<string, string> _resultDisplayText;

			internal InputCommandBuilder(TerminalCommandInfoBuilder parent)
			{
				_parentBuilder = parent;
			}

			public InputCommandBuilder SetResultDisplayText(Func<string, string> resultDisplayText)
			{
				_resultDisplayText = resultDisplayText;
				return this;
			}

			internal DawnInputCommandInfo Build()
			{
				if (_resultDisplayText == null)
				{
					throw new ArgumentException($"Input command: '{_parentBuilder.key}' didn't set result display text.");
				}
				TerminalNode resultNode = new TerminalNodeBuilder($"{_parentBuilder.key}:ResultNode").SetClearPreviousText(_parentBuilder.value.ClearTextFlags.HasFlag(ClearText.Result)).SetDisplayText(_resultDisplayText(DawnInputCommandInfo.GetLastUserInput())).Build();
				return new DawnInputCommandInfo(resultNode, _resultDisplayText);
			}
		}

		private DawnComplexQueryCommandInfo? _complexQueryCommandInfo;

		private DawnSimpleQueryCommandInfo? _simpleQueryCommandInfo;

		private DawnComplexCommandInfo? _complexCommandInfo;

		private DawnSimpleCommandInfo? _simpleCommandInfo;

		private DawnTerminalObjectCommandInfo? _terminalObjectCommandInfo;

		private DawnEventDrivenCommandInfo? _eventDrivenCommandInfo;

		private DawnInputCommandInfo? _inputCommandInfo;

		private List<string> _keywords = new List<string>();

		private bool _buildOnTerminalAwake = true;

		public TerminalCommandInfoBuilder DefineComplexQueryCommand(Action<ComplexQueryCommandBuilder> callback)
		{
			ComplexQueryCommandBuilder complexQueryCommandBuilder = new ComplexQueryCommandBuilder(this);
			callback(complexQueryCommandBuilder);
			_complexQueryCommandInfo = complexQueryCommandBuilder.Build();
			return this;
		}

		public TerminalCommandInfoBuilder DefineSimpleQueryCommand(Action<SimpleQueryCommandBuilder> callback)
		{
			SimpleQueryCommandBuilder simpleQueryCommandBuilder = new SimpleQueryCommandBuilder(this);
			callback(simpleQueryCommandBuilder);
			_simpleQueryCommandInfo = simpleQueryCommandBuilder.Build();
			return this;
		}

		public TerminalCommandInfoBuilder DefineComplexCommand(Action<ComplexCommandBuilder> callback)
		{
			ComplexCommandBuilder complexCommandBuilder = new ComplexCommandBuilder(this);
			callback(complexCommandBuilder);
			_complexCommandInfo = complexCommandBuilder.Build();
			return this;
		}

		public TerminalCommandInfoBuilder DefineSimpleCommand(Action<SimpleCommandBuilder> callback)
		{
			SimpleCommandBuilder simpleCommandBuilder = new SimpleCommandBuilder(this);
			callback(simpleCommandBuilder);
			_simpleCommandInfo = simpleCommandBuilder.Build();
			return this;
		}

		public TerminalCommandInfoBuilder DefineTerminalObjectCommand(Action<TerminalObjectCommandBuilder> callback)
		{
			TerminalObjectCommandBuilder terminalObjectCommandBuilder = new TerminalObjectCommandBuilder(this);
			callback(terminalObjectCommandBuilder);
			_terminalObjectCommandInfo = terminalObjectCommandBuilder.Build();
			return this;
		}

		public TerminalCommandInfoBuilder DefineEventDrivenCommand(Action<EventDrivenCommandBuilder> callback)
		{
			EventDrivenCommandBuilder eventDrivenCommandBuilder = new EventDrivenCommandBuilder(this);
			callback(eventDrivenCommandBuilder);
			_eventDrivenCommandInfo = eventDrivenCommandBuilder.Build();
			return this;
		}

		public TerminalCommandInfoBuilder DefineInputCommand(Action<InputCommandBuilder> callback)
		{
			InputCommandBuilder inputCommandBuilder = new InputCommandBuilder(this);
			callback(inputCommandBuilder);
			_inputCommandInfo = inputCommandBuilder.Build();
			return this;
		}

		public TerminalCommandInfoBuilder(NamespacedKey<DawnTerminalCommandInfo> key, TerminalCommandBasicInformation value)
			: base(key, value)
		{
		}

		public TerminalCommandInfoBuilder SetKeywords(List<string> keywords)
		{
			_keywords = keywords;
			return this;
		}

		public TerminalCommandInfoBuilder OverrideTerminalAwakeBuild()
		{
			_buildOnTerminalAwake = false;
			return this;
		}

		internal override DawnTerminalCommandInfo Build()
		{
			if (_keywords.Count <= 0)
			{
				throw new ArgumentException($"Command: '{base.key}' didn't set any keywords, this will cause issues.");
			}
			List<TerminalKeyword> list = new List<TerminalKeyword>();
			foreach (string keyword in _keywords)
			{
				TerminalKeyword item = new TerminalKeywordBuilder($"{base.key}_{keyword}", keyword, (DawnKeywordType)9).Build();
				list.Add(item);
			}
			return new DawnTerminalCommandInfo(base.key, base.value, list, _buildOnTerminalAwake, tags, _complexQueryCommandInfo, _simpleQueryCommandInfo, _complexCommandInfo, _simpleCommandInfo, _terminalObjectCommandInfo, _eventDrivenCommandInfo, _inputCommandInfo, customData);
		}
	}
	public static class TerminalNodeExtensions
	{
		public static bool TryGetDawnInfo(this TerminalNode terminalNode, [NotNullWhen(true)] out DawnTerminalCommandInfo? terminalCommandInfo)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			terminalCommandInfo = (DawnTerminalCommandInfo)((IDawnObject)terminalNode).DawnInfo;
			return terminalCommandInfo != null;
		}

		public static DawnTerminalCommandInfo GetDawnInfo(this TerminalNode terminalNode)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return (DawnTerminalCommandInfo)((IDawnObject)terminalNode).DawnInfo;
		}

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

		internal static void SetDawnInfo(this TerminalNode terminalNode, DawnTerminalCommandInfo terminalCommandInfo)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			((IDawnObject)terminalNode).DawnInfo = terminalCommandInfo;
		}

		public static string GetDisplayText(this TerminalNode terminalNode)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			DawnTerminalCommandInfo dawnInfo = terminalNode.GetDawnInfo();
			if (dawnInfo != null && dawnInfo.InputCommandInfo != null)
			{
				return dawnInfo.InputCommandInfo.DynamicInputTextResult(DawnInputCommandInfo.GetLastUserInput());
			}
			if (((ITerminalNode)terminalNode).DynamicDisplayText == null)
			{
				return terminalNode.displayText;
			}
			return ((ITerminalNode)terminalNode).DynamicDisplayText();
		}

		internal static void SetDynamicDisplayText(this TerminalNode terminalNode, Func<string> func)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			((ITerminalNode)terminalNode).DynamicDisplayText = func;
		}
	}
	public class VanillaTerminalEvents
	{
		public static Action<Terminal, TerminalNode> SetUpTerminalEvent => SetUpTerminal;

		public static Action<Terminal, TerminalNode> Cheat_ResetCreditsEvent => Cheat_ResetCredits;

		public static Action<Terminal, TerminalNode> SwitchCameraEvent => SwitchCamera;

		public static Action<Terminal, TerminalNode> EjectPlayersEvent => EjectPlayers;

		private static void SetUpTerminal(Terminal terminal, TerminalNode terminalNode)
		{
			ES3.Save<bool>("HasUsedTerminal", true, "LCGeneralSaveData");
		}

		private static void Cheat_ResetCredits(Terminal terminal, TerminalNode node)
		{
			if ((GameNetworkManager.Instance.localPlayerController.playerUsername == "Zeekerss" || GameNetworkManager.Instance.localPlayerController.playerUsername == "Blueray" || GameNetworkManager.Instance.localPlayerController.playerUsername == "Puffo") && ((NetworkBehaviour)GameNetworkManager.Instance.localPlayerController).IsServer)
			{
				terminal.useCreditsCooldown = true;
				terminal.groupCredits = 2500;
				terminal.SyncGroupCreditsServerRpc(terminal.groupCredits, terminal.numberOfItemsInDropship);
			}
		}

		private static void SwitchCamera(Terminal terminal, TerminalNode node)
		{
			StartOfRound.Instance.mapScreen.SwitchRadarTargetForward(true);
		}

		private static void EjectPlayers(Terminal terminal, TerminalNode node)
		{
			if (((NetworkBehaviour)terminal).IsServer && !StartOfRound.Instance.isChallengeFile && StartOfRound.Instance.inShipPhase && !StartOfRound.Instance.firingPlayersCutsceneRunning)
			{
				StartOfRound.Instance.ManuallyEjectPlayersServerRpc();
			}
		}
	}
	[HarmonyPatch]
	internal static class UnlockableRegistrationHandler
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static hook_Awake <0>__FixRegularUnlockables;

			public static hook_Awake <1>__RegisterDawnUnlockables;

			public static hook_TextPostProcess <2>__AddShipUpgradesToTerminal;
		}

		internal static void Init()
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Expected O, but got Unknown
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Expected O, but got Unknown
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Expected O, but got Unknown
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Expected O, but got Unknown
			DetourContext val = new DetourContext(-100);
			try
			{
				object obj = <>O.<0>__FixRegularUnlockables;
				if (obj == null)
				{
					hook_Awake val2 = FixRegularUnlockables;
					<>O.<0>__FixRegularUnlockables = val2;
					obj = (object)val2;
				}
				StartOfRound.Awake += (hook_Awake)obj;
				object obj2 = <>O.<1>__RegisterDawnUnlockables;
				if (obj2 == null)
				{
					hook_Awake val3 = RegisterDawnUnlockables;
					<>O.<1>__RegisterDawnUnlockables = val3;
					obj2 = (object)val3;
				}
				Terminal.Awake += (hook_Awake)obj2;
			}
			finally
			{
				((IDisposable)val)?.Dispose();
			}
			object obj3 = <>O.<2>__AddShipUpgradesToTerminal;
			if (obj3 == null)
			{
				hook_TextPostProcess val4 = AddShipUpgradesToTerminal;
				<>O.<2>__AddShipUpgradesToTerminal = val4;
				obj3 = (object)val4;
			}
			Terminal.TextPostProcess += (hook_TextPostProcess)obj3;
		}

		private static void FixRegularUnlockables(orig_Awake orig, StartOfRound self)
		{
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			orig.Invoke(self);
			int layer = LayerMask.NameToLayer("Room");
			((Component)StartOfRoundRefs.Instance.unlockablesList.unlockables[13].prefabObject.transform.Find("TableMesh")).gameObject.layer = layer;
			((Component)StartOfRoundRefs.Instance.unlockablesList.unlockables[14].prefabObject.transform.Find("RTableMesh")).gameObject.layer = layer;
			((Component)StartOfRoundRefs.Instance.unlockablesList.unlockables[17].prefabObject.transform.Find("Mesh")).gameObject.layer = layer;
			((Component)StartOfRoundRefs.Instance.unlockablesList.unlockables[17].prefabObject.transform.Find("Mesh")).gameObject.AddComponent<BoxCollider>().size = new Vector3(0.83f, 0.31f, 0.31f);
			((Component)StartOfRoundRefs.Instance.unlockablesList.unlockables[28].prefabObject.transform.Find("MicrowaveBody")).gameObject.layer = layer;
			((Component)StartOfRoundRefs.Instance.unlockablesList.unlockables[29].prefabObject.transform.Find("SofaChairMesh/Cube")).gameObject.layer = layer;
			((Component)StartOfRoundRefs.Instance.unlockablesList.unlockables[29].prefabObject.transform.Find("SofaChairMesh/Cube (1)")).gameObject.layer = layer;
			((Component)StartOfRoundRefs.Instance.unlockablesList.unlockables[29].prefabObject.transform.Find("SofaChairMesh/Cube (2)")).gameObject.layer = layer;
			((Component)StartOfRoundRefs.Instance.unlockablesList.unlockables[29].prefabObject.transform.Find("SofaChairMesh/Cube (3)")).gameObject.layer = layer;
			((Component)StartOfRoundRefs.Instance.unlockablesList.unlockables[30].prefabObject.transform.Find("FridgeBody")).gameObject.layer = layer;
			((Component)StartOfRoundRefs.Instance.unlockablesList.unlockables[32].prefabObject.transform.Find("ElectricChair")).gameObject.layer = layer;
			((Component)StartOfRoundRefs.Instance.unlockablesList.unlockables[33].prefabObject.transform.Find("DoghouseMesh")).gameObject.layer = layer;
		}

		private static void RegisterDawnUnlockables(orig_Awake orig, Terminal self)
		{
			//IL_0292: Unknown result type (might be due to invalid IL or missing references)
			//IL_029c: Expected O, but got Unknown
			//IL_0278: Unknown result type (might be due to invalid IL or missing references)
			//IL_0282: Expected O, but got Unknown
			if (LethalContent.Unlockables.IsFrozen)
			{
				orig.Invoke(self);
				return;
			}
			int num = StartOfRoundRefs.Instance.unlockablesList.unlockables.Count;
			Debuggers.Unlockables?.Log($"latestUnlockableID = {num}");
			Terminal instance = TerminalRefs.Instance;
			TerminalKeyword confirmPurchaseKeyword = TerminalRefs.ConfirmPurchaseKeyword;
			TerminalKeyword denyKeyword = TerminalRefs.DenyKeyword;
			TerminalNode cancelPurchaseNode = TerminalRefs.CancelPurchaseNode;
			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 (DawnUnlockableItemInfo value in LethalContent.Unlockables.Values)
			{
				if (value.ShouldSkipIgnoreOverride())
				{
					continue;
				}
				StartOfRoundRefs.Instance.unlockablesList.unlockables.Add(value.UnlockableItem);
				if (value.UnlockableItem.alreadyUnlocked || (Object)(object)value.RequestNode == (Object)null)
				{
					GameObject prefabObject = value.UnlockableItem.prefabObject;
					PlaceableShipObject val = ((prefabObject != null) ? prefabObject.GetComponentInChildren<PlaceableShipObject>() : null);
					if (!((Object)(object)val == (Object)null))
					{
						val.parentObject.unlockableID = StartOfRoundRefs.Instance.unlockablesList.unlockables.Count;
						val.unlockableID = StartOfRoundRefs.Instance.unlockablesList.unlockables.Count;
					}
					continue;
				}
				value.RequestNode.shipUnlockableID = num;
				num++;
				UpdateUnlockablePrices(value);
				value.RequestNode.terminalOptions[0].noun = confirmPurchaseKeyword;
				value.RequestNode.terminalOptions[0].result = CreateUnlockableConfirmNode(value.UnlockableItem, value.RequestNode.shipUnlockableID);
				value.ConfirmNode = value.RequestNode.terminalOptions[0].result;
				value.RequestNode.terminalOptions[1].noun = denyKeyword;
				value.RequestNode.terminalOptions[1].result = cancelPurchaseNode;
				value.BuyKeyword = new TerminalKeywordBuilder("Buy" + value.UnlockableItem.unlockableName, value.UnlockableItem.unlockableName.ToLowerInvariant() ?? "", (DawnKeywordType)5).SetDefaultVerb(buyKeyword).Build();
				list3.Add(value.BuyKeyword);
				if ((Object)(object)value.InfoNode != (Object)null)
				{
					list2.Add(new CompatibleNoun(value.BuyKeyword, value.InfoNode));
				}
				list.Add(new CompatibleNoun(value.BuyKeyword, value.RequestNode));
				GameObject prefabObject2 = value.UnlockableItem.prefabObject;
				PlaceableShipObject val2 = ((prefabObject2 != null) ? prefabObject2.GetComponentInChildren<PlaceableShipObject>() : null);
				if ((Object)(object)val2 != (Object)null)
				{
					val2.parentObject.unlockableID = value.RequestNode.shipUnlockableID;
					val2.unlockableID = value.RequestNode.shipUnlockableID;
				}
			}
			buyKeyword.compatibleNouns = list.ToArray();
			infoKeyword.compatibleNouns = list2.ToArray();
			instance.terminalNodes.allKeywords = list3.ToArray();
			orig.Invoke(self);
		}

		private static string AddShipUpgradesToTerminal(orig_TextPostProcess orig, Terminal self, string modifiedDisplayText, TerminalNode node)
		{
			string text = orig.Invoke(self, modifiedDisplayText, node);
			int num = text.IndexOf("SHIP UPGRADES:");
			if (num < 0)
			{
				return text;
			}
			if (num >= 0)
			{
				int num2 = text.IndexOf("The selection of ship decor rotates per-quota.", num);
				if (num2 >= 0)
				{
					text = text.Remove(num, num2 - num);
				}
			}
			List<string> list = new List<string>(1) { "SHIP UPGRADES:\n" };
			foreach (DawnUnlockableItemInfo item in from x in LethalContent.Unlockables.Values
				orderby x.UnlockableItem.unlockableName
				orderby x.Key.IsVanilla() descending
				select x)
			{
				UpdateUnlockablePrices(item);
				if (!item.UnlockableItem.alwaysInStock)
				{
					continue;
				}
				string text2 = item.UnlockableItem.unlockableName;
				if (string.IsNullOrWhiteSpace(text2))
				{
					string text3 = (((Object)(object)item.BuyKeyword != (Object)null) ? item.BuyKeyword.word : null);
					if (!string.IsNullOrWhiteSpace(text3))
					{
						DawnPlugin.Logger.LogWarning((object)("Unlockable '" + text3 + "' has no .unlockableName name."));
					}
					continue;
				}
				TerminalPurchaseResult terminalPurchaseResult = item.DawnPurchaseInfo.PurchasePredicate.CanPurchase();
				TerminalPurchaseResult.HiddenPurchaseResult hiddenPurchaseResult = terminalPurchaseResult as TerminalPurchaseResult.HiddenPurchaseResult;
				if (hiddenPurchaseResult == null)
				{
					if (terminalPurchaseResult is TerminalPurchaseResult.FailedPurchaseResult failedPurchaseResult && !string.IsNullOrWhiteSpace(failedPurchaseResult.OverrideName))
					{
						text2 = failedPurchaseResult.OverrideName;
					}
					int num3 = item.DawnPurchaseInfo.Cost.Provide();
					list.Add($"* {text2}    //    Price: ${num3}\n");
				}
			}
			return text.Insert(num, string.Join("", list));
		}

		internal static void UpdateAllUnlockablePrices()
		{
			foreach (DawnUnlockableItemInfo value in LethalContent.Unlockables.Values)
			{
				if (!value.ShouldSkipRespectOverride())
				{
					UpdateUnlockablePrices(value);
				}
			}
		}

		private static void UpdateUnlockablePrices(DawnUnlockableItemInfo info)
		{
			int itemCost = info.DawnPurchaseInfo.Cost.Provide();
			if ((Object)(object)info.RequestNode != (Object)null)
			{
				info.RequestNode.itemCost = itemCost;
			}
			if ((Object)(object)info.ConfirmNode != (Object)null)
			{
				info.ConfirmNode.itemCost = itemCost;
			}
		}

		[HarmonyPatch(typeof(StartOfRound), "Start")]
		[HarmonyPrefix]
		[HarmonyAfter(new string[] { "x753.More_Suits" })]
		private static void FreezeShipUnlockables()
		{
			if (LethalContent.Unlockables.IsFrozen)
			{
				return;
			}
			int i;
			for (i = 0; i < StartOfRoundRefs.Instance.unlockablesList.unlockables.Count; i++)
			{
				UnlockableItem val = StartOfRoundRefs.Instance.unlockablesList.unlockables[i];
				if (val.HasDawnInfo())
				{
					continue;
				}
				string name = NamespacedKey.NormalizeStringForNamespacedKey(val.unlockableName, CSharpName: true);
				NamespacedKey<DawnUnlockableItemInfo> namespacedKey = UnlockableItemKeys.GetByReflection(name);
				if (namespacedKey == null && LethalLibCompat.Enabled && LethalLibCompat.TryGetUnlockableItemFromLethalLib(val, out string modName))
				{
					namespacedKey = NamespacedKey<DawnUnlockableItemInfo>.From(modName, val.unlockableName);
				}
				else if (namespacedKey == null)
				{
					namespacedKey = NamespacedKey<DawnUnlockableItemInfo>.From("unknown_lib", val.unlockableName);
				}
				if (LethalContent.Unlockables.ContainsKey(namespacedKey))
				{
					DawnPlugin.Logger.LogWarning((object)("UnlockableItem " + val.unlockableName + " is already registered by the same creator to LethalContent. This is likely to cause issues."));
					val.SetDawnInfo(LethalContent.Unlockables[namespacedKey]);
					continue;
				}
				int value = 0;
				if ((Object)(object)val.shopSelectionNode == (Object)null && !val.alreadyUnlocked && !val.alwaysInStock)
				{
					DawnPlugin.Logger.LogWarning((object)("Unlockable " + val.unlockableName + " has no shop selection node and is not already unlocked. This is probably a problem."));
				}
				else if ((Object)(object)val.shopSelectionNode != (Object)null)
				{
					value = val.shopSelectionNode.itemCost;
				}
				DawnSuitInfo suitInfo = null;
				if ((Object)(object)val.suitMaterial != (Object)null)
				{
					suitInfo = new DawnSuitInfo(val.suitMaterial, val.jumpAudio);
				}
				DawnPlaceableObjectInfo placeableObjectInfo = null;
				if ((Object)(object)val.prefabObject != (Object)null)
				{
					placeableObjectInfo = new DawnPlaceableObjectInfo();
				}
				TerminalNode requestNode = val.shopSelectionNode;
				if ((Object)(object)requestNode == (Object)null)
				{
					requestNode = TerminalRefs.BuyKeyword.compatibleNouns.Where((CompatibleNoun x) => x.result.shipUnlockableID == i)?.Select((CompatibleNoun x) => x.result).FirstOrDefault();
				}
				TerminalNode confirmNode = null;
				TerminalKeyword unlockableBuyKeyword = null;
				if ((Object)(object)requestNode != (Object)null)
				{
					unlockableBuyKeyword = (from x in TerminalRefs.BuyKeyword.compatibleNouns
						where (Object)(object)x.result == (Object)(object)requestNode
						select x.noun).FirstOrDefault();
					confirmNode = requestNode.terminalOptions?.FirstOrDefault()?.result;
					value = requestNode.itemCost;
				}
				TerminalNode infoNode = null;
				if ((Object)(object)requestNode != (Object)null)
				{
					infoNode = TerminalRefs.InfoKeyword.compatibleNouns.Where((CompatibleNoun x) => (Object)(object)x.noun == (Object)(object)unlockableBuyKeyword)?.Select((CompatibleNoun x) => x.result).FirstOrDefault();
				}
				DawnUnlockableItemInfo dawnUnlockableItemInfo = new DawnUnlockableItemInfo(namespacedKey, new HashSet<NamespacedKey> { DawnLibTags.IsExternal }, val, new DawnPurchaseInfo(new SimpleProvider<int>(value), ITerminalPurchasePredicate.AlwaysSuccess()), suitInfo, placeableObjectInfo, requestNode, confirmNode, unlockableBuyKeyword, infoNode, null);
				val.SetDawnInfo(dawnUnlockableItemInfo);
				LethalContent.Unlockables.Register(dawnUnlockableItemInfo);
			}
			LethalContent.Unlockables.Freeze();
		}

		private static TerminalNode CreateUnlockableConfirmNode(UnlockableItem unlockableItem, int shipUnlockableID)
		{
			return new TerminalNodeBuilder(unlockableItem.unlockableName + "ConfirmNode").SetDisplayText("Ordered the " + unlockableItem.unlockableName + "! Your new balance is [playerCredits].\nPress [B] to rearrange objects in your ship and [V] to confirm.").SetClearPreviousText(clearPreviousText: true).SetMaxCharactersToType(35)
				.SetShipUnlockableIndex(shipUnlockableID)
				.SetBuyUnlockable(buyUnlockable: true)
				.SetPlaySyncedClip(0)
				.Build();
		}
	}
	public sealed class DawnPlaceableObjectInfo
	{
		public DawnUnlockableItemInfo ParentInfo { get; internal set; }

		internal DawnPlaceableObjectInfo()
		{
		}
	}
	public sealed class DawnSuitInfo
	{
		public DawnUnlockableItemInfo ParentInfo { get; internal set; }

		public Material SuitMaterial { get; private set; }

		public AudioClip? JumpAudioClip { get; private set; }

		internal DawnSuitInfo(Material suitMaterial, AudioClip? jumpAudioClip)
		{
			SuitMaterial = suitMaterial;
			JumpAudioClip = jumpAudioClip;
		}
	}
	public sealed class DawnUnlockableItemInfo : DawnBaseInfo<DawnUnlockableItemInfo>
	{
		public UnlockableItem UnlockableItem { get; }

		public DawnPurchaseInfo DawnPurchaseInfo { get; }

		public DawnSuitInfo? SuitInfo { get; }

		public DawnPlaceableObjectInfo? PlaceableObjectInfo { get; }

		public TerminalNode? RequestNode { get; internal set; }

		public TerminalNode? ConfirmNode { get; internal set; }

		public TerminalKeyword? BuyKeyword { get; internal set; }

		public TerminalNode? InfoNode { get; internal set; }

		internal DawnUnlockableItemInfo(NamespacedKey<DawnUnlockableItemInfo> key, HashSet<NamespacedKey> tags, UnlockableItem unlockableItem, DawnPurchaseInfo dawnPurchaseInfo, DawnSuitInfo? suitInfo, DawnPlaceableObjectInfo? placeableObjectInfo, TerminalNode? requestNode, TerminalNode? confirmNode, TerminalKeyword? buyKeyword, TerminalNode? infoNode, IDataContainer? customData)
			: base(key, tags, customData)
		{
			UnlockableItem = unlockableItem;
			SuitInfo = suitInfo;
			if (SuitInfo != null)
			{
				SuitInfo.ParentInfo = this;
			}
			PlaceableObjectInfo = placeableObjectInfo;
			if (PlaceableObjectInfo != null)
			{
				PlaceableObjectInfo.ParentInfo = this;
			}
			DawnPurchaseInfo = dawnPurchaseInfo;
			RequestNode = requestNode;
			ConfirmNode = confirmNode;
			BuyKeyword = buyKeyword;
			InfoNode = infoNode;
		}
	}
	public static class UnlockableItemExtensions
	{
		public static DawnUnlockableItemInfo GetDawnInfo(this UnlockableItem unlockableItem)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return (DawnUnlockableItemInfo)((IDawnObject)unlockableItem).DawnInfo;
		}

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

		internal static void SetDawnInfo(this UnlockableItem unlockableItem, DawnUnlockableItemInfo unlockableItemInfo)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			((IDawnObject)unlockableItem).DawnInfo = unlockableItemInfo;
		}
	}
	public class UnlockableInfoBuilder : BaseInfoBuilder<DawnUnlockableItemInfo, UnlockableItem, UnlockableInfoBuilder>
	{
		public class SuitBuilder
		{
			private UnlockableInfoBuilder _parentBuilder;

			private Material? _suitMaterial;

			private AudioClip? _jumpAudioClip;

			internal SuitBuilder(UnlockableInfoBuilder parent)
			{
				_parentBuilder = parent;
			}

			internal SuitBuilder OverrideSuitMaterial(Material suitMaterial)
			{
				_suitMaterial = suitMaterial;
				return this;
			}

			internal SuitBuilder OverrideJumpAudioClip(AudioClip jumpAudioClip)
			{
				_jumpAudioClip = jumpAudioClip;
				return this;
			}

			internal DawnSuitInfo Build()
			{
				if ((Object)(object)_suitMaterial == (Object)null)
				{
					DawnPlugin.Logger.LogWarning((object)$"Suit: '{_parentBuilder.key}' didn't set suit material.");
					throw new ArgumentNullException(_parentBuilder.key.ToString());
				}
				return new DawnSuitInfo(_suitMaterial, _jumpAudioClip);
			}
		}

		public class PlaceableObjectBuilder
		{
			private UnlockableInfoBuilder _parentBuilder;

			internal PlaceableObjectBuilder(UnlockableInfoBuilder parent)
			{
				_parentBuilder = parent;
			}

			internal PlaceableObjectBuilder SetDecor()
			{
				_parentBuilder.value.alwaysInStock = false;
				_parentBuilder.value.unlockableType = 1;
				return this;
			}

			internal PlaceableObjectBuilder SetShipUpgrade()
			{
				_parentBuilder.value.alwaysInStock = true;
				_parentBuilder.value.unlockableType = 1;
				return this;
			}

			internal DawnPlaceableObjectInfo Build()
			{
				return new DawnPlaceableObjectInfo();
			}
		}

		private IProvider<int>? _cost;

		private DawnSuitInfo? _suitInfo;

		private DawnPlaceableObjectInfo? _placeableObjectInfo;

		private ITerminalPurchasePredicate? _purchasePredicate;

		private string _infoNodeText = string.Empty;

		internal UnlockableInfoBuilder(NamespacedKey<DawnUnlockableItemInfo> key, UnlockableItem unlockableItem)
			: base(key, unlockableItem)
		{
		}

		public UnlockableInfoBuilder SetInfoText(string infoText)
		{
			_infoNodeText = infoText;
			return this;
		}

		public UnlockableInfoBuilder SetCost(int cost)
		{
			return SetCost(new SimpleProvider<int>(cost));
		}

		public UnlockableInfoBuilder SetCost(IProvider<int> cost)
		{
			_cost = cost;
			return this;
		}

		public UnlockableInfoBuilder DefinePlaceableObject(Action<PlaceableObjectBuilder> callback)
		{
			PlaceableObjectBuilder placeableObjectBuilder = new PlaceableObjectBuilder(this);
			callback(placeableObjectBuilder);
			_placeableObjectInfo = placeableObjectBuilder.Build();
			return this;
		}

		public UnlockableInfoBuilder DefineSuit(Action<SuitBuilder> callback)
		{
			base.value.unlockableType = 0;
			SuitBuilder suitBuilder = new SuitBuilder(this);
			callback(suitBuilder);
			_suitInfo = suitBuilder.Build();
			return this;
		}

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

		internal override DawnUnlockableItemInfo Build()
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Expected O, but got Unknown
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Expected O, but got Unknown
			if (!base.value.alreadyUnlocked && !Object.op_Implicit((Object)(object)base.value.shopSelectionNode))
			{
				CompatibleNoun val = new CompatibleNoun((TerminalKeyword)null, (TerminalNode)null);
				CompatibleNoun val2 = new CompatibleNoun((TerminalKeyword)null, (TerminalNode)null);
				base.value.shopSelectionNode = new TerminalNodeBuilder(base.value.unlockableName + "ShopSelectionNode").SetDisplayText("You have requested to order " + base.value.unlockableName + ".\nTotal cost of item: [totalCost].\n\nPlease CONFIRM or DENY.\n").SetMaxCharactersToType(15).SetShipUnlockableIndex(-1)
					.SetClearPreviousText(clearPreviousText: true)
					.SetCreatureName(base.value.unlockableName)
					.SetOverrideOptions(overrideOptions: true)
					.SetTerminalOptions((CompatibleNoun[])(object)new CompatibleNoun[2] { val, val2 })
					.Build();
			}
			TerminalNode infoNode = null;
			if (!string.IsNullOrWhiteSpace(_infoNodeText))
			{
				infoNode = new TerminalNodeBuilder(base.value.unlockableName + "Info").SetDisplayText(_infoNodeText).SetClearPreviousText(clearPreviousText: true).SetMaxCharactersToType(35)
					.Build();
			}
			IProvider<int> provider = _cost;
			if (provider == null && (Object)(object)base.value.shopSelectionNode == (Object)null)
			{
				provider = new SimpleProvider<int>(-999);
				DawnPlugin.Logger.LogWarning((object)$"Unlockable: '{base.key}' didn't set cost. If you intend to have no cost, call .SetCost(0) or provide a ShopSelectionNode with a cost inside to use.");
			}
			else if (provider == null)
			{
				provider = new SimpleProvider<int>(base.value.shopSelectionNode.itemCost);
			}
			if (_purchasePredicate == null)
			{
				_purchasePredicate = ITerminalPurchasePredicate.AlwaysSuccess();
			}
			return new DawnUnlockableItemInfo(base.key, tags, base.value, new DawnPurchaseInfo(provider, _purchasePredicate), _suitInfo, _placeableObjectInfo, base.value.shopSelectionNode, base.value.shopSelectionNode?.terminalOptions?.FirstOrDefault()?.result, null, infoNode, customData);
		}
	}
	public sealed class DawnVehicleInfo : DawnBaseInfo<DawnVehicleInfo>
	{
		public DawnPurchaseInfo DawnPurchaseInfo { get; }

		public GameObject VehiclePrefab { get; }

		public GameObject? SecondaryPrefab { get; }

		public GameObject? StationPrefab { get; }

		public TerminalNode BuyNode { get; internal set; }

		public TerminalKeyword BuyKeyword { get; internal set; }

		public TerminalNode ConfirmPurchaseNode { get; internal set; }

		public TerminalNode? InfoNode { get; internal set; }

		internal DawnVehicleInfo(NamespacedKey<DawnVehicleInfo> key, HashSet<NamespacedKey> tags, GameObject vehiclePrefab, GameObject? secondaryPrefab, GameObject? stationPrefab, DawnPurchaseInfo dawnPurchaseInfo, IDataContainer? customData)
			: base(key, tags, customData)
		{
			VehiclePrefab = vehiclePrefab;
			SecondaryPrefab = secondaryPrefab;
			StationPrefab = stationPrefab;
			DawnPurchaseInfo = dawnPurchaseInfo;
		}
	}
	internal static class WeatherRegistrationHandler
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static hook_Awake <0>__RegisterVanillaWeathers;

			public static hook_Start <1>__RegisterModdedWeathers;

			public static hook_ConnectClientToPlayerObject <2>__SyncWeathers;
		}

		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
			object obj = <>O.<0>__RegisterVanillaWeathers;
			if (obj == null)
			{
				hook_Awake val = RegisterVanillaWeathers;
				<>O.<0>__RegisterVanillaWeathers = val;
				obj = (object)val;
			}
			Terminal.Awake += (hook_Awake)obj;
			object obj2 = <>O.<1>__RegisterModdedWeathers;
			if (obj2 == null)
			{
				hook_Start val2 = RegisterModdedWeathers;
				<>O.<1>__RegisterModdedWeathers = val2;
				obj2 = (object)val2;
			}
			Terminal.Start += (hook_Start)obj2;
			object obj3 = <>O.<2>__SyncWeathers;
			if (obj3 == null)
			{
				hook_ConnectClientToPlayerObject val3 = SyncWeathers;
				<>O.<2>__SyncWeathers = val3;
				obj3 = (object)val3;
			}
			PlayerControllerB.ConnectClientToPlayerObject += (hook_ConnectClientToPlayerObject)obj3;
		}

		private static void SyncWeathers(orig_ConnectClientToPlayerObject orig, PlayerControllerB self)
		{
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Expected I4, but got Unknown
			orig.Invoke(self);
			if (NetworkManager.Singleton.IsServer || !self.IsLocalPlayer())
			{
				return;
			}
			self.playersManager.SetMapScreenInfoToCurrentLevel();
			LevelWeatherType[] array = (LevelWeatherType[])(object)new LevelWeatherType[LethalContent.Moons.Count];
			foreach (var (num, dawnMoonInfo) in LethalContent.Moons.Values.WithIndex())
			{
				array[num] = (LevelWeatherType)(int)dawnMoonInfo.Level.currentWeather;
			}
			NetworkSingleton<DawnNetworker>.Instance?.RequestWeatherSyncRpc(array, self.actualClientId);
		}

		private static void RegisterVanillaWeathers(orig_Awake orig, Terminal self)
		{
			AddWeathersToRegistry();
			orig.Invoke(self);
		}

		private static void RegisterModdedWeathers(orig_Start orig, Terminal self)
		{
			orig.Invoke(self);
			AddWeathersToRegistry();
			if (!LethalContent.Weathers.IsFrozen)
			{
				LethalContent.Weathers.Freeze();
			}
		}

		private static void AddWeathersToRegistry()
		{
			WeatherEffect[] effects = TimeOfDayRefs.Instance.effects;
			foreach (WeatherEffect val in effects)
			{
				if (val.HasDawnInfo())
				{
					continue;
				}
				string name = NamespacedKey.NormalizeStringForNamespacedKey(val.name, CSharpName: true);
				NamespacedKey<DawnWeatherEffectInfo> namespacedKey = WeatherKeys.GetByReflection(name);
				string modName2;
				if (namespacedKey == null && LethalLibCompat.Enabled && LethalLibCompat.TryGetWeatherEffectFromLethalLib(val.name, out string modName))
				{
					namespacedKey = NamespacedKey<DawnWeatherEffectInfo>.From(modName, val.name);
				}
				else if (namespacedKey == null && WeatherRegistryCompat.Enabled && WeatherRegistryCompat.TryGetWeatherFromWeatherRegistry(val.name, out modName2))
				{
					namespacedKey = NamespacedKey<DawnWeatherEffectInfo>.From(modName2, val.name);
				}
				else if (namespacedKey == null)
				{
					namespacedKey = NamespacedKey<DawnWeatherEffectInfo>.From("unknown_lib", val.name);
				}
				if (LethalContent.Weathers.ContainsKey(namespacedKey))
				{
					if (!LethalContent.Weathers.IsFrozen)
					{
						DawnPlugin.Logger.LogWarning((object)("Weather " + val.name + " is already registered by the same creator to LethalContent. This is likely to cause issues."));
					}
					LethalContent.Weathers[namespacedKey].WeatherEffect = val;
					val.SetDawnInfo(LethalContent.Weathers[namespacedKey]);
				}
				else
				{
					DawnWeatherEffectInfo dawnWeatherEffectInfo = new DawnWeatherEffectInfo(namespacedKey, new HashSet<NamespacedKey> { DawnLibTags.IsExternal }, val, null);
					LethalContent.Weathers.Register(dawnWeatherEffectInfo);
					val.SetDawnInfo(dawnWeatherEffectInfo);
				}
			}
		}
	}
	public class DawnWeatherEffectInfo : DawnBaseInfo<DawnWeatherEffectInfo>
	{
		public WeatherEffect WeatherEffect { get; internal set; }

		internal DawnWeatherEffectInfo(NamespacedKey<DawnWeatherEffectInfo> key, HashSet<NamespacedKey> tags, WeatherEffect weatherEffect, IDataContainer? customData)
			: base(key, tags, customData)
		{
			WeatherEffect = weatherEffect;
		}
	}
	public static class WeatherEffectExtensions
	{
		internal static DawnWeatherEffectInfo GetDawnInfo(this WeatherEffect weatherEffect)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return (DawnWeatherEffectInfo)((IDawnObject)weatherEffect).DawnInfo;
		}

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

		internal static void SetDawnInfo(this WeatherEffect weatherEffect, DawnWeatherEffectInfo weatherEffectInfo)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			((IDawnObject)weatherEffect).DawnInfo = weatherEffectInfo;
		}
	}
	public class CurveTableBuilder<TBase, TContext> where TBase : INamespaced<TBase>, ITaggable
	{
		private List<IContextualProvider<AnimationCurve?, TBase, TContext>> _baseProviders = new List<IContextualProvider<AnimationCurve, TBase, TContext>>();

		private List<IContextualProvider<AnimationCurve?, TBase, TContext>> _tagProviders = new List<IContextualProvider<AnimationCurve, TBase, TContext>>();

		private IContextualProvider<AnimationCurve?, TBase, TContext>? _global;

		public CurveTableBuilder<TBase, TContext> AddCurve(NamespacedKey<TBase> key, AnimationCurve curve)
		{
			_baseProviders.Add(new MatchingKeyContextualProvider<AnimationCurve, TBase, TContext>(key, curve));
			return this;
		}

		public CurveTableBuilder<TBase, TContext> AddTagCurve(NamespacedKey tag, AnimationCurve curve)
		{
			_tagProviders.Add(new HasTagContextualProvider<AnimationCurve, TBase, TContext>(tag, curve));
			return this;
		}

		public CurveTableBuilder<TBase, TContext> SetGlobalCurve(AnimationCurve curve)
		{
			return SetGlobalCurve((IContextualProvider<AnimationCurve?, TBase, TContext>)new SimpleContextualProvider<AnimationCurve, TBase, TContext>(curve));
		}

		public CurveTableBuilder<TBase, TContext> SetGlobalCurve(IContextualProvider<AnimationCurve?, TBase, TContext> provider)
		{
			_global = provider;
			return this;
		}

		public ProviderTable<AnimationCurve?, TBase, TContext> Build()
		{
			List<IContextualProvider<AnimationCurve, TBase, TContext>> baseProviders = _baseProviders;
			List<IContextualProvider<AnimationCurve, TBase, TContext>> tagProviders = _tagProviders;
			List<IContextualProvider<AnimationCurve, TBase, TContext>> list = new List<IContextualProvider<AnimationCurve, TBase, TContext>>(baseProviders.Count + tagProviders.Count);
			list.AddRange(baseProviders);
			list.AddRange(tagProviders);
			List<IContextualProvider<AnimationCurve, TBase, TContext>> list2 = list;
			if (_global != null)
			{
				list2.Add(_global);
			}
			return new ProviderTable<AnimationCurve, TBase, TContext>(list2);
		}
	}
	public interface IContextualProvider<out T, in TBase> where TBase : INamespaced<TBase>
	{
		T Provide(TBase info);
	}
	public interface IContextualProvider<out T, in TBase, in TContext> where TBase : INamespaced<TBase>
	{
		T Provide(TBase info, TContext ctx);
	}
	public interface IWeighted
	{
		int GetWeight();
	}
	public class ProviderTable<T, TBase> where TBase : INamespaced<TBase>
	{
		private List<IContextualProvider<T, TBase>> _providers;

		internal ProviderTable(List<IContextualProvider<T, TBase>> providers)
		{
			_providers = providers;
		}

		public T? GetFor(TBase info)
		{
			foreach (IContextualProvider<T, TBase> provider in _providers)
			{
				T val = provider.Provide(info);
				if (val != null)
				{
					return val;
				}
			}
			return default(T);
		}

		public static ProviderTable<T, TBase> Empty()
		{
			return new ProviderTable<T, TBase>(new List<IContextualProvider<T, TBase>>());
		}
	}
	public sealed class ProviderTable<T, TBase, TContext> where TBase : INamespaced<TBase>
	{
		private readonly List<IContextualProvider<T, TBase, TContext>> _providers;

		internal ProviderTable(List<IContextualProvider<T, TBase, TContext>> providers)
		{
			_providers = providers;
		}

		public T? GetFor(TBase info, in TContext ctx)
		{
			foreach (IContextualProvider<T, TBase, TContext> provider in _providers)
			{
				T val = provider.Provide(info, ctx);
				if (val != null)
				{
					return val;
				}
			}
			return default(T);
		}

		public static ProviderTable<T, TBase, TContext> Empty()
		{
			return new ProviderTable<T, TBase, TContext>(new List<IContextualProvider<T, TBase, TContext>>());
		}
	}
	public static class ProviderTableSpawnWeightExtensions
	{
		public static T? GetFor<T>(this ProviderTable<T, DawnMoonInfo, SpawnWeightContext> table, in SpawnWeightContext ctx)
		{
			if (ctx.Moon == null)
			{
				return default(T);
			}
			return table.GetFor(ctx.Moon, in ctx);
		}
	}
	public class SimpleWeighted : IWeighted
	{
		[CompilerGenerated]
		private int <weight>P;

		public SimpleWeighted(int weight)
		{
			<weight>P = weight;
			base..ctor();
		}

		public int GetWeight()
		{
			return <weight>P;
		}
	}
	public interface IContextualWeighted<in TContext>
	{
		int GetWeight(TContext ctx);
	}
	public static class WeightedExtensions
	{
		public static int GetWeight<TContext>(this IWeighted weighted, in TContext ctx)
		{
			if (weighted is IContextualWeighted<TContext> contextualWeighted)
			{
				return contextualWeighted.GetWeight(ctx);
			}
			return weighted.GetWeight();
		}
	}
	public class SimpleContextualProvider<T, TBase, TContext> : IContextualProvider<T, TBase, TContext> where TBase : INamespaced<TBase>
	{
		[CompilerGenerated]
		private T <value>P;

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

		public T Provide(TBase info, TContext ctx)
		{
			return <value>P;
		}
	}
	public class MatchingKeyContextualProvider<T, TBase, TContext> : IContextualProvider<T?, TBase, TContext> where TBase : INamespaced<TBase>
	{
		[CompilerGenerated]
		private NamespacedKey<TBase> <targetKey>P;

		[CompilerGenerated]
		private T <value>P;

		public MatchingKeyContextualProvider(NamespacedKey<TBase> targetKey, T value)
		{
			<targetKey>P = targetKey;
			<value>P = value;
			base..ctor();
		}

		public T? Provide(TBase info, TContext ctx)
		{
			if (!object.Equals(info.Key, <targetKey>P))
			{
				return default(T);
			}
			return <value>P;
		}
	}
	public class HasTagContextualProvider<T, TBase, TContext> : IContextualProvider<T?, TBase, TContext> where TBase : INamespaced<TBase>
	{
		[CompilerGenerated]
		private NamespacedKey <tag>P;

		[CompilerGenerated]
		private T <value>P;

		public HasTagContextualProvider(NamespacedKey tag, T value)
		{
			<tag>P = tag;
			<value>P = value;
			base..ctor();
		}

		public T? Provide(TBase info, TContext ctx)
		{
			if (!((object)info is ITaggable taggable))
			{
				return default(T);
			}
			if (!taggable.HasTag(<tag>P))
			{
				return default(T);
			}
			return <value>P;
		}
	}
	public sealed class MatchingKeyWeightContextualProvider<TBase, TContext> : IContextualProvider<int?, TBase, TContext> where TBase : INamespaced<TBase>
	{
		[CompilerGenerated]
		private NamespacedKey<TBase> <targetKey>P;

		[CompilerGenerated]
		private IWeighted <weight>P;

		public MatchingKeyWeightContextualProvider(NamespacedKey<TBase> targetKey, IWeighted weight)
		{
			<targetKey>P = targetKey;
			<weight>P = weight;
			base..ctor();
		}

		public int? Provide(TBase info, TContext ctx)
		{
			if (!object.Equals(info.Key, <targetKey>P))
			{
				return null;
			}
			return <weight>P.GetWeight(in ctx);
		}
	}
	public sealed class HasTagWeightContextualProvider<TBase, TContext> : IContextualProvider<int?, TBase, TContext> where TBase : INamespaced<TBase>, ITaggable
	{
		[CompilerGenerated]
		private NamespacedKey <tag>P;

		[CompilerGenerated]
		private IWeighted <weight>P;

		public HasTagWeightContextualProvider(NamespacedKey tag, IWeighted weight)
		{
			<tag>P = tag;
			<weight>P = weight;
			base..ctor();
		}

		public int? Provide(TBase info, TContext ctx)
		{
			if (!info.HasTag(<tag>P))
			{
				return null;
			}
			return <weight>P.GetWeight(in ctx);
		}
	}
	public sealed class SimpleWeightContextualProvider<TBase, TContext> : IContextualProvider<int?, TBase, TContext> where TBase : INamespaced<TBase>
	{
		[CompilerGenerated]
		private IWeighted <weight>P;

		public SimpleWeightContextualProvider(IWeighted weight)
		{
			<weight>P = weight;
			base..ctor();
		}

		public int? Provide(TBase info, TContext ctx)
		{
			return <weight>P.GetWeight(in ctx);
		}
	}
	public readonly struct SpawnWeightExtras
	{
		private readonly Dictionary<string, object?>? _data;

		public static SpawnWeightExtras Empty => default(SpawnWeightExtras);

		private SpawnWeightExtras(Dictionary<string, object?> data)
		{
			_data = data;
		}

		private static string Canonical(NamespacedKey key)
		{
			return key.ToString();
		}

		public SpawnWeightExtras With<T>(NamespacedKey key, T value)
		{
			Dictionary<string, object> dictionary = ((_data != null) ? new Dictionary<string, object>(_data) : new Dictionary<string, object>());
			dictionary[Canonical(key)] = value;
			return new SpawnWeightExtras(dictionary);
		}

		public bool TryGet<T>(NamespacedKey key, [NotNullWhen(true)] out T? value)
		{
			value = default(T);
			if (_data == null)
			{
				return false;
			}
			if (_data.TryGetValue(Canonical(key), out object value2) && value2 is T val)
			{
				value = val;
				return true;
			}
			return false;
		}

		public T GetOrDefault<T>(NamespacedKey key, T fallback = default(T))
		{
			if (!TryGet<T>(key, out T value))
			{
				return fallback;
			}
			return value;
		}
	}
	public static class SpawnWeightExtraKeys
	{
		public static readonly NamespacedKey RoutingPriceKey = NamespacedKey.From("dawn_lib", "spawn_weight_routing_price");
	}
	public readonly struct SpawnWeightContext
	{
		public DawnMoonInfo? Moon { get; }

		public DawnDungeonInfo? Dungeon { get; }

		public DawnWeatherEffectInfo? Weather { get; }

		public SpawnWeightExtras Extras { get; }

		public SpawnWeightContext(DawnMoonInfo? moon, DawnDungeonInfo? dungeon, DawnWeatherEffectInfo? weather, SpawnWeightExtras extras)
		{
			Moon = moon;
			Dungeon = dungeon;
			Weather = weather;
			Extras = extras;
		}

		public SpawnWeightContext(DawnMoonInfo? moon, DawnDungeonInfo? dungeon, DawnWeatherEffectInfo? weather)
			: this(moon, dungeon, weather, SpawnWeightExtras.Empty)
		{
		}

		public SpawnWeightContext WithExtra<T>(NamespacedKey key, T value)
		{
			return new SpawnWeightContext(Moon, Dungeon, Weather, Extras.With(key, value));
		}
	}
	public class WeightTableBuilder<TBase, TContext> where TBase : INamespaced<TBase>, ITaggable
	{
		private List<IContextualProvider<int?, TBase, TContext>> _baseProviders = new List<IContextualProvider<int?, TBase, TContext>>();

		private List<IContextualProvider<int?, TBase, TContext>> _tagProviders = new List<IContextualProvider<int?, TBase, TContext>>();

		private IContextualProvider<int?, TBase, TContext>? _global;

		public WeightTableBuilder<TBase, TContext> AddWeight(NamespacedKey<TBase> key, int weight)
		{
			return AddWeight(key, new SimpleWeighted(weight));
		}

		public WeightTableBuilder<TBase, TContext> AddWeight(NamespacedKey<TBase> key, IWeighted weight)
		{
			_baseProviders.Add(new MatchingKeyWeightContextualProvider<TBase, TContext>(key, weight));
			return this;
		}

		public WeightTableBuilder<TBase, TContext> AddTagWeight(NamespacedKey tag, int weight)
		{
			return AddTagWeight(tag, new SimpleWeighted(weight));
		}

		public WeightTableBuilder<TBase, TContext> AddTagWeight(NamespacedKey tag, IWeighted weight)
		{
			_tagProviders.Add(new HasTagWeightContextualProvider<TBase, TContext>(tag, weight));
			return this;
		}

		public WeightTableBuilder<TBase, TContext> SetGlobalWeight(int weight)
		{
			return SetGlobalWeight(new SimpleWeighted(weight));
		}

		public WeightTableBuilder<TBase, TContext> SetGlobalWeight(IWeighted weight)
		{
			return SetGlobalWeight(new SimpleWeightContextualProvider<TBase, TContext>(weight));
		}

		public WeightTableBuilder<TBase, TContext> SetGlobalWeight(IContextualProvider<int?, TBase, TContext> provider)
		{
			_global = provider;
			return this;
		}

		public ProviderTable<int?, TBase, TContext> Build()
		{
			List<IContextualProvider<int?, TBase, TContext>> baseProviders = _baseProviders;
			List<IContextualProvider<int?, TBase, TContext>> tagProviders = _tagProviders;
			List<IContextualProvider<int?, TBase, TContext>> list = new List<IContextualProvider<int?, TBase, TContext>>(baseProviders.Count + tagProviders.Count);
			list.AddRange(baseProviders);
			list.AddRange(tagProviders);
			List<IContextualProvider<int?, TBase, TContext>> list2 = list;
			if (_global != null)
			{
				list2.Add(_global);
			}
			return new ProviderTable<int?, TBase, TContext>(list2);
		}
	}
	internal static class DawnConstants
	{
		internal const string MenuName = "DawnLib";

		internal const string ExtraEvents = "DawnLib/Extra Events";

		internal const string AudioComponents = "DawnLib/Audio";

		internal const string Networking = "DawnLib/Networking";

		internal const string MiscUtils = "DawnLib/Misc Utilities";

		internal const string Triggers = "DawnLib/Triggers";

		internal const string MoonUtils = "DawnLib/Moon Utils";

		internal const string UI = "DawnLib/UI";
	}
	public static class DawnKeys
	{
		public const string Namespace = "dawn_lib";

		public static readonly NamespacedKey LastVersion = NamespacedKey.From("dawn_lib", "last_version");

		public static readonly NamespacedKey DawnSave = NamespacedKey.From("dawn_lib", "dawn_save");

		public static readonly NamespacedKey StingerPlayed = NamespacedKey.From("dawn_lib", "played_stinger_once_before");

		public static readonly NamespacedKey ShipItemsSaveData = NamespacedKey.From("dawn_lib", "ship_items_save_data");

		public static readonly NamespacedKey ShipUnlockablesSaveData = NamespacedKey.From("dawn_lib", "ship_unlockables_save_data");
	}
	[BepInPlugin("com.github.teamxiaolan.dawnlib", "DawnLib", "0.9.21")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class DawnPlugin : BaseUnityPlugin
	{
		internal static readonly List<Hook> Hooks = new List<Hook>();

		internal static readonly Harmony _harmony = new Harmony("com.github.teamxiaolan.dawnlib");

		internal static ManualLogSource Logger { get; private set; } = null;


		internal static PersistentDataContainer PersistentData { get; private set; } = null;


		private void Awake()
		{
			Logger = ((BaseUnityPlugin)this).Logger;
			Debuggers.Bind(((BaseUnityPlugin)this).Config);
			DawnConfig.Bind(((BaseUnityPlugin)this).Config);
			if (DawnConfig.CreateTagExport.Value)
			{
				TagExporter.Init();
			}
			if (LethalConfigCompat.Enabled)
			{
				LethalConfigCompat.Init();
			}
			if (WeatherRegistryCompat.Enabled)
			{
				WeatherRegistryCompat.Init();
			}
			if (LethalQuantitiesCompat.Enabled)
			{
				LethalQuantitiesCompat.Init();
			}
			if (TerminalFormatterCompat.Enabled)
			{
				TerminalFormatterCompat.Init();
			}
			ExtendedTOML.Init();
			PersistentDataHandler.Init();
			if (!DawnConfig.VanillaCompatibility.Value)
			{
				NetworkVariableInitalizer.Init();
			}
			SurfaceRegistrationHandler.Init();
			StoryLogRegistrationHandler.Init();
			MoonRegistrationHandler.Init();
			DungeonRegistrationHandler.Init();
			ItemRegistrationHandler.Init();
			EnemyRegistrationHandler.Init();
			UnlockableRegistrationHandler.Init();
			MapObjectRegistrationHandler.Init();
			WeatherRegistrationHandler.Init();
			HandleCorruptedDataPatch.Init();
			TerminalCommandRegistration.Init();
			MoreLayerMasks.Init();
			EnemyDataPatch.Init();
			ExtraItemEventsPatch.Init();
			MiscFixesPatch.Init();
			SaveDataPatch.Init();
			TerminalPatches.Init();
			DebugPatches.Init();
			ExtraScanEventsPatch.Init();
			DawnCommands.Init();
			_harmony.PatchAll(Assembly.GetExecutingAssembly());
			DawnNetworkSceneManager.Init();
			DebugPrintRegistryResult("Enemies", LethalContent.Enemies, (DawnEnemyInfo enemyInfo) => enemyInfo.EnemyType.enemyName);
			DebugPrintRegistryResult("Moons", LethalContent.Moons, (DawnMoonInfo moonInfo) => moonInfo.Level.PlanetName);
			DebugPrintRegistryResult("Items", LethalContent.Items, (DawnItemInfo itemInfo) => itemInfo.Item.itemName);
			DebugPrintRegistryResult("Unlockables", LethalContent.Unlockables, (DawnUnlockableItemInfo unlockableInfo) => unlockableInfo.UnlockableItem.unlockableName);
			DebugPrintRegistryResult("Map Objects", LethalContent.MapObjects, (DawnMapObjectInfo mapObjectInfo) => ((Object)mapObjectInfo.GetMapObjectPrefab()).name);
			DebugPrintRegistryResult("Weathers", LethalContent.Weathers, (DawnWeatherEffectInfo weatherInfo) => weatherInfo.WeatherEffect.name);
			DebugPrintRegistryResult("Tile Sets", LethalContent.TileSets, (DawnTileSetInfo tileInfo) => ((Object)tileInfo.TileSet).name);
			DebugPrintRegistryResult("Dungeons", LethalContent.Dungeons, (DawnDungeonInfo dungeonInfo) => ((Object)dungeonInfo.DungeonFlow).name);
			DebugPrintRegistryResult("Archetypes", LethalContent.Archetypes, (DawnArchetypeInfo archetypeInfo) => ((Object)archetypeInfo.DungeonArchetype).name);
			DebugPrintRegistryResult("Story Logs", LethalContent.StoryLogs, (DawnStoryLogInfo storyLogInfo) => storyLogInfo.StoryLogTerminalNode.creatureName);
			DebugPrintRegistryResult("Surfaces", LethalContent.Surfaces, (DawnSurfaceInfo surfaceInfo) => surfaceInfo.Surface.surfaceTag);
			DebugPrintRegistryResult("Terminal Commands", LethalContent.TerminalCommands, (DawnTerminalCommandInfo commandInfo) => commandInfo.CommandBasicInformation.CommandName);
			PersistentData = ((BaseUnityPlugin)(object)this).GetPersistentDataContainer();
			DawnLib.ApplyAllTagsInFolder(RelativePath("data", "tags"));
		}

		internal static string RelativePath(params string[] folders)
		{
			return Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), Path.Combine(folders));
		}

		private static void DebugPrintRegistryResult<T>(string name, Registry<T> registry, Func<T, string> nameGetter) where T : INamespaced<T>
		{
			string name2 = name;
			Registry<T> registry2 = registry;
			Func<T, string> nameGetter2 = nameGetter;
			registry2.OnFreeze += delegate
			{
				Logger.LogDebug((object)$"Registry '{name2}' ({typeof(T).Name}) contains '{registry2.Count}' entries.");
				foreach (var (arg, arg2) in registry2)
				{
					Logger.LogDebug((object)$"{arg} -> {nameGetter2(arg2)}");
				}
			};
		}
	}
	internal class DawnTesting
	{
		private static string AdjectivesExample()
		{
			List<string> list = new List<string>(3) { "VERY ", "MANY ", "INCREDIBLY " };
			Random random = new Random();
			return list[random.Next(0, list.Count)];
		}

		internal static void TestCommands()
		{
			TerminalTextModifier terminalTextModifier = new TerminalTextModifier("planet", new SimpleProvider<string>("<mark=#ffff001A>moon</mark>"));
			TerminalTextModifier terminalTextModifier2 = new TerminalTextModifier("commands", new SimpleProvider<string>("\"")).SetInsertStyle(MatchInsert.Before | MatchInsert.After);
			TerminalTextModifier terminalTextModifier3 = new TerminalTextModifier("useful", new FuncProvider<string>(AdjectivesExample)).SetInsertStyle(MatchInsert.Before);
			TerminalTextModifier terminalTextModifier4 = new TerminalTextModifier("the list", new SimpleProvider<string>("<i>ing</i>")).SetInsertStyle(MatchInsert.After);
			TerminalTextModifier terminalTextModifier5 = new TerminalTextModifier("\n\n\n", new SimpleProvider<string>("<align=\"center\">---</align>\n")).SetInsertStyle(MatchInsert.After).SetIndexStyle(MatchIndex.First);
			TerminalTextModifier terminalTextModifier6 = new TerminalTextModifier("\n", new SimpleProvider<string>("\n<align=\"center\">----</align>\n\n")).SetIndexStyle(MatchIndex.Last);
			TerminalTextModifier terminalTextModifier7 = new TerminalTextModifier("record.*\\S", new SimpleProvider<string>("$&\n\n>VERSION\nDisplay Dawnlib's current version")).UseRegexPattern(value: true).SetNodeFromKeyword("help");
			TerminalCommandBasicInformation commandBasicInformation = new TerminalCommandBasicInformation("DawnLibVersionCommand", "Test", "Prints the version of DawnLib!", ClearText.Result | ClearText.Query);
			DawnLib.DefineTerminalCommand(NamespacedKey<DawnTerminalCommandInfo>.From("dawn_lib", "version_command"), commandBasicInformation, delegate(TerminalCommandInfoBuilder builder)
			{
				builder.SetKeywords(new List<string>(1) { "version" });
				builder.DefineSimpleCommand(delegate(TerminalCommandInfoBuilder.SimpleCommandBuilder simpleBuilder)
				{
					simpleBuilder.SetResultDisplayText(() => "DawnLib version 0.9.21");
				});
			});
			TerminalCommandBasicInformation commandBasicInformation2 = new TerminalCommandBasicInformation("DawnLibLightsCommand", "Test", "Toggles the lights in the ship.", ClearText.Result | ClearText.Query);
			DawnLib.DefineTerminalCommand(NamespacedKey<DawnTerminalCommandInfo>.From("dawn_lib", "lights_command"), commandBasicInformation2, delegate(TerminalCommandInfoBuilder builder)
			{
				builder.SetKeywords(new List<string>(4) { "lights", "dark", "vow", "help" });
				builder.DefineSimpleCommand(delegate(TerminalCommandInfoBuilder.SimpleCommandBuilder simpleBuilder)
				{
					simpleBuilder.SetResultDisplayText(BasicLightsCommand);
				});
			});
			TerminalCommandBasicInformation commandBasicInformation3 = new TerminalCommandBasicInformation("DawnLibComplexCommand", "Test", "Test complex command", ClearText.Result | ClearText.Query);
			DawnLib.DefineTerminalCommand(NamespacedKey<DawnTerminalCommandInfo>.From("dawn_lib", "test_complex_command"), commandBasicInformation3, delegate(TerminalCommandInfoBuilder builder)
			{
				builder.SetKeywords(new List<string>(1) { "complex" });
				builder.DefineComplexCommand(delegate(TerminalCommandInfoBuilder.ComplexCommandBuilder complexBuilder)
				{
					complexBuilder.SetSecondaryKeywords(new List<string>(3) { "first", "second", "third" });
					complexBuilder.SetResultsDisplayText(new List<Func<string>>(3)
					{
						() => "result 1",
						() => "result 2",
						() => "result 3"
					});
				});
			});
			TerminalCommandBasicInformation commandBasicInformation4 = new TerminalCommandBasicInformation("DawnLibInputs", "Test", "Takes the player's input and uses it on the next screen.", ClearText.Result | ClearText.Query);
			DawnLib.DefineTerminalCommand(NamespacedKey<DawnTerminalCommandInfo>.From("dawn_lib", "test_input_command"), commandBasicInformation4, delegate(TerminalCommandInfoBuilder builder)
			{
				builder.SetKeywords(new List<string>(1) { "input" });
				builder.DefineInputCommand(delegate(TerminalCommandInfoBuilder.InputCommandBuilder inputBuilder)
				{
					inputBuilder.SetResultDisplayText(InputCommandExample);
				});
			});
			Action<bool> dawnEvent = delegate(bool continued)
			{
				//IL_0016: Unknown result type (might be due to invalid IL or missing references)
				//IL_001c: Unknown result type (might be due to invalid IL or missing references)
				if (!continued)
				{
					GameNetworkManager.Instance.localPlayerController.DamagePlayer(50, true, true, (CauseOfDeath)0, 0, false, default(Vector3));
				}
			};
			TerminalCommandBasicInformation commandBasicInformation5 = new TerminalCommandBasicInformation("DawnLibQueryCommand", "Test", "Test query command with added compatible nouns", ClearText.Result | ClearText.Query);
			DawnLib.DefineTerminalCommand(NamespacedKey<DawnTerminalCommandInfo>.From("dawn_lib", "test_query_command"), commandBasicInformation5, delegate(TerminalCommandInfoBuilder builder)
			{
				builder.SetKeywords(new List<string>(2) { "qUEry", "version" });
				builder.DefineSimpleQueryCommand(delegate(TerminalCommandInfoBuilder.SimpleQueryCommandBuilder queryCommandBuilder)
				{
					queryCommandBuilder.SetResult(() => "You have selected, YES!\n\n");
					queryCommandBuilder.SetContinueOrCancel(() => "This is a test query, respond [YES] or [NO]\n\n");
					queryCommandBuilder.SetCancel(() => "You have selected, NO!\n\n");
					queryCommandBuilder.SetContinueConditions(() => (Object)(object)GameNetworkManager.Instance.localPlayerController.currentlyHeldObjectServer != (Object)null);
					queryCommandBuilder.SetQueryEvent(dawnEvent);
					queryCommandBuilder.SetContinueWord("yes");
					queryCommandBuilder.SetCancelWord("no");
				});
			});
			TerminalCommandBasicInformation commandBasicInformation6 = new TerminalCommandBasicInformation("DawnLibComplexQueryCommand", "Test", "Test complex query command", ClearText.Result | ClearText.Query);
			DawnLib.DefineTerminalCommand(NamespacedKey<DawnTerminalCommandInfo>.From("dawn_lib", "test_complex_query_command"), commandBasicInformation6, delegate(TerminalCommandInfoBuilder builder)
			{
				builder.SetKeywords(new List<string>(2) { "complex query", "please" });
				builder.DefineComplexQueryCommand(delegate(TerminalCommandInfoBuilder.ComplexQueryCommandBuilder complexQueryCommandBuilder)
				{
					complexQueryCommandBuilder.SetContinueOrCancelDisplayTexts(() => "This is a test complex query, what's your favourite mod?\n\n");
					complexQueryCommandBuilder.SetResultDisplayTexts(new List<Func<string>>(3)
					{
						() => "wow, that's a nice mod",
						() => "Not a good mod",
						() => "It's had its ups and downs"
					});
					complexQueryCommandBuilder.SetContinueKeywords(new List<string>(3) { "coderebirth", "surfaced", "biodiversity" });
					complexQueryCommandBuilder.SetCancelKeyword("usefulzapgun");
					complexQueryCommandBuilder.SetCancelDisplayText(() => "That's not a nice mod\n\n");
				});
			});
			TerminalCommandBasicInformation commandBasicInformation7 = new TerminalCommandBasicInformation("DawnLibEventDrivenCommand", "Test", "Test event driven command", ClearText.Result | ClearText.Query);
			DawnLib.DefineTerminalCommand(NamespacedKey<DawnTerminalCommandInfo>.From("dawn_lib", "test_event_driven_command"), commandBasicInformation7, delegate(TerminalCommandInfoBuilder builder)
			{
				builder.SetKeywords(new List<string>(1) { "event driven" });
				builder.DefineEventDrivenCommand(delegate(TerminalCommandInfoBuilder.EventDrivenCommandBuilder eventDrivenCommandBuilder)
				{
					eventDrivenCommandBuilder.SetResultNodeDisplayText(() => "This is a test event driven command, it copies the... eject command... wait what?\n\n");
					eventDrivenCommandBuilder.SetOnTerminalEvent(VanillaTerminalEvents.EjectPlayersEvent);
				});
			});
		}

		private static string BasicLightsCommand()
		{
			if ((Object)(object)StartOfRound.Instance == (Object)null)
			{
				return "Command not Initialized!\n\n";
			}
			StartOfRound.Instance.shipRoomLights.ToggleShipLights();
			if (StartOfRound.Instance.shipRoomLights.areLightsOn)
			{
				return "Ship Lights are [ON]\n\n";
			}
			return "Ship Lights are [OFF]\n\n";
		}

		private static string InputCommandExample(string userInput)
		{
			return "This is a test command displaying user input after the command.\n\nUser input is [ " + userInput + " ]\n\n";
		}
	}
	public delegate void Event();
	public delegate void Event<T>(T param);
	public delegate void Event<T1, T2>(T1 param1, T2 param2);
	public delegate void Event<T1, T2, T3>(T1 param1, T2 param2, T3 param3);
	public delegate void Event<T1, T2, T3, T4>(T1 param1, T2 param2, T3 param3, T4 param4);
	public delegate void Event<T1, T2, T3, T4, T5>(T1 param1, T2 param2, T3 param3, T4 param4, T5 param5);
	public delegate void Event<T1, T2, T3, T4, T5, T6>(T1 param1, T2 param2, T3 param3, T4 param4, T5 param5, T6 param6);
	public class DawnEvent
	{
		public event Event OnInvoke;

		public void Invoke()
		{
			this.OnInvoke?.Invoke();
		}
	}
	public class DawnEvent<T>
	{
		public event Event<T> OnInvoke;

		public void Invoke(T param)
		{
			this.OnInvoke?.Invoke(param);
		}
	}
	public class DawnEvent<T1, T2>
	{
		public event Event<T1, T2> OnInvoke;

		public void Invoke(T1 param1, T2 param2)
		{
			this.OnInvoke?.Invoke(param1, param2);
		}
	}
	public class DawnEvent<T1, T2, T3>
	{
		public event Event<T1, T2, T3> OnInvoke;

		public void Invoke(T1 param1, T2 param2, T3 param3)
		{
			this.OnInvoke?.Invoke(param1, param2, param3);
		}
	}
	public class DawnEvent<T1, T2, T3, T4>
	{
		public event Event<T1, T2, T3, T4> OnInvoke;

		public void Invoke(T1 param1, T2 param2, T3 param3, T4 param4)
		{
			this.OnInvoke?.Invoke(param1, param2, param3, param4);
		}
	}
	public class DawnEvent<T1, T2, T3, T4, T5>
	{
		public event Event<T1, T2, T3, T4, T5> OnInvoke;

		public void Invoke(T1 param1, T2 param2, T3 param3, T4 param4, T5 param5)
		{
			this.OnInvoke?.Invoke(param1, param2, param3, param4, param5);
		}
	}
	public class DawnEvent<T1, T2, T3, T4, T5, T6>
	{
		public event Event<T1, T2, T3, T4, T5, T6> OnInvoke;

		public void Invoke(T1 param1, T2 param2, T3 param3, T4 param4, T5 param5, T6 param6)
		{
			this.OnInvoke?.Invoke(param1, param2, param3, param4, param5, param6);
		}
	}
	internal static class MyPluginInfo
	{
		public const string PLUGIN_GUID = "com.github.teamxiaolan.dawnlib";

		public const string PLUGIN_NAME = "DawnLib";

		public const string PLUGIN_VERSION = "0.9.21";
	}
	[GeneratedCode("DawnLib", "0.9.21")]
	public static class MoonKeys
	{
		public static NamespacedKey<DawnMoonInfo> Test = NamespacedKey<DawnMoonInfo>.Vanilla("test");

		public static NamespacedKey<DawnMoonInfo> Adamance = NamespacedKey<DawnMoonInfo>.Vanilla("adamance");

		public static NamespacedKey<DawnMoonInfo> Artifice = NamespacedKey<DawnMoonInfo>.Vanilla("artifice");

		public static NamespacedKey<DawnMoonInfo> Assurance = NamespacedKey<DawnMoonInfo>.Vanilla("assurance");

		public static NamespacedKey<DawnMoonInfo> Gordion = NamespacedKey<DawnMoonInfo>.Vanilla("gordion");

		public static NamespacedKey<DawnMoonInfo> Dine = NamespacedKey<DawnMoonInfo>.Vanilla("dine");

		public static NamespacedKey<DawnMoonInfo> Embrion = NamespacedKey<DawnMoonInfo>.Vanilla("embrion");

		public static NamespacedKey<DawnMoonInfo> Experimentation = NamespacedKey<DawnMoonInfo>.Vanilla("experimentation");

		public static NamespacedKey<DawnMoonInfo> Liquidation = NamespacedKey<DawnMoonInfo>.Vanilla("liquidation");

		public static NamespacedKey<DawnMoonInfo> March = NamespacedKey<DawnMoonInfo>.Vanilla("march");

		public static NamespacedKey<DawnMoonInfo> Offense = NamespacedKey<DawnMoonInfo>.Vanilla("offense");

		public static NamespacedKey<DawnMoonInfo> Rend = NamespacedKey<DawnMoonInfo>.Vanilla("rend");

		public static NamespacedKey<DawnMoonInfo> Titan = NamespacedKey<DawnMoonInfo>.Vanilla("titan");

		public static NamespacedKey<DawnMoonInfo> Vow = NamespacedKey<DawnMoonInfo>.Vanilla("vow");

		public static NamespacedKey<DawnMoonInfo>? GetByReflection(string name)
		{
			return (NamespacedKey<DawnMoonInfo>)(typeof(MoonKeys).GetField(name)?.GetValue(null));
		}
	}
	[GeneratedCode("DawnLib", "0.9.21")]
	public static class WeatherKeys
	{
		public static NamespacedKey<DawnWeatherEffectInfo> None = NamespacedKey<DawnWeatherEffectInfo>.Vanilla("none");

		public static NamespacedKey<DawnWeatherEffectInfo> Rollinggroundfog = NamespacedKey<DawnWeatherEffectInfo>.Vanilla("rolling_ground_fog");

		public static NamespacedKey<DawnWeatherEffectInfo> Rainy = NamespacedKey<DawnWeatherEffectInfo>.Vanilla("rainy");

		public static NamespacedKey<DawnWeatherEffectInfo> Stormy = NamespacedKey<DawnWeatherEffectInfo>.Vanilla("stormy");

		public static NamespacedKey<DawnWeatherEffectInfo> Foggy = NamespacedKey<DawnWeatherEffectInfo>.Vanilla("foggy");

		public static NamespacedKey<DawnWeatherEffectInfo> Flooded = NamespacedKey<DawnWeatherEffectInfo>.Vanilla("flooded");

		public static NamespacedKey<DawnWeatherEffectInfo> Eclipsed = NamespacedKey<DawnWeatherEffectInfo>.Vanilla("eclipsed");

		public static NamespacedKey<DawnWeatherEffectInfo>? GetByReflection(string name)
		{
			return (NamespacedKey<DawnWeatherEffectInfo>)(typeof(WeatherKeys).GetField(name)?.GetValue(null));
		}
	}
	[GeneratedCode("DawnLib", "0.9.21")]
	public static class EnemyKeys
	{
		public static NamespacedKey<DawnEnemyInfo> Baboonhawk = NamespacedKey<DawnEnemyInfo>.Vanilla("baboon_hawk");

		public static NamespacedKey<DawnEnemyInfo> Blob = NamespacedKey<DawnEnemyInfo>.Vanilla("blob");

		public static NamespacedKey<DawnEnemyInfo> BushWolf = NamespacedKey<DawnEnemyInfo>.Vanilla("bush_wolf");

		public static NamespacedKey<DawnEnemyInfo> Butler = NamespacedKey<DawnEnemyInfo>.Vanilla("butler");

		public static NamespacedKey<DawnEnemyInfo> ButlerBees = NamespacedKey<DawnEnemyInfo>.Vanilla("butler_bees");

		public static NamespacedKey<DawnEnemyInfo> Maneater = NamespacedKey<DawnEnemyInfo>.Vanilla("maneater");

		public static NamespacedKey<DawnEnemyInfo> Centipede = NamespacedKey<DawnEnemyInfo>.Vanilla("centipede");

		public static NamespacedKey<DawnEnemyInfo> ClaySurgeon = NamespacedKey<DawnEnemyInfo>.Vanilla("clay_surgeon");

		public static NamespacedKey<DawnEnemyInfo> Crawler = NamespacedKey<DawnEnemyInfo>.Vanilla("crawler");

		public static NamespacedKey<DawnEnemyInfo> DocileLocustBees = NamespacedKey<DawnEnemyInfo>.Vanilla("docile_locust_bees");

		public static NamespacedKey<DawnEnemyInfo> Manticoil = NamespacedKey<DawnEnemyInfo>.Vanilla("manticoil");

		public static NamespacedKey<DawnEnemyInfo> Girl = NamespacedKey<DawnEnemyInfo>.Vanilla("girl");

		public static NamespacedKey<DawnEnemyInfo> Flowerman = NamespacedKey<DawnEnemyInfo>.Vanilla("flowerman");

		public static NamespacedKey<DawnEnemyInfo> TulipSnake = NamespacedKey<DawnEnemyInfo>.Vanilla("tulip_snake");

		public static NamespacedKey<DawnEnemyInfo> ForestGiant = NamespacedKey<DawnEnemyInfo>.Vanilla("forestgiant");

		public static NamespacedKey<DawnEnemyInfo> GiantKiwi = NamespacedKey<DawnEnemyInfo>.Vanilla("giantkiwi");

		public static NamespacedKey<DawnEnemyInfo> Hoardingbug = NamespacedKey<DawnEnemyInfo>.Vanilla("hoarding_bug");

		public static NamespacedKey<DawnEnemyInfo> Jester = NamespacedKey<DawnEnemyInfo>.Vanilla("jester");

		public static NamespacedKey<DawnEnemyInfo> Lasso = NamespacedKey<DawnEnemyInfo>.Vanilla("lasso");

		public static NamespacedKey<DawnEnemyInfo> Masked = NamespacedKey<DawnEnemyInfo>.Vanilla("masked");

		public static NamespacedKey<DawnEnemyInfo> MouthDog = NamespacedKey<DawnEnemyInfo>.Vanilla("mouthdog");

		public static NamespacedKey<DawnEnemyInfo> Nutcracker = NamespacedKey<DawnEnemyInfo>.Vanilla("nutcracker");

		public static NamespacedKey<DawnEnemyInfo> Puffer = NamespacedKey<DawnEnemyInfo>.Vanilla("puffer");

		public static NamespacedKey<DawnEnemyInfo> RadMech = NamespacedKey<DawnEnemyInfo>.Vanilla("radmech");

		public static NamespacedKey<DawnEnemyInfo> RedLocustBees = NamespacedKey<DawnEnemyInfo>.Vanilla("red_locust_bees");

		public static NamespacedKey<DawnEnemyInfo> Redpill = NamespacedKey<DawnEnemyInfo>.Vanilla("red_pill");

		public static NamespacedKey<DawnEnemyInfo> BunkerSpider = NamespacedKey<DawnEnemyInfo>.Vanilla("bunker_spider");

		public static NamespacedKey<DawnEnemyInfo> EarthLeviathan = NamespacedKey<DawnEnemyInfo>.Vanilla("earth_leviathan");

		public static NamespacedKey<DawnEnemyInfo> Spring = NamespacedKey<DawnEnemyInfo>.Vanilla("spring");

		public static NamespacedKey<DawnEnemyInfo> Stingray = NamespacedKey<DawnEnemyInfo>.Vanilla("stingray");

		public static NamespacedKey<DawnEnemyInfo> Feiopar = NamespacedKey<DawnEnemyInfo>.Vanilla("feiopar");

		public static NamespacedKey<DawnEnemyInfo> CadaverGrowths = NamespacedKey<DawnEnemyInfo>.Vanilla("cadaver_growths");

		public static NamespacedKey<DawnEnemyInfo> CadaverBloom = NamespacedKey<DawnEnemyInfo>.Vanilla("cadaver_bloom");

		public static NamespacedKey<DawnEnemyInfo>? GetByReflection(string name)
		{
			return (NamespacedKey<DawnEnemyInfo>)(typeof(EnemyKeys).GetField(name)?.GetValue(null));
		}
	}
	[GeneratedCode("DawnLib", "0.9.21")]
	public static class UnlockableItemKeys
	{
		public static NamespacedKey<DawnUnlockableItemInfo> Orangesuit = NamespacedKey<DawnUnlockableItemInfo>.Vanilla("orange_suit");

		public static NamespacedKey<DawnUnlockableItemInfo> Greensuit = NamespacedKey<DawnUnlockableItemInfo>.Vanilla("green_suit");

		public static NamespacedKey<DawnUnlockableItemInfo> Hazardsuit = NamespacedKey<DawnUnlockableItemInfo>.Vanilla("hazard_suit");

		public static NamespacedKey<DawnUnlockableItemInfo> Pajamasuit = NamespacedKey<DawnUnlockableItemInfo>.Vanilla("pajama_suit");

		public static NamespacedKey<DawnUnlockableItemInfo> Cozylights = NamespacedKey<DawnUnlockableItemInfo>.Vanilla("cozy_lights");

		public static NamespacedKey<DawnUnlockableItemInfo> Teleporter = NamespacedKey<DawnUnlockableItemInfo>.Vanilla("teleporter");

		public static NamespacedKey<DawnUnlockableItemInfo> Television = NamespacedKey<DawnUnlockableItemInfo>.Vanilla("television");

		public static NamespacedKey<DawnUnlockableItemInfo> Cupboard = NamespacedKey<DawnUnlockableItemInfo>.Vanilla("cupboard");

		public static NamespacedKey<DawnUnlockableItemInfo> FileCabinet = NamespacedKey<DawnUnlockableItemInfo>.Vanilla("file_cabinet");

		public static NamespacedKey<DawnUnlockableItemInfo> Toilet = NamespacedKey<DawnUnlockableItemInfo>.Vanilla("toilet");

		public static NamespacedKey<DawnUnlockableItemInfo> Shower = NamespacedKey<DawnUnlockableItemInfo>.Vanilla("shower");

		public static NamespacedKey<DawnUnlockableItemInfo> Lightswitch = NamespacedKey<DawnUnlockableItemInfo>.Vanilla("light_switch");

		public static NamespacedKey<DawnUnlockableItemInfo> Recordplayer = NamespacedKey<DawnUnlockableItemInfo>.Vanilla("record_player");

		public static NamespacedKey<DawnUnlockableItemInfo> Table = NamespacedKey<DawnUnlockableItemInfo>.Vanilla("table");

		public static NamespacedKey<DawnUnlockableItemInfo> Romantictable = NamespacedKey<DawnUnlockableItemInfo>.Vanilla("romantic_table");

		public static NamespacedKey<DawnUnlockableItemInfo> Bunkbeds = NamespacedKey<DawnUnlockableItemInfo>.Vanilla("bunkbeds");

		public static NamespacedKey<DawnUnlockableItemInfo> Terminal = NamespacedKey<DawnUnlockableItemInfo>.Vanilla("terminal");

		public static NamespacedKey<DawnUnlockableItemInfo> Signaltranslator = NamespacedKey<DawnUnlockableItemInfo>.Vanilla("signal_translator");

		public static NamespacedKey<DawnUnlockableItemInfo> Loudhorn = NamespacedKey<DawnUnlockableItemInfo>.Vanilla("loud_horn");

		public static NamespacedKey<DawnUnlockableItemInfo> InverseTeleporter = NamespacedKey<DawnUnlockableItemInfo>.Vanilla("inverse_teleporter");

		public static NamespacedKey<DawnUnlockableItemInfo> JackOLantern = NamespacedKey<DawnUnlockableItemInfo>.Vanilla("jackolantern");

		public static NamespacedKey<DawnUnlockableItemInfo> Welcomemat = NamespacedKey<DawnUnlockableItemInfo>.Vanilla("welcome_mat");

		public static NamespacedKey<DawnUnlockableItemInfo> Goldfish = NamespacedKey<DawnUnlockableItemInfo>.Vanilla("goldfish");

		public static NamespacedKey<DawnUnlockableItemInfo> Plushiepajamaman = NamespacedKey<DawnUnlockableItemInfo>.Vanilla("plushie_pajama_man");

		public static NamespacedKey<DawnUnlockableItemInfo> PurpleSuit = NamespacedKey<DawnUnlockableItemInfo>.Vanilla("purple_suit");

		public static NamespacedKey<DawnUnlockableItemInfo> BeeSuit = NamespacedKey<DawnUnlockableItemInfo>.Vanilla("bee_suit");

		public static NamespacedKey<DawnUnlockableItemInfo> BunnySuit = NamespacedKey<DawnUnlockableItemInfo>.Vanilla("bunny_suit");

		public static NamespacedKey<DawnUnlockableItemInfo> DiscoBall = NamespacedKey<DawnUnlockableItemInfo>.Vanilla("disco_ball");

		public static NamespacedKey<DawnUnlockableItemInfo> Microwave = NamespacedKey<DawnUnlockableItemInfo>.Vanilla("microwave");

		public static NamespacedKey<DawnUnlockableItemInfo> Sofachair = NamespacedKey<DawnUnlockableItemInfo>.Vanilla("sofa_chair");

		public static NamespacedKey<DawnUnlockableItemInfo> Fridge = NamespacedKey<DawnUnlockableItemInfo>.Vanilla("fridge");

		public static NamespacedKey<DawnUnlockableItemInfo> Classicpainting = NamespacedKey<DawnUnlockableItemInfo>.Vanilla("classic_painting");

		public static NamespacedKey<DawnUnlockableItemInfo> Electricchair = NamespacedKey<DawnUnlockableItemInfo>.Vanilla("electric_chair");

		public static NamespacedKey<DawnUnlockableItemInfo> Doghouse = NamespacedKey<DawnUnlockableItemInfo>.Vanilla("dog_house");

		public static NamespacedKey<DawnUnlockableItemInfo>? GetByReflection(string name)
		{
			return (NamespacedKey<DawnUnlockableItemInfo>)(typeof(UnlockableItemKeys).GetField(name)?.GetValue(null));
		}
	}
	[GeneratedCode("DawnLib", "0.9.21")]
	public static class ItemKeys
	{
		public static NamespacedKey<DawnItemInfo> MagicSevenball = NamespacedKey<DawnItemInfo>.Vanilla("magic_seven_ball");

		public static NamespacedKey<DawnItemInfo> Airhorn = NamespacedKey<DawnItemInfo>.Vanilla("airhorn");

		public static NamespacedKey<DawnItemInfo> Egg = NamespacedKey<DawnItemInfo>.Vanilla("egg");

		public static NamespacedKey<DawnItemInfo> Bell = NamespacedKey<DawnItemInfo>.Vanilla("bell");

		public static NamespacedKey<DawnItemInfo> Beltbag = NamespacedKey<DawnItemInfo>.Vanilla("belt_bag");

		public static NamespacedKey<DawnItemInfo> Bigbolt = NamespacedKey<DawnItemInfo>.Vanilla("big_bolt");

		public static NamespacedKey<DawnItemInfo> Binoculars = NamespacedKey<DawnItemInfo>.Vanilla("binoculars");

		public static NamespacedKey<DawnItemInfo> Boombox = NamespacedKey<DawnItemInfo>.Vanilla("boombox");

		public static NamespacedKey<DawnItemInfo> Bottles = NamespacedKey<DawnItemInfo>.Vanilla("bottles");

		public static NamespacedKey<DawnItemInfo> Brush = NamespacedKey<DawnItemInfo>.Vanilla("brush");

		public static NamespacedKey<DawnItemInfo> Candy = NamespacedKey<DawnItemInfo>.Vanilla("candy");

		public static NamespacedKey<DawnItemInfo> Box = NamespacedKey<DawnItemInfo>.Vanilla("box");

		public static NamespacedKey<DawnItemInfo> Cashregister = NamespacedKey<DawnItemInfo>.Vanilla("cash_register");

		public static NamespacedKey<DawnItemInfo> Maneater = NamespacedKey<DawnItemInfo>.Vanilla("maneater");

		public static NamespacedKey<DawnItemInfo> Chemicaljug = NamespacedKey<DawnItemInfo>.Vanilla("chemical_jug");

		public static NamespacedKey<DawnItemInfo> Clipboard = NamespacedKey<DawnItemInfo>.Vanilla("clipboard");

		public static NamespacedKey<DawnItemInfo> Clock = NamespacedKey<DawnItemInfo>.Vanilla("clock");

		public static NamespacedKey<DawnItemInfo> Clownhorn = NamespacedKey<DawnItemInfo>.Vanilla("clown_horn");

		public static NamespacedKey<DawnItemInfo> Largeaxle = NamespacedKey<DawnItemInfo>.Vanilla("large_axle");

		public static NamespacedKey<DawnItemInfo> Comedy = NamespacedKey<DawnItemInfo>.Vanilla("comedy");

		public static NamespacedKey<DawnItemInfo> Controlpad = NamespacedKey<DawnItemInfo>.Vanilla("control_pad");

		public static NamespacedKey<DawnItemInfo> Teeth = NamespacedKey<DawnItemInfo>.Vanilla("teeth");

		public static NamespacedKey<DawnItemInfo> Homemadeflashbang = NamespacedKey<DawnItemInfo>.Vanilla("homemade_flashbang");

		public static NamespacedKey<DawnItemInfo> Dustpan = NamespacedKey<DawnItemInfo>.Vanilla("dust_pan");

		public static NamespacedKey<DawnItemInfo> Easteregg = NamespacedKey<DawnItemInfo>.Vanilla("easter_egg");

		public static NamespacedKey<DawnItemInfo> Eggbeater = NamespacedKey<DawnItemInfo>.Vanilla("egg_beater");

		public static NamespacedKey<DawnItemInfo> Vtypeengine = NamespacedKey<DawnItemInfo>.Vanilla("vtype_engine");

		public static NamespacedKey<DawnItemInfo> Extensionladder = NamespacedKey<DawnItemInfo>.Vanilla("extension_ladder");

		public static NamespacedKey<DawnItemInfo> Goldencup = NamespacedKey<DawnItemInfo>.Vanilla("golden_cup");

		public static NamespacedKey<DawnItemInfo> Fancylamp = NamespacedKey<DawnItemInfo>.Vanilla("fancy_lamp");

		public static NamespacedKey<DawnItemInfo> Painting = NamespacedKey<DawnItemInfo>.Vanilla("painting");

		public static NamespacedKey<DawnItemInfo> Plasticfish = NamespacedKey<DawnItemInfo>.Vanilla("plastic_fish");

		public static NamespacedKey<DawnItemInfo> Laserpointer = NamespacedKey<DawnItemInfo>.Vanilla("laser_pointer");

		public static NamespacedKey<DawnItemInfo> Flashlight = NamespacedKey<DawnItemInfo>.Vanilla("flashlight");

		public static NamespacedKey<DawnItemInfo> Flask = NamespacedKey<DawnItemInfo>.Vanilla("flask");

		public static NamespacedKey<DawnItemInfo> Garbagelid = NamespacedKey<DawnItemInfo>.Vanilla("garbage_lid");

		public static NamespacedKey<DawnItemInfo> Gift = NamespacedKey<DawnItemInfo>.Vanilla("gift");

		public static NamespacedKey<DawnItemInfo> Goldbar = NamespacedKey<DawnItemInfo>.Vanilla("gold_bar");

		public static NamespacedKey<DawnItemInfo> Ammo = NamespacedKey<DawnItemInfo>.Vanilla("ammo");

		public static NamespacedKey<DawnItemInfo> Hairdryer = NamespacedKey<DawnItemInfo>.Vanilla("hairdryer");

		public static NamespacedKey<DawnItemInfo> Jetpack = NamespacedKey<DawnItemInfo>.Vanilla("jetpack");

		public static NamespacedKey<DawnItemInfo> Key = NamespacedKey<DawnItemInfo>.Vanilla("key");

		public static NamespacedKey<DawnItemInfo> Kitchenknife = NamespacedKey<DawnItemInfo>.Vanilla("kitchen_knife");

		public static NamespacedKey<DawnItemInfo> Lockpicker = NamespacedKey<DawnItemInfo>.Vanilla("lockpicker");

		public static NamespacedKey<DawnItemInfo> Apparatus = NamespacedKey<DawnItemInfo>.Vanilla("apparatus");

		public static NamespacedKey<DawnItemInfo> Magnifyingglass = NamespacedKey<DawnItemInfo>.Vanilla("magnifying_glass");

		public static NamespacedKey<DawnItemInfo> Mapper = NamespacedKey<DawnItemInfo>.Vanilla("mapper");

		public static NamespacedKey<DawnItemInfo> Metalsheet = NamespacedKey<DawnItemInfo>.Vanilla("metal_sheet");

		public static NamespacedKey<DawnItemInfo> Cookiepan = NamespacedKey<DawnItemInfo>.Vanilla("cookie_pan");

		public static NamespacedKey<DawnItemInfo> Mug = NamespacedKey<DawnItemInfo>.Vanilla("mug");

		public static NamespacedKey<DawnItemInfo> Perfumebottle = NamespacedKey<DawnItemInfo>.Vanilla("perfume_bottle");

		public static NamespacedKey<DawnItemInfo> Oldphone = NamespacedKey<DawnItemInfo>.Vanilla("old_phone");

		public static NamespacedKey<DawnItemInfo> Jarofpickles = NamespacedKey<DawnItemInfo>.Vanilla("jar_of_pickles");

		public static NamespacedKey<DawnItemInfo> Pillbottle = NamespacedKey<DawnItemInfo>.Vanilla("pill_bottle");

		public static NamespacedKey<DawnItemInfo> Plasticcup = NamespacedKey<DawnItemInfo>.Vanilla("plastic_cup");

		public static NamespacedKey<DawnItemInfo> Proflashlight = NamespacedKey<DawnItemInfo>.Vanilla("proflashlight");

		public static NamespacedKey<DawnItemInfo> Radarbooster = NamespacedKey<DawnItemInfo>.Vanilla("radarbooster");

		public static NamespacedKey<DawnItemInfo> Body = NamespacedKey<DawnItemInfo>.Vanilla("body");

		public static NamespacedKey<DawnItemInfo> Hive = NamespacedKey<DawnItemInfo>.Vanilla("hive");

		public static NamespacedKey<DawnItemInfo> Remote = NamespacedKey<DawnItemInfo>.Vanilla("remote");

		public static NamespacedKey<DawnItemInfo> Ring = NamespacedKey<DawnItemInfo>.Vanilla("ring");

		public static NamespacedKey<DawnItemInfo> Toyrobot = NamespacedKey<DawnItemInfo>.Vanilla("toy_robot");

		public static NamespacedKey<DawnItemInfo> RubberDucky = NamespacedKey<DawnItemInfo>.Vanilla("rubber_ducky");

		public static NamespacedKey<DawnItemInfo> Bone = NamespacedKey<DawnItemInfo>.Vanilla("bone");

		public static NamespacedKey<DawnItemInfo> Ribcage = NamespacedKey<DawnItemInfo>.Vanilla("ribcage");

		public static NamespacedKey<DawnItemInfo> Ear = NamespacedKey<DawnItemInfo>.Vanilla("ear");

		public static NamespacedKey<DawnItemInfo> Foot = NamespacedKey<DawnItemInfo>.Vanilla("foot");

		public static NamespacedKey<DawnItemInfo> Hand = NamespacedKey<DawnItemInfo>.Vanilla("hand");

		public static NamespacedKey<DawnItemInfo> Heart = NamespacedKey<DawnItemInfo>.Vanilla("heart");

		public static NamespacedKey<DawnItemInfo> Knee = NamespacedKey<DawnItemInfo>.Vanilla("knee");

		public static NamespacedKey<DawnItemInfo> Tongue = NamespacedKey<DawnItemInfo>.Vanilla("tongue");

		public static NamespacedKey<DawnItemInfo> Shotgun = NamespacedKey<DawnItemInfo>.Vanilla("shotgun");

		public static NamespacedKey<DawnItemInfo> Shovel = NamespacedKey<DawnItemInfo>.Vanilla("shovel");

		public static NamespacedKey<DawnItemInfo> Soccerball = NamespacedKey<DawnItemInfo>.Vanilla("soccer_ball");

		public static NamespacedKey<DawnItemInfo> Redsoda = NamespacedKey<DawnItemInfo>.Vanilla("red_soda");

		public static NamespacedKey<DawnItemInfo> Spraypaint = NamespacedKey<DawnItemInfo>.Vanilla("spray_paint");

		public static NamespacedKey<DawnItemInfo> Steeringwheel = NamespacedKey<DawnItemInfo>.Vanilla("steering_wheel");

		public static NamespacedKey<DawnItemInfo> Stickynote = NamespacedKey<DawnItemInfo>.Vanilla("sticky_note");

		public static NamespacedKey<DawnItemInfo> Stopsign = NamespacedKey<DawnItemInfo>.Vanilla("stop_sign");

		public static NamespacedKey<DawnItemInfo> Stungrenade = NamespacedKey<DawnItemInfo>.Vanilla("stun_grenade");

		public static NamespacedKey<DawnItemInfo> Teakettle = NamespacedKey<DawnItemInfo>.Vanilla("tea_kettle");

		public static NamespacedKey<DawnItemInfo> Toiletpaper = NamespacedKey<DawnItemInfo>.Vanilla("toilet_paper");

		public static NamespacedKey<DawnItemInfo> Toothpaste = NamespacedKey<DawnItemInfo>.Vanilla("toothpaste");

		public static NamespacedKey<DawnItemInfo> Toycube = NamespacedKey<DawnItemInfo>.Vanilla("toy_cube");

		public static NamespacedKey<DawnItemInfo> Toytrain = NamespacedKey<DawnItemInfo>.Vanilla("toy_train");

		public static NamespacedKey<DawnItemInfo> Tragedy = NamespacedKey<DawnItemInfo>.Vanilla("tragedy");

		public static NamespacedKey<DawnItemInfo> TZPInhalant = NamespacedKey<DawnItemInfo>.Vanilla("tzpinhalant");

		public static NamespacedKey<DawnItemInfo> Walkietalkie = NamespacedKey<DawnItemInfo>.Vanilla("walkietalkie");

		public static NamespacedKey<DawnItemInfo> Weedkiller = NamespacedKey<DawnItemInfo>.Vanilla("weed_killer");

		public static NamespacedKey<DawnItemInfo> Whoopiecushion = NamespacedKey<DawnItemInfo>.Vanilla("whoopie_cushion");

		public static NamespacedKey<DawnItemInfo> Yieldsign = NamespacedKey<DawnItemInfo>.Vanilla("yield_sign");

		public static NamespacedKey<DawnItemInfo> Zapgun = NamespacedKey<DawnItemInfo>.Vanilla("zap_gun");

		public static NamespacedKey<DawnItemInfo> ZedDog = NamespacedKey<DawnItemInfo>.Vanilla("zed_dog");

		public static NamespacedKey<DawnItemInfo>? GetByReflection(string name)
		{
			return (NamespacedKey<DawnItemInfo>)(typeof(ItemKeys).GetField(name)?.GetValue(null));
		}
	}
	[GeneratedCode("DawnLib", "0.9.21")]
	public static class DungeonKeys
	{
		public static NamespacedKey<DawnDungeonInfo> FacilityFlow = NamespacedKey<DawnDungeonInfo>.Vanilla("facility");

		public static NamespacedKey<DawnDungeonInfo> FacilityFlowThreeExits = NamespacedKey<DawnDungeonInfo>.Vanilla("facility_three_exits");

		public static NamespacedKey<DawnDungeonInfo> FacilityFlowExtraLarge = NamespacedKey<DawnDungeonInfo>.Vanilla("facility_extra_large");

		public static NamespacedKey<DawnDungeonInfo> MansionFlow = NamespacedKey<DawnDungeonInfo>.Vanilla("mansion");

		public static NamespacedKey<DawnDungeonInfo> MineshaftFlow = NamespacedKey<DawnDungeonInfo>.Vanilla("mineshaft");

		public static NamespacedKey<DawnDungeonInfo>? GetByReflection(string name)
		{
			return (NamespacedKey<DawnDungeonInfo>)(typeof(DungeonKeys).GetField(name)?.GetValue(null));
		}
	}
	[GeneratedCode("DawnLib", "0.9.21")]
	public static class DungeonTileSetKeys
	{
		public static NamespacedKey<DawnTileSetInfo> FacilityHallway = NamespacedKey<DawnTileSetInfo>.Vanilla("facility_hallway_tiles");

		public static NamespacedKey<DawnTileSetInfo> FacilityMaze = NamespacedKey<DawnTileSetInfo>.Vanilla("facility_maze_tiles");

		public static NamespacedKey<DawnTileSetInfo> FacilityRoom = NamespacedKey<DawnTileSetInfo>.Vanilla("facility_room_tiles");

		public static NamespacedKey<DawnTileSetInfo> MansionCap = NamespacedKey<DawnTileSetInfo>.Vanilla("mansion_cap_tiles");

		public static NamespacedKey<DawnTileSetInfo> MansionHallway = NamespacedKey<DawnTileSetInfo>.Vanilla("mansion_hallway_tiles");

		public static NamespacedKey<DawnTileSetInfo> MansionHallwayB = NamespacedKey<DawnTileSetInfo>.Vanilla("mansion_hallway_b_tiles");

		public static NamespacedKey<DawnTileSetInfo> MansionRoom = NamespacedKey<DawnTileSetInfo>.Vanilla("mansion_room_tiles");

		public static NamespacedKey<DawnTileSetInfo> MansionStartRooms = NamespacedKey<DawnTileSetInfo>.Vanilla("mansion_start_rooms");

		public static NamespacedKey<DawnTileSetInfo> MineshaftCave = NamespacedKey<DawnTileSetInfo>.Vanilla("mineshaft_cave_tiles");

		public static NamespacedKey<DawnTileSetInfo> MineshaftTunnelEnd = NamespacedKey<DawnTileSetInfo>.Vanilla("mineshaft_tunnel_end_tiles");

		public static NamespacedKey<DawnTileSetInfo> MineshaftTunnel = NamespacedKey<DawnTileSetInfo>.Vanilla("mineshaft_tunnel_tiles");

		public static NamespacedKey<DawnTileSetInfo> MineshaftStartRooms = NamespacedKey<DawnTileSetInfo>.Vanilla("mineshaft_start_rooms");

		public static NamespacedKey<DawnTileSetInfo> MineshaftCaveBranch = NamespacedKey<DawnTileSetInfo>.Vanilla("mineshaft_cave_branch_tiles");

		public static NamespacedKey<DawnTileSetInfo> MineshaftEndTunnel = NamespacedKey<DawnTileSetInfo>.Vanilla("mineshaft_end_tunnel_tiles");

		public static NamespacedKey<DawnTileSetInfo> MineshaftEndTunnelBranchCaps = NamespacedKey<DawnTileSetInfo>.Vanilla("mineshaft_end_tunnel_branch_caps_tiles");

		public static NamespacedKey<DawnTileSetInfo> StartRooms = NamespacedKey<DawnTileSetInfo>.Vanilla("start_rooms");

		public static NamespacedKey<DawnTileSetInfo>? GetByReflection(string name)
		{
			return (NamespacedKey<DawnTileSetInfo>)(typeof(DungeonTileSetKeys).GetField(name)?.GetValue(null));
		}
	}
	[GeneratedCode("DawnLib", "0.9.21")]
	public static class DungeonArchetypeKeys
	{
		public static NamespacedKey<DawnArchetypeInfo> Facility = NamespacedKey<DawnArchetypeInfo>.Vanilla("facility_archetype");

		public static NamespacedKey<DawnArchetypeInfo> FacilityMaze = NamespacedKey<DawnArchetypeInfo>.Vanilla("facility_maze_archetype");

		public static NamespacedKey<DawnArchetypeInfo> MansionB = NamespacedKey<DawnArchetypeInfo>.Vanilla("mansion_b_archetype");

		public static NamespacedKey<DawnArchetypeInfo> MansionC = NamespacedKey<DawnArchetypeInfo>.Vanilla("mansion_c_archetype");

		public static NamespacedKey<DawnArchetypeInfo> MineshaftCaves = NamespacedKey<DawnArchetypeInfo>.Vanilla("mineshaft_caves_archetype");

		public static NamespacedKey<DawnArchetypeInfo> MineshaftTunnels = NamespacedKey<DawnArchetypeInfo>.Vanilla("mineshaft_tunnels_archetype");

		public static NamespacedKey<DawnArchetypeInfo> MineshaftEndTunnels = NamespacedKey<DawnArchetypeInfo>.Vanilla("mineshaft_end_tunnels_archetype");

		public static NamespacedKey<DawnArchetypeInfo>? GetByReflection(string name)
		{
			return (NamespacedKey<DawnArchetypeInfo>)(typeof(DungeonArchetypeKeys).GetField(name)?.GetValue(null));
		}
	}
	[GeneratedCode("DawnLib", "0.9.21")]
	public static class MapObjectKeys
	{
		public static NamespacedKey<DawnMapObjectInfo> TurretContainer = NamespacedKey<DawnMapObjectInfo>.Vanilla("turretcontainer");

		public static NamespacedKey<DawnMapObjectInfo> Landmine = NamespacedKey<DawnMapObjectInfo>.Vanilla("landmine");

		public static NamespacedKey<DawnMapObjectInfo> SpikeRoofTrapHazard = NamespacedKey<DawnMapObjectInfo>.Vanilla("spikerooftraphazard");

		public static NamespacedKey<DawnMapObjectInfo> TreeLeaflessBrownZeroZeroOneVariant = NamespacedKey<DawnMapObjectInfo>.Vanilla("treeleaflessbrownzerozeroone_variant");

		public static NamespacedKey<DawnMapObjectInfo> GreyRockGroupingTwo = NamespacedKey<DawnMapObjectInfo>.Vanilla("greyrockgroupingtwo");

		public static NamespacedKey<DawnMapObjectInfo> GreyRockGroupingFour = NamespacedKey<DawnMapObjectInfo>.Vanilla("greyrockgroupingfour");

		public static NamespacedKey<DawnMapObjectInfo> GiantPumpkin = NamespacedKey<DawnMapObjectInfo>.Vanilla("giantpumpkin");

		public static NamespacedKey<DawnMapObjectInfo> LargeRockOneGrey = NamespacedKey<DawnMapObjectInfo>.Vanilla("largerockonegrey");

		public static NamespacedKey<DawnMapObjectInfo> LargeRockTwoGrey = NamespacedKey<DawnMapObjectInfo>.Vanilla("largerocktwogrey");

		public static NamespacedKey<DawnMapObjectInfo> LargeRockThreeGrey = NamespacedKey<DawnMapObjectInfo>.Vanilla("largerockthreegrey");

		public static NamespacedKey<DawnMapObjectInfo> LargeRockFourGrey = NamespacedKey<DawnMapObjectInfo>.Vanilla("largerockfourgrey");

		public static NamespacedKey<DawnMapObjectInfo> TreeLeaflessZeroZeroTwoLODZero = NamespacedKey<DawnMapObjectInfo>.Vanilla("treeleaflesszerozerotwo_lodzero");

		public static NamespacedKey<DawnMapObjectInfo> LargeRockOne = NamespacedKey<DawnMapObjectInfo>.Vanilla("largerockone");

		public static NamespacedKey<DawnMapObjectInfo> LargeRockTwo = NamespacedKey<DawnMapObjectInfo>.Vanilla("largerocktwo");

		public static NamespacedKey<DawnMapObjectInfo> LargeRockThree = NamespacedKey<DawnMapObjectInfo>.Vanilla("largerockthree");

		public static NamespacedKey<DawnMapObjectInfo> LargeRockFour = NamespacedKey<DawnMapObjectInfo>.Vanilla("largerockfour");

		public static NamespacedKey<DawnMapObjectInfo> TreeLeaflessZeroZeroThreeLODZero = NamespacedKey<DawnMapObjectInfo>.Vanilla("treeleaflesszerozerothree_lodzero");

		public static NamespacedKey<DawnMapObjectInfo> Snowman = NamespacedKey<DawnMapObjectInfo>.Vanilla("snowman");

		public static NamespacedKey<DawnMapObjectInfo> SnowmanTall = NamespacedKey<DawnMapObjectInfo>.Vanilla("snowmantall");

		public static NamespacedKey<DawnMapObjectInfo> Tree = NamespacedKey<DawnMapObjectInfo>.Vanilla("tree");

		public static NamespacedKey<DawnMapObjectInfo>? GetByReflection(string name)
		{
			return (NamespacedKey<DawnMapObjectInfo>)(typeof(MapObjectKeys).GetField(name)?.GetValue(null));
		}
	}
	[GeneratedCode("DawnLib", "0.9.21")]
	public static class StoryLogKeys
	{
		public static NamespacedKey<DawnStoryLogInfo> FirstLogAugTwoTwo = NamespacedKey<DawnStoryLogInfo>.Vanilla("first_log__aug_twotwo");

		public static NamespacedKey<DawnStoryLogInfo> MummyAugTwoFour = NamespacedKey<DawnStoryLogInfo>.Vanilla("mummy__aug_twofour");

		public static NamespacedKey<DawnStoryLogInfo> SwingofthingsAugTwoSeven = NamespacedKey<DawnStoryLogInfo>.Vanilla("swing_of_things__aug_twoseven");

		public static NamespacedKey<DawnStoryLogInfo> AutopilotAugThreeOne = NamespacedKey<DawnStoryLogInfo>.Vanilla("autopilot__aug_threeone");

		public static NamespacedKey<DawnStoryLogInfo> BehindTheWallSepFour = NamespacedKey<DawnStoryLogInfo>.Vanilla("behind_the_wall__sep_four");

		public static NamespacedKey<DawnStoryLogInfo> GoodbyeSepSeven = NamespacedKey<DawnStoryLogInfo>.Vanilla("goodbye__sep_seven");

		public static NamespacedKey<DawnStoryLogInfo> ScreamsSepOneThree = NamespacedKey<DawnStoryLogInfo>.Vanilla("screams__sep_onethree");

		public static NamespacedKey<DawnStoryLogInfo> GoldenplanetSep = NamespacedKey<DawnStoryLogInfo>.Vanilla("golden_planet__sep_");

		public static NamespacedKey<DawnStoryLogInfo> IdeaSepOneEight = NamespacedKey<DawnStoryLogInfo>.Vanilla("idea__sep_oneeight");

		public static NamespacedKey<DawnStoryLogInfo> NonsenseSepTwoSeven = NamespacedKey<DawnStoryLogInfo>.Vanilla("nonsense__sep_twoseven");

		public static NamespacedKey<DawnStoryLogInfo> HidingSepThreeZero = NamespacedKey<DawnStoryLogInfo>.Vanilla("hiding__sep_threezero");

		public static NamespacedKey<DawnStoryLogInfo> RealJobOctOne = NamespacedKey<DawnStoryLogInfo>.Vanilla("real_job__oct_one");

		public static NamespacedKey<DawnStoryLogInfo> DesmondOctSeven = NamespacedKey<DawnStoryLogInfo>.Vanilla("desmond__oct_seven");

		public static NamespacedKey<DawnStoryLogInfo> TeamSynergyOctOneZero = NamespacedKey<DawnStoryLogInfo>.Vanilla("team_synergy__oct_onezero");

		public static NamespacedKey<DawnStoryLogInfo> LetterOfResignationOctOneThree = NamespacedKey<DawnStoryLogInfo>.Vanilla("letter_of_resignation__oct_onethree");

		public static NamespacedKey<DawnStoryLogInfo> WorkOctOneFive = NamespacedKey<DawnStoryLogInfo>.Vanilla("work__oct_onefive");

		public static NamespacedKey<DawnStoryLogInfo>? GetByReflection(string name)
		{
			return (NamespacedKey<DawnStoryLogInfo>)(typeof(StoryLogKeys).GetField(name)?.GetValue(null));
		}
	}
	[GeneratedCode("DawnLib", "0.9.21")]
	public static class SurfaceKeys
	{
		public static NamespacedKey<DawnSurfaceInfo> Concrete = NamespacedKey<DawnSurfaceInfo>.Vanilla("concrete");

		public static NamespacedKey<DawnSurfaceInfo> Gravel = NamespacedKey<DawnSurfaceInfo>.Vanilla("gravel");

		public static NamespacedKey<DawnSurfaceInfo> Catwalk = NamespacedKey<DawnSurfaceInfo>.Vanilla("catwalk");

		public static NamespacedKey<DawnSurfaceInfo> Aluminum = NamespacedKey<DawnSurfaceInfo>.Vanilla("aluminum");

		public static NamespacedKey<DawnSurfaceInfo> Grass = NamespacedKey<DawnSurfaceInfo>.Vanilla("grass");

		public static NamespacedKey<DawnSurfaceInfo> Rock = NamespacedKey<DawnSurfaceInfo>.Vanilla("rock");

		public static NamespacedKey<DawnSurfaceInfo> Puddle = NamespacedKey<DawnSurfaceInfo>.Vanilla("puddle");

		public static NamespacedKey<DawnSurfaceInfo> Tiles = NamespacedKey<DawnSurfaceInfo>.Vanilla("tiles");

		public static NamespacedKey<DawnSurfaceInfo> Snow = NamespacedKey<DawnSurfaceInfo>.Vanilla("snow");

		public static NamespacedKey<DawnSurfaceInfo> Carpet = NamespacedKey<DawnSurfaceInfo>.Vanilla("carpet");

		public static NamespacedKey<DawnSurfaceInfo> Untagged = NamespacedKey<DawnSurfaceInfo>.Vanilla("untagged");

		public static NamespacedKey<DawnSurfaceInfo> Wood = NamespacedKey<DawnSurfaceInfo>.Vanilla("wood");

		public static NamespacedKey<DawnSurfaceInfo> Slime = NamespacedKey<DawnSurfaceInfo>.Vanilla("slime");

		public static NamespacedKey<DawnSurfaceInfo> Tree = NamespacedKey<DawnSurfaceInfo>.Vanilla("tree");

		public static NamespacedKey<DawnSurfaceInfo>? GetByReflection(string name)
		{
			return (NamespacedKey<DawnSurfaceInfo>)(typeof(SurfaceKeys).GetField(name)?.GetValue(null));
		}
	}
	[GeneratedCode("DawnLib", "0.9.21")]
	public static class TerminalCommandKeys
	{
		public static NamespacedKey<DawnTerminalCommandInfo> Buy = NamespacedKey<DawnTerminalCommandInfo>.Vanilla("buy");

		public static NamespacedKey<DawnTerminalCommandInfo> BuyProFlashlightTwo = NamespacedKey<DawnTerminalCommandInfo>.Vanilla("buyflashlighttwo");

		public static NamespacedKey<DawnTerminalCommandInfo> BuyFlashTwo = NamespacedKey<DawnTerminalCommandInfo>.Vanilla("buyflashtwo");

		public static NamespacedKey<DawnTerminalCommandInfo> BuyLockpickersTwo = NamespacedKey<DawnTerminalCommandInfo>.Vanilla("buylockpickerstwo");

		public static NamespacedKey<DawnTerminalCommandInfo> BuyMapperTwo = NamespacedKey<DawnTerminalCommandInfo>.Vanilla("buymappertwo");

		public static NamespacedKey<DawnTerminalCommandInfo> BuyZapGunTwo = NamespacedKey<DawnTerminalCommandInfo>.Vanilla("buyzapguntwo");

		public static NamespacedKey<DawnTerminalCommandInfo> BuyShovelTwo = NamespacedKey<DawnTerminalCommandInfo>.Vanilla("buyshoveltwo");

		public static NamespacedKey<DawnTerminalCommandInfo> BuyBoomboxTwo = NamespacedKey<DawnTerminalCommandInfo>.Vanilla("buyboomboxtwo");

		public static NamespacedKey<DawnTerminalCommandInfo> BuyWalkieTalkieTwo = NamespacedKey<DawnTerminalCommandInfo>.Vanilla("buywalkietalkietwo");

		public static NamespacedKey<DawnTerminalCommandInfo> BuySurvivalKitTwo = NamespacedKey<DawnTerminalCommandInfo>.Vanilla("buysurvivalkittwo");

		public static NamespacedKey<DawnTerminalCommandInfo> GreenSuitBuyConfirm = NamespacedKey<DawnTerminalCommandInfo>.Vanilla("greensuitbuyconfirm");

		public static NamespacedKey<DawnTerminalCommandInfo> HazardSuitBuyConfirm = NamespacedKey<DawnTerminalCommandInfo>.Vanilla("hazardsuitbuyconfirm");

		public static NamespacedKey<DawnTerminalCommandInfo> PajamaSuitBuyConfirm = NamespacedKey<DawnTerminalCommandInfo>.Vanilla("pajamasuitbuyconfirm");

		public static NamespacedKey<DawnTerminalCommandInfo> CozyLightsBuyConfirm = NamespacedKey<DawnTerminalCommandInfo>.Vanilla("cozylightsbuyconfirm");

		public static NamespacedKey<DawnTerminalCommandInfo> BuyStunGrenadeTwo = NamespacedKey<DawnTerminalCommandInfo>.Vanilla("buystungrenadetwo");

		public static NamespacedKey<DawnTerminalCommandInfo> BuyJetpackTwo = NamespacedKey<DawnTerminalCommandInfo>.Vanilla("buyjetpacktwo");

		public static NamespacedKey<DawnTerminalCommandInfo> TelevisionBuyConfirm = NamespacedKey<DawnTerminalCommandInfo>.Vanilla("televisionbuyconfirm");

		public static NamespacedKey<DawnTerminalCommandInfo> TeleporterBuyConfirm = NamespacedKey<DawnTerminalCommandInfo>.Vanilla("teleporterbuyconfirm");

		public static NamespacedKey<DawnTerminalCommandInfo> ShowerBuyConfirm = NamespacedKey<DawnTerminalCommandInfo>.Vanilla("showerbuyconfirm");

		public static NamespacedKey<DawnTerminalCommandInfo> ToiletBuyConfirm = NamespacedKey<DawnTerminalCommandInfo>.Vanilla("toiletbuyconfirm");

		public static NamespacedKey<DawnTerminalCommandInfo> RecordPlayerBuyConfirm = NamespacedKey<DawnTerminalCommandInfo>.Vanilla("recordplayerbuyconfirm");

		public static NamespacedKey<DawnTerminalCommandInfo> TableBuyConfirm = NamespacedKey<DawnTerminalCommandInfo>.Vanilla("tablebuyconfirm");

		public static NamespacedKey<DawnTerminalCommandInfo> RomTableBuyConfirm = NamespacedKey<DawnTerminalCommandInfo>.Vanilla("romtablebuyconfirm");

		public static NamespacedKey<DawnTerminalCommandInfo> BuyTZPTwo = NamespacedKey<DawnTerminalCommandInfo>.Vanilla("buytzptwo");

		public static NamespacedKey<DawnTerminalCommandInfo> LoudHornBuyConfirm = NamespacedKey<DawnTerminalCommandInfo>.Vanilla("loudhornbuyone");

		public static NamespacedKey<DawnTerminalCommandInfo> BuyExtensLadderTwo = NamespacedKey<DawnTerminalCommandInfo>.Vanilla("buyextensladdertwo");

		public static NamespacedKey<DawnTerminalCommandInfo> InverseTeleporterBuyConfirm = NamespacedKey<DawnTerminalCommandInfo>.Vanilla("inverseteleporterbuyconfirm");

		public static NamespacedKey<DawnTerminalCommandInfo> JackOLanternBuyConfirm = NamespacedKey<DawnTerminalCommandInfo>.Vanilla("jackolanternbuyconfirm");

		public static NamespacedKey<DawnTerminalCommandInfo> BuyRadarBoosterTwo = NamespacedKey<DawnTerminalCommandInfo>.Vanilla("buyradarboostertwo");

		public static NamespacedKey<DawnTerminalCommandInfo> WelcomeMatBuyConfirm = NamespacedKey<DawnTerminalCommandInfo>.Vanilla("welcomematbuyconfirm");

		public static NamespacedKey<DawnTerminalCommandInfo> FishBowlBuyConfirm = NamespacedKey<DawnTerminalCommandInfo>.Vanilla("fishbowlbuyconfirm");

		public static NamespacedKey<DawnTerminalCommandInfo> PlushiePajamaManBuyConfirm = NamespacedKey<DawnTerminalCommandInfo>.Vanilla("plushiepajamamanbuyconfirm");

		public static NamespacedKey<DawnTerminalCommandInfo> SignalTranslatorBuyConfirm = NamespacedKey<DawnTerminalCommandInfo>.Vanilla("signaltranslatorbuyconfirm");

		public static NamespacedKey<DawnTerminalCommandInfo> BuySpraypaintTwo = NamespacedKey<DawnTerminalCommandInfo>.Vanilla("buyspraypainttwo");

		public static NamespacedKey<DawnTerminalCommandInfo> PurpleSuitBuyConfirm = NamespacedKey<DawnTerminalCommandInfo>.Vanilla("purplesuitbuyconfirm");

		public static NamespacedKey<DawnTerminalCommandInfo> BeeSuitBuyConfirm = NamespacedKey<DawnTerminalCommandInfo>.Vanilla("beesuitbuyconfirm");

		public static NamespacedKey<DawnTerminalCommandInfo> BunnySuitBuyConfirm = NamespacedKey<DawnTerminalCommandInfo>.Vanilla("bunnysuitbuyconfirm");

		public static NamespacedKey<DawnTerminalCommandInfo> DiscoBallBuyConfirm = NamespacedKey<DawnTerminalCommandInfo>.Vanilla("discoballbuyconfirm");

		public static NamespacedKey<DawnTerminalCommandInfo> BuyCruiserTwo = NamespacedKey<DawnTerminalCommandInfo>.Vanilla("buycruisertwo");

		public static NamespacedKey<DawnTerminalCommandInfo> BuyWeedKillerTwo = NamespacedKey<DawnTerminalCommandInfo>.Vanilla("buyweedkillertwo");

		public static NamespacedKey<DawnTerminalCommandInfo> BuyBeltBagTwo = NamespacedKey<DawnTerminalCommandInfo>.Vanilla("buybeltbagtwo");

		public static NamespacedKey<DawnTerminalCommandInfo> MicrowaveBuyConfirm = NamespacedKey<DawnTerminalCommandInfo>.Vanilla("microwavebuyconfirm");

		public static NamespacedKey<DawnTerminalCommandInfo> SofaChairBuyConfirm = NamespacedKey<DawnTerminalCommandInfo>.Vanilla("sofachairbuyconfirm");

		public static NamespacedKey<DawnTerminalCommandInfo> FridgeBuyConfirm = NamespacedKey<DawnTerminalCommandInfo>.Vanilla("fridgebuyconfirm");

		public static NamespacedKey<DawnTerminalCommandInfo> ClassicPaintingBuyConfirm = NamespacedKey<DawnTerminalCommandInfo>.Vanilla("classicpaintingbuyconfirm");

		public static NamespacedKey<DawnTerminalCommandInfo> ElectricChairBuyConfirm = NamespacedKey<DawnTerminalCommandInfo>.Vanilla("electricchairbuyconfirm");

		public static NamespacedKey<DawnTerminalCommandInfo> DoghouseBuyConfirm = NamespacedKey<DawnTerminalCommandInfo>.Vanilla("doghousebuy");

		public static NamespacedKey<DawnTerminalCommandInfo> Info = NamespacedKey<DawnTerminalCommandInfo>.Vanilla("info");

		public static NamespacedKey<DawnTerminalCommandInfo> ChResetCredits = NamespacedKey<DawnTerminalCommandInfo>.Vanilla("ch_resetcredits");

		public static NamespacedKey<DawnTerminalCommandInfo> View = NamespacedKey<DawnTerminalCommandInfo>.Vanilla("view");

		public static NamespacedKey<DawnTerminalCommandInfo> Route = NamespacedKey<DawnTerminalCommandInfo>.Vanilla("route");

		public static NamespacedKey<DawnTerminalCommandInfo> ExperimentationRouteConfirm = NamespacedKey<DawnTerminalCommandInfo>.Vanilla("experimentationrouteconfirm");

		public static NamespacedKey<DawnTerminalCommandInfo> AdamanceRouteConfirm = NamespacedKey<DawnTerminalCommandInfo>.Vanilla("assurancerouteconfirm");

		public static NamespacedKey<DawnTerminalCommandInfo> VowRouteConfirm = NamespacedKey<DawnTerminalCommandInfo>.Vanilla("vowrouteconfirm");

		public static NamespacedKey<DawnTerminalCommandInfo> CompanyMoonRouteConfirm = NamespacedKey<DawnTerminalCommandInfo>.Vanilla("companymoonrouteconfirm");

		public static NamespacedKey<DawnTerminalCommandInfo> MarchRouteConfirm = NamespacedKey<DawnTerminalCommandInfo>.Vanilla("marchrouteconfirm");

		public static NamespacedKey<DawnTerminalCommandInfo> EmbrionRouteConfirm = NamespacedKey<DawnTerminalCommandInfo>.Vanilla("embrionrouteconfirm");

		public static NamespacedKey<DawnTerminalCommandInfo> DineRouteConfirm = NamespacedKey<DawnTerminalCommandInfo>.Vanilla("dinerouteconfirm");

		public static NamespacedKey<DawnTerminalCommandInfo> OffenseRouteConfirm = NamespacedKey<DawnTerminalCommandInfo>.Vanilla("offenserouteconfirm");

		public static NamespacedKey<DawnTerminalCommandInfo> TitanRouteConfirm = NamespacedKey<DawnTerminalCommandInfo>.Vanilla("titanrouteconfirm");

		public static NamespacedKey<DawnTerminalCommandInfo> BThree = NamespacedKey<DawnTerminalCommandInfo>.Vanilla("bthree");

		public static NamespacedKey<DawnTerminalCommandInfo> COne = NamespacedKey<DawnTerminalCommandInfo>.Vanilla("cone");

		public static NamespacedKey<DawnTerminalCommandInfo> CTwo = NamespacedKey<DawnTerminalCommandInfo>.Vanilla("ctwo");

		public static NamespacedKey<DawnTerminalCommandInfo> CSeven = NamespacedKey<DawnTerminalCommandInfo>.Vanilla("cseven");

		public static NamespacedKey<DawnTerminalCommandInfo> DSix = NamespacedKey<DawnTerminalCommandInfo>.Vanilla("dsix");

		public static NamespacedKey<DawnTerminalCommandInfo> FTwo = NamespacedKey<DawnTerminalCommandInfo>.Vanilla("ftwo");

		public static NamespacedKey<DawnTerminalCommandInfo> HFive = NamespacedKey<DawnTerminalCommandInfo>.Vanilla("hfive");

		public static NamespacedKey<DawnTerminalCommandInfo> IOne = NamespacedKey<DawnTerminalCommandInfo>.Vanilla("ione");

		public static NamespacedKey<DawnTerminalCommandInfo> JSix = NamespacedKey<DawnTerminalCommandInfo>.Vanilla("jsix");

		public static NamespacedKey<DawnTerminalCommandInfo> KNine = NamespacedKey<DawnTerminalCommandInfo>.Vanilla("knine");

		public static NamespacedKey<DawnTerminalCommandInfo> LZero = NamespacedKey<DawnTerminalCommandInfo>.Vanilla("lzero");

		public static NamespacedKey<DawnTerminalCommandInfo> MSix = NamespacedKey<DawnTerminalCommandInfo>.Vanilla("msix");

		public static NamespacedKey<DawnTerminalCommandInfo> MNine = NamespacedKey<DawnTerminalCommandInfo>.Vanilla("mnine");

		public static NamespacedKey<DawnTerminalCommandInfo> OFive = NamespacedKey<DawnTerminalCommandInfo>.Vanilla("ofive");

		public static NamespacedKey<DawnTerminalCommandInfo> POne = NamespacedKey<DawnTerminalCommandInfo>.Vanilla("pone");

		public static NamespacedKey<DawnTerminalCommandInfo> RTwo = NamespacedKey<DawnTerminalCommandInfo>.Vanilla("rtwo");

		public static NamespacedKey<DawnTerminalCommandInfo> RFour = NamespacedKey<DawnTerminalCommandInfo>.Vanilla("rfour");

		public static NamespacedKey<DawnTerminalCommandInfo> TTwo = NamespacedKey<DawnTerminalCommandInfo>.Vanilla("ttwo");

		public static NamespacedKey<DawnTerminalCommandInfo> UTwo = NamespacedKey<DawnTerminalCommandInfo>.Vanilla("utwo");

		public static NamespacedKey<DawnTerminalCommandInfo> UNine = NamespacedKey<DawnTerminalCommandInfo>.Vanilla("unine");

		public static NamespacedKey<DawnTerminalCommandInfo> VZero = NamespacedKey<DawnTerminalCommandInfo>.Vanilla("vzero");

		public static NamespacedKey<DawnTerminalCommandInfo> XEight = NamespacedKey<DawnTerminalCommandInfo>.Vanilla("xeight");

		public static NamespacedKey<DawnTerminalCommandInfo> YNine = NamespacedKey<DawnTerminalCommandInfo>.Vanilla("ynine");

		public static NamespacedKey<DawnTerminalCommandInfo> ZThree = NamespacedKey<DawnTerminalCommandInfo>.Vanilla("zthree");

		public static NamespacedKey<DawnTerminalCommandInfo> SwitchRadarCamPlayerOne = NamespacedKey<DawnTerminalCommandInfo>.Vanilla("switchradarcamplayerone");

		public static NamespacedKey<DawnTerminalCommandInfo> EjectPlayers = NamespacedKey<DawnTerminalCommandInfo>.Vanilla("eject_players");

		public static NamespacedKey<DawnTerminalCommandInfo>? GetByReflection(string name)
		{
			return (NamespacedKey<DawnTerminalCommandInfo>)(typeof(TerminalCommandKeys).GetField(name)?.GetValue(null));
		}
	}
}
namespace Dawn.Internal
{
	internal static class DawnConfig
	{
		public static ConfigEntry<CompatibilityBool> LethalConfigCompatibility;

		public static ConfigEntry<bool> VanillaCompatibility;

		public static ConfigEntry<bool> CreateTagExport;

		public static ConfigEntry<bool> DisableDawnItemSaving;

		public static ConfigEntry<bool> DisableDawnUnlockableSaving;

		public static ConfigEntry<bool> DisableAchievementsButton;

		public static ConfigEntry<bool> AllowLLLToOverrideVanillaStatus;

		public static ConfigEntry<bool> TerminalKeywordResolution;

		public static ConfigEntry<int> TerminalKeywordSpecificity;

		internal static void Bind(ConfigFile file)
		{
			VanillaCompatibility = file.CleanedBind("Compatibility", "Vanilla Compatibility", defaultValue: false, "Enable compatibility with vanilla");
			LethalConfigCompatibility = file.CleanedBind("Compatibility", "Extend LethalConfig Support", CompatibilityBool.IfVersionMatches, "Patches LethalConfig to enable raw editing of strings for unknown types.\nCurrent Targeted Version: 1.4.6");
			CreateTagExport = file.CleanedBind("Exports", "Tag Info Export", defaultValue: false, "Export a markdown file listing all tags?");
			DisableDawnItemSaving = file.CleanedBind("Dawn Save System", "Item Saving", defaultValue: false, "Disable the Dawn Save System for item saving");
			DisableDawnUnlockableSaving = file.CleanedBind("Dawn Save System", "Unlockable Saving", defaultValue: false, "Disable the Dawn Save System for unlockable saving");
			DisableAchievementsButton = file.CleanedBind("Achievements", "Disable Achievements Button", defaultValue: false, "Disable the Achievements Button from showing up in the main menu");
			AllowLLLToOverrideVanillaStatus = file.CleanedBind("Compatibility", "Allow LLL to Override Vanilla Moon Locked/Hidden Status", defaultValue: false, "Allow LLL to override the vanilla status of unlockables");
			TerminalKeywordResolution = file.CleanedBind("Terminal", "Keyword Resolution", defaultValue: true, "Dawnlib's terminal keyword resolution sytem to better handle conflicting keywords.");
			TerminalKeywordSpecificity = file.CleanedBind("Terminal", "Keyword Specificity", 3, "When Keyword Resolution is enabled, how many characters must match for a keyword to be considered a result for a given input in the terminal.", 0, 5);
		}
	}
	public class DawnDungeonNetworker : NetworkSingleton<DawnDungeonNetworker>
	{
		[CompilerGenerated]
		private sealed class <DoDungeonBundleLoading>d__14 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public DawnDungeonInfo dungeonInfo;

			public DawnDungeonNetworker <>4__this;

			private AssetBundleCreateRequest <request>5__2;

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

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

			[DebuggerHidden]
			public <DoDungeonBundleLoading>d__14(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<request>5__2 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_003b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0045: Expected O, but got Unknown
				int num = <>1__state;
				DawnDungeonNetworker dawnDungeonNetworker = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForSeconds(0.05f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					if (object.Equals(dungeonInfo.TypedKey, dawnDungeonNetworker._currentDungeonKey))
					{
						dawnDungeonNetworker.PlayerSetBundleStateRpc(GameNetworkManager.Instance.localPlayerController, DawnMoonNetworker.BundleState.Done);
						return false;
					}
					dawnDungeonNetworker._currentDungeonKey = dungeonInfo.TypedKey;
					if (!dungeonInfo.ShouldSkipIgnoreOverride())
					{
						if (!(dawnDungeonNetworker._currentBundlePath != dungeonInfo.AssetBundlePath))
						{
							break;
						}
						if ((Object)(object)dawnDungeonNetworker._currentBundle != (Object)null)
						{
							<>2__current = ((MonoBehaviour)dawnDungeonNetworker).StartCoroutine(dawnDungeonNetworker.UnloadExisting());
							<>1__state = 2;
							return true;
						}
						goto IL_00f1;
					}
					if ((Object)(object)dawnDungeonNetworker._currentBundle != (Object)null)
					{
						<>2__current = ((MonoBehaviour)dawnDungeonNetworker).StartCoroutine(dawnDungeonNetworker.UnloadExisting());
						<>1__state = 5;
						return true;
					}
					break;
				case 2:
					<>1__state = -1;
					goto IL_00f1;
				case 3:
					<>1__state = -1;
					<request>5__2 = AssetBundle.LoadFromFileAsync(dungeonInfo.AssetBundlePath);
					<>2__current = <request>5__2;
					<>1__state = 4;
					return true;
				case 4:
				{
					<>1__state = -1;
					DungeonFlow val = dawnDungeonNetworker.CheckDungeonBundleFailed(dungeonInfo, <request>5__2);
					if ((Object)(object)val == (Object)null)
					{
						dawnDungeonNetworker.PlayerSetBundleStateRpc(GameNetworkManager.Instance.localPlayerController, DawnMoonNetworker.BundleState.Error);
						return false;
					}
					dawnDungeonNetworker._currentBundlePath = dungeonInfo.AssetBundlePath;
					dawnDungeonNetworker._currentBundle = <request>5__2.assetBundle;
					dawnDungeonNetworker._currentlyLoadedDungeonFlow = val;
					<request>5__2 = null;
					break;
				}
				case 5:
					{
						<>1__state = -1;
						break;
					}
					IL_00f1:
					dawnDungeonNetworker.PlayerSetBundleStateRpc(GameNetworkManager.Instance.localPlayerController, DawnMoonNetworker.BundleState.Loading);
					<>2__current = null;
					<>1__state = 3;
					return true;
				}
				dawnDungeonNetworker.PlayerSetBundleStateRpc(GameNetworkManager.Instance.localPlayerController, DawnMoonNetworker.BundleState.Done);
				return false;
			}

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

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

		[CompilerGenerated]
		private sealed class <UnloadExisting>d__17 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public DawnDungeonNetworker <>4__this;

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

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

			[DebuggerHidden]
			public <UnloadExisting>d__17(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				int num = <>1__state;
				DawnDungeonNetworker dawnDungeonNetworker = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if ((Object)(object)dawnDungeonNetworker._currentBundle == (Object)null)
					{
						return false;
					}
					dawnDungeonNetworker.PlayerSetBundleStateRpc(GameNetworkManager.Instance.localPlayerController, DawnMoonNetworker.BundleState.Unloading);
					dawnDungeonNetworker.UnloadAndHandleFlow(dawnDungeonNetworker._currentBundle);
					<>2__current = dawnDungeonNetworker._currentBundle.UnloadAsync(true);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					dawnDungeonNetworker._currentBundle = null;
					dawnDungeonNetworker._currentBundlePath = null;
					<>2__current = Resources.UnloadUnusedAssets();
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					GC.Collect();
					return false;
				}
			}

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

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

		private Dictionary<PlayerControllerB, DawnMoonNetworker.BundleState> _playerStates = new Dictionary<PlayerControllerB, DawnMoonNetworker.BundleState>();

		private string? _currentBundlePath;

		private AssetBundle? _currentBundle;

		private DungeonFlow? _currentlyLoadedDungeonFlow;

		private DungeonFlow? _temporaryDungeonFlow;

		private NamespacedKey<DawnDungeonInfo> _currentDungeonKey;

		private static readonly List<GameObject> _objectsToUnregister = new List<GameObject>();

		internal bool allPlayersDone { get; private set; }

		internal void QueueDungeonBundleLoading(NamespacedKey dungeonKey)
		{
			DawnDungeonInfo dungeonInfo = LethalContent.Dungeons[dungeonKey.AsTyped<DawnDungeonInfo>()];
			_playerStates = new Dictionary<PlayerControllerB, DawnMoonNetworker.BundleState>();
			PlayerControllerB[] allPlayerScripts = StartOfRound.Instance.allPlayerScripts;
			foreach (PlayerControllerB val in allPlayerScripts)
			{
				if (val.isPlayerControlled)
				{
					_playerStates[val] = DawnMoonNetworker.BundleState.Queued;
				}
			}
			CheckReady();
			((MonoBehaviour)this).StartCoroutine(DoDungeonBundleLoading(dungeonInfo));
		}

		private static void SyncSpawnSyncedObjects(DawnDungeonInfo importantDungeonInfo, bool register)
		{
			if (importantDungeonInfo.ShouldSkipIgnoreOverride())
			{
				return;
			}
			NetworkManager.Singleton.NetworkConfig.ForceSamePrefabs = false;
			if (register)
			{
				List<GameObject> list = new List<GameObject>();
				foreach (NetworkPrefab prefab in NetworkManager.Singleton.NetworkConfig.Prefabs.Prefabs)
				{
					list.Add(prefab.Prefab);
				}
				foreach (SpawnSyncedObject spawnSyncedObject in importantDungeonInfo.SpawnSyncedObjects)
				{
					if ((Object)(object)spawnSyncedObject.spawnPrefab == (Object)null)
					{
						continue;
					}
					foreach (GameObject item in list)
					{
						if (((Object)spawnSyncedObject.spawnPrefab).name == ((Object)item).name)
						{
							Debuggers.Dungeons?.Log("Fixed SpawnSyncedObject: " + ((Object)spawnSyncedObject.spawnPrefab).name + " with reference");
							spawnSyncedObject.spawnPrefab = item;
							break;
						}
					}
				}
				foreach (SpawnSyncedObject spawnSyncedObject2 in importantDungeonInfo.SpawnSyncedObjects)
				{
					if (!((Object)(object)spawnSyncedObject2.spawnPrefab == (Object)null) && !((Object)(object)spawnSyncedObject2.spawnPrefab.GetComponent<NetworkObject>() == (Object)null) && !NetworkManager.Singleton.NetworkConfig.Prefabs.Contains(spawnSyncedObject2.spawnPrefab))
					{
						_objectsToUnregister.Add(spawnSyncedObject2.spawnPrefab);
						NetworkManager.Singleton.PrefabHandler.AddNetworkPrefab(spawnSyncedObject2.spawnPrefab);
						NetworkObject component = spawnSyncedObject2.spawnPrefab.GetComponent<NetworkObject>();
						DawnPlugin.Logger.LogDebug((object)("Registered network prefab '" + ((Object)spawnSyncedObject2.spawnPrefab).name + "' " + $"with hash={component.GlobalObjectIdHash} " + $"(IsServer={NetworkManager.Singleton.IsServer}, IsClient={NetworkManager.Singleton.IsClient})"));
					}
				}
			}
			else
			{
				foreach (GameObject item2 in _objectsToUnregister)
				{
					NetworkManager.Singleton.PrefabHandler.RemoveNetworkPrefab(item2);
				}
				_objectsToUnregister.Clear();
			}
			NetworkManager.Singleton.NetworkConfig.ForceSamePrefabs = true;
		}

		[Rpc(/*Could not decode attribute arguments.*/)]
		public void PlayerSetBundleStateRpc(PlayerControllerReference reference, DawnMoonNetworker.BundleState state)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Invalid comparison between Unknown and I4
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1)
			{
				RpcAttributeParams val = new RpcAttributeParams
				{
					RequireOwnership = false
				};
				RpcParams val2 = default(RpcParams);
				FastBufferWriter val3 = ((NetworkBehaviour)this).__beginSendRpc(3970644998u, val2, val, (SendTo)6, (RpcDelivery)0);
				bool flag = reference != null;
				((FastBufferWriter)(ref val3)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val3)).WriteValueSafe<PlayerControllerReference>(ref reference, default(ForNetworkSerializable));
				}
				((FastBufferWriter)(ref val3)).WriteValueSafe<DawnMoonNetworker.BundleState>(ref state, default(ForEnums));
				((NetworkBehaviour)this).__endSendRpc(ref val3, 3970644998u, val2, val, (SendTo)6, (RpcDelivery)0);
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1)
			{
				((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
				PlayerControllerB val4 = reference;
				_playerStates[reference] = state;
				CheckReady();
				if (state == DawnMoonNetworker.BundleState.Error)
				{
					DawnPlugin.Logger.LogError((object)("player: " + val4.playerUsername + " failed to load asset bundle!"));
				}
				Debuggers.Dungeons?.Log($"Player '{val4.playerUsername}' updated their bundle loading state to: {state}.");
			}
		}

		[IteratorStateMachine(typeof(<DoDungeonBundleLoading>d__14))]
		private IEnumerator DoDungeonBundleLoading(DawnDungeonInfo dungeonInfo)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <DoDungeonBundleLoading>d__14(0)
			{
				<>4__this = this,
				dungeonInfo = dungeonInfo
			};
		}

		private DungeonFlow? CheckDungeonBundleFailed(DawnDungeonInfo dungeonInfo, AssetBundleCreateRequest request)
		{
			if (!((AsyncOperation)request).isDone || (Object)(object)request.assetBundle == (Object)null)
			{
				return null;
			}
			AssetBundle assetBundle = request.assetBundle;
			DungeonFlow val = assetBundle.LoadAsset<DungeonFlow>(((Object)dungeonInfo.DungeonFlow).name ?? "");
			if ((Object)(object)val == (Object)null)
			{
				DawnPlugin.Logger.LogError((object)("Bundle: " + Path.GetFileName(dungeonInfo.AssetBundlePath) + " does not contain DungeonFlow: " + ((Object)dungeonInfo.DungeonFlow).name + "."));
				return null;
			}
			return val;
		}

		public override void OnNetworkDespawn()
		{
			base.OnNetworkDespawn();
			if (!((Object)(object)_currentBundle == (Object)null))
			{
				UnloadAndHandleFlow(_currentBundle);
				_currentBundle.Unload(true);
			}
		}

		[IteratorStateMachine(typeof(<UnloadExisting>d__17))]
		internal IEnumerator UnloadExisting()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <UnloadExisting>d__17(0)
			{
				<>4__this = this
			};
		}

		private void UnloadAndHandleFlow(AssetBundle currentBundle)
		{
			DawnDungeonInfo dawnDungeonInfo = LethalContent.Dungeons[_currentDungeonKey];
			DungeonFlow dungeonFlow = dawnDungeonInfo.DungeonFlow;
			if (DungeonGenerationPlusCompat.Enabled)
			{
				DungeonGenerationPlusCompat.HandleExtenderForBundle(currentBundle, dungeonFlow, register: false);
			}
			SyncSpawnSyncedObjects(dawnDungeonInfo, register: false);
			if ((Object)(object)_temporaryDungeonFlow != (Object)null)
			{
				SwapReferences(dungeonFlow, _temporaryDungeonFlow);
				Object.Destroy((Object)(object)_temporaryDungeonFlow);
				_temporaryDungeonFlow = null;
			}
			dawnDungeonInfo.sockets.Clear();
			dawnDungeonInfo.doorways.Clear();
			dawnDungeonInfo.spawnSyncedObjects.Clear();
			dawnDungeonInfo.tiles.Clear();
			_currentlyLoadedDungeonFlow = null;
			_currentDungeonKey = null;
		}

		private void CheckReady()
		{
			bool flag = _playerStates.Any<KeyValuePair<PlayerControllerB, DawnMoonNetworker.BundleState>>((KeyValuePair<PlayerControllerB, DawnMoonNetworker.BundleState> it) => it.Value == DawnMoonNetworker.BundleState.Error);
			int num = _playerStates.Count<KeyValuePair<PlayerControllerB, DawnMoonNetworker.BundleState>>((KeyValuePair<PlayerControllerB, DawnMoonNetworker.BundleState> it) => it.Value != DawnMoonNetworker.BundleState.Done);
			Debuggers.Dungeons?.Log(string.Format("Dungeon {0}. failed: {1}, remaining: {2}", "CheckReady", flag, num));
			Debuggers.Dungeons?.Log($"connected players amount: {_playerStates.Count}. done players = {_playerStates.Count<KeyValuePair<PlayerControllerB, DawnMoonNetworker.BundleState>>((KeyValuePair<PlayerControllerB, DawnMoonNetworker.BundleState> it) => it.Value == DawnMoonNetworker.BundleState.Done)}");
			if (num <= 0)
			{
				UnlockGame();
			}
			else
			{
				LockGame();
			}
		}

		private void LockGame()
		{
			allPlayersDone = false;
		}

		private void UnlockGame()
		{
			DungeonFlow val = TryApplyLoadedDungeonFlow(_currentlyLoadedDungeonFlow, _currentBundle);
			if ((Object)(object)val != (Object)null)
			{
				_temporaryDungeonFlow = val;
			}
			allPlayersDone = true;
		}

		internal static DungeonFlow? TryApplyLoadedDungeonFlow(DungeonFlow? loadedDungeonFlow, AssetBundle? sourceBundle = null)
		{
			if ((Object)(object)loadedDungeonFlow == (Object)null)
			{
				return null;
			}
			DungeonFlow val = null;
			foreach (DawnDungeonInfo value in LethalContent.Dungeons.Values)
			{
				if (((Object)value.DungeonFlow).name == ((Object)loadedDungeonFlow).name)
				{
					val = value.DungeonFlow;
					break;
				}
			}
			if ((Object)(object)val == (Object)null)
			{
				return null;
			}
			DungeonFlow val2 = ScriptableObject.CreateInstance<DungeonFlow>();
			SwapReferences(val2, val);
			SwapReferences(val, loadedDungeonFlow);
			ApplyDawnInfoToTileSets(val);
			ApplyDawnInfoToArchetypes(val);
			DawnDungeonInfo importantDungeonInfo = RebuildDungeonInfoCache(val);
			if (DungeonGenerationPlusCompat.Enabled && (Object)(object)sourceBundle != (Object)null)
			{
				DungeonGenerationPlusCompat.HandleExtenderForBundle(sourceBundle, val, register: true);
			}
			SyncSpawnSyncedObjects(importantDungeonInfo, register: true);
			return val2;
		}

		private static void ApplyDawnInfoToTileSets(DungeonFlow flow)
		{
			TileSet[] usedTileSets = flow.GetUsedTileSets();
			foreach (TileSet val in usedTileSets)
			{
				string text = ((Object)val).name.RemoveLeadingNumbers().ReplaceNumbersWithWords().Replace(" ", "_");
				Debuggers.Dungeons?.Log("tileSetName: " + ((Object)val).name);
				foreach (DawnTileSetInfo value in LethalContent.TileSets.Values)
				{
					Debuggers.Dungeons?.Log("tileSetInfo.Key.Key: " + value.Key.Key);
					if (!value.ShouldSkipIgnoreOverride() && text.Equals(value.Key.Key, StringComparison.InvariantCultureIgnoreCase))
					{
						val.SetDawnInfo(value);
						break;
					}
				}
			}
		}

		private static void ApplyDawnInfoToArchetypes(DungeonFlow flow)
		{
			DungeonArchetype[] usedArchetypes = flow.GetUsedArchetypes();
			foreach (DungeonArchetype val in usedArchetypes)
			{
				string text = ((Object)val).name.RemoveLeadingNumbers().ReplaceNumbersWithWords().Replace(" ", "_");
				Debuggers.Dungeons?.Log("archetypeName: " + text);
				foreach (DawnArchetypeInfo value in LethalContent.Archetypes.Values)
				{
					if (!value.ShouldSkipIgnoreOverride())
					{
						Debuggers.Dungeons?.Log("archetypeInfo.Key.Key: " + value.Key.Key);
						if (text.Equals(value.Key.Key, StringComparison.InvariantCultureIgnoreCase))
						{
							val.SetDawnInfo(value);
							break;
						}
					}
				}
			}
		}

		private static DawnDungeonInfo RebuildDungeonInfoCache(DungeonFlow flow)
		{
			DawnDungeonInfo dawnInfo = flow.GetDawnInfo();
			dawnInfo.sockets = new List<DoorwaySocket>();
			IEnumerable<TileSet> source = flow.TileInjectionRules.Select((TileInjectionRule it) => it.TileSet).Concat(flow.GetUsedTileSets()).Distinct();
			dawnInfo.tiles = source.Select((TileSet it) => it.TileWeights.Weights).SelectMany((List<GameObjectChance> it) => it).SelectMany((GameObjectChance it) => it.Value.GetComponentsInChildren<Tile>())
				.ToList();
			dawnInfo.doorways = new List<Doorway>();
			dawnInfo.spawnSyncedObjects = new List<SpawnSyncedObject>();
			foreach (Tile tile in dawnInfo.Tiles)
			{
				Doorway[] componentsInChildren = ((Component)tile).gameObject.GetComponentsInChildren<Doorway>();
				foreach (Doorway val in componentsInChildren)
				{
					if (!dawnInfo.Doorways.Contains(val))
					{
						dawnInfo.doorways.Add(val);
					}
					if (!dawnInfo.Sockets.Contains(val.socket))
					{
						dawnInfo.sockets.Add(val.socket);
					}
					AddSpawnSyncedObjectsFromWeights(dawnInfo, val.ConnectorPrefabWeights);
					AddSpawnSyncedObjectsFromWeights(dawnInfo, val.BlockerPrefabWeights);
				}
				SpawnSyncedObject[] componentsInChildren2 = ((Component)tile).gameObject.GetComponentsInChildren<SpawnSyncedObject>();
				foreach (SpawnSyncedObject val2 in componentsInChildren2)
				{
					if (!dawnInfo.SpawnSyncedObjects.Contains(val2))
					{
						dawnInfo.spawnSyncedObjects.Add(val2);
					}
				}
			}
			return dawnInfo;
		}

		private static void AddSpawnSyncedObjectsFromWeights(DawnDungeonInfo dungeonInfo, IEnumerable<GameObjectWeight> weights)
		{
			foreach (GameObjectWeight weight in weights)
			{
				SpawnSyncedObject[] componentsInChildren = weight.GameObject.GetComponentsInChildren<SpawnSyncedObject>();
				foreach (SpawnSyncedObject val in componentsInChildren)
				{
					if (!dungeonInfo.SpawnSyncedObjects.Contains(val))
					{
						dungeonInfo.spawnSyncedObjects.Add(val);
					}
				}
			}
		}

		private static void SwapReferences(DungeonFlow dungeonA, DungeonFlow dungeonB)
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			dungeonA.globalPropGroupID_obsolete = dungeonB.globalPropGroupID_obsolete;
			dungeonA.globalPropRanges_obsolete = dungeonB.globalPropRanges_obsolete;
			dungeonA.Length = dungeonB.Length;
			dungeonA.BranchMode = dungeonB.BranchMode;
			dungeonA.BranchCount = dungeonB.BranchCount;
			dungeonA.GlobalProps = dungeonB.GlobalProps;
			dungeonA.KeyManager = dungeonB.KeyManager;
			dungeonA.DoorwayConnectionChance = dungeonB.DoorwayConnectionChance;
			dungeonA.RestrictConnectionToSameSection = dungeonB.RestrictConnectionToSameSection;
			dungeonA.TileInjectionRules = dungeonB.TileInjectionRules;
			dungeonA.TileTagConnectionMode = dungeonB.TileTagConnectionMode;
			dungeonA.TileConnectionTags = dungeonB.TileConnectionTags;
			dungeonA.BranchTagPruneMode = dungeonB.BranchTagPruneMode;
			dungeonA.BranchPruneTags = dungeonB.BranchPruneTags;
			dungeonA.Nodes = dungeonB.Nodes;
			dungeonA.Lines = dungeonB.Lines;
			foreach (GraphNode node in dungeonA.Nodes)
			{
				node.Graph = dungeonA;
			}
			foreach (GraphLine line in dungeonA.Lines)
			{
				line.Graph = dungeonA;
			}
			dungeonA.currentFileVersion = dungeonB.currentFileVersion;
		}

		protected override void __initializeVariables()
		{
			base.__initializeVariables();
		}

		protected override void __initializeRpcs()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			((NetworkBehaviour)this).__registerRpc(3970644998u, new RpcReceiveHandler(__rpc_handler_3970644998), "PlayerSetBundleStateRpc");
			base.__initializeRpcs();
		}

		private static void __rpc_handler_3970644998(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: 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_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				bool flag = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
				PlayerControllerReference reference = null;
				if (flag)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe<PlayerControllerReference>(ref reference, default(ForNetworkSerializable));
				}
				DawnMoonNetworker.BundleState state = default(DawnMoonNetworker.BundleState);
				((FastBufferReader)(ref reader)).ReadValueSafe<DawnMoonNetworker.BundleState>(ref state, default(ForEnums));
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((DawnDungeonNetworker)(object)target).PlayerSetBundleStateRpc(reference, state);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		protected internal override string __getTypeName()
		{
			return "DawnDungeonNetworker";
		}
	}
	public class DawnMoonNetworker : NetworkSingleton<DawnMoonNetworker>
	{
		public enum BundleState
		{
			Queued,
			Unloading,
			Loading,
			Error,
			Done
		}

		[CompilerGenerated]
		private sealed class <DoMoonSceneLoading>d__21 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public DawnMoonInfo moonInfo;

			public DawnMoonNetworker <>4__this;

			public IMoonSceneInfo sceneInfo;

			private CustomMoonSceneInfo <customMoon>5__2;

			private AssetBundleCreateRequest <request>5__3;

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

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

			[DebuggerHidden]
			public <DoMoonSceneLoading>d__21(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<customMoon>5__2 = null;
				<request>5__3 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_003b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0045: Expected O, but got Unknown
				//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ee: Expected O, but got Unknown
				int num = <>1__state;
				DawnMoonNetworker dawnMoonNetworker = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForSeconds(0.05f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					if (object.Equals(moonInfo.TypedKey, dawnMoonNetworker._currentMoonKey) && object.Equals(sceneInfo.TypedKey, dawnMoonNetworker._currentSceneKey))
					{
						dawnMoonNetworker.PlayerSetBundleStateRpc(GameNetworkManager.Instance.localPlayerController, BundleState.Done);
						return false;
					}
					dawnMoonNetworker._currentMoonKey = moonInfo.TypedKey;
					dawnMoonNetworker._currentSceneKey = sceneInfo.TypedKey;
					StartOfRound.Instance.shipAnimator.runtimeAnimatorController = dawnMoonNetworker._originalAnimatorController;
					dawnMoonNetworker._animatorOverrideController = new AnimatorOverrideController(StartOfRound.Instance.shipAnimator.runtimeAnimatorController);
					StartOfRound.Instance.shipAnimator.runtimeAnimatorController = (RuntimeAnimatorController)(object)dawnMoonNetworker._animatorOverrideController;
					<customMoon>5__2 = sceneInfo as CustomMoonSceneInfo;
					if (<customMoon>5__2 != null)
					{
						dawnMoonNetworker.ReplaceShipAnimations(dawnMoonNetworker._originalShipLeaveClip, <customMoon>5__2.ShipTakeoffOverrideAnimation);
						dawnMoonNetworker.ReplaceShipAnimations(dawnMoonNetworker._originalShipLandClip, <customMoon>5__2.ShipLandingOverrideAnimation);
						if (!(dawnMoonNetworker._currentBundlePath != <customMoon>5__2.AssetBundlePath))
						{
							break;
						}
						if ((Object)(object)dawnMoonNetworker._currentBundle != (Object)null)
						{
							<>2__current = ((MonoBehaviour)dawnMoonNetworker).StartCoroutine(dawnMoonNetworker.UnloadExisting());
							<>1__state = 2;
							return true;
						}
						goto IL_0198;
					}
					if ((Object)(object)dawnMoonNetworker._currentBundle != (Object)null)
					{
						<>2__current = ((MonoBehaviour)dawnMoonNetworker).StartCoroutine(dawnMoonNetworker.UnloadExisting());
						<>1__state = 5;
						return true;
					}
					break;
				case 2:
					<>1__state = -1;
					goto IL_0198;
				case 3:
					<>1__state = -1;
					<request>5__3 = AssetBundle.LoadFromFileAsync(<customMoon>5__2.AssetBundlePath);
					<>2__current = <request>5__3;
					<>1__state = 4;
					return true;
				case 4:
					<>1__state = -1;
					if (dawnMoonNetworker.CheckMoonBundleFailed(<customMoon>5__2, <request>5__3))
					{
						dawnMoonNetworker.PlayerSetBundleStateRpc(GameNetworkManager.Instance.localPlayerController, BundleState.Error);
						return false;
					}
					dawnMoonNetworker._currentBundlePath = <customMoon>5__2.AssetBundlePath;
					dawnMoonNetworker._currentBundle = <request>5__3.assetBundle;
					<request>5__3 = null;
					break;
				case 5:
					{
						<>1__state = -1;
						break;
					}
					IL_0198:
					dawnMoonNetworker.PlayerSetBundleStateRpc(GameNetworkManager.Instance.localPlayerController, BundleState.Loading);
					<>2__current = null;
					<>1__state = 3;
					return true;
				}
				dawnMoonNetworker.PlayerSetBundleStateRpc(GameNetworkManager.Instance.localPlayerController, BundleState.Done);
				return false;
			}

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

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

		[CompilerGenerated]
		private sealed class <UnloadExisting>d__25 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public DawnMoonNetworker <>4__this;

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

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

			[DebuggerHidden]
			public <UnloadExisting>d__25(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				int num = <>1__state;
				DawnMoonNetworker dawnMoonNetworker = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					if ((Object)(object)dawnMoonNetworker._currentBundle == (Object)null)
					{
						return false;
					}
					dawnMoonNetworker.PlayerSetBundleStateRpc(GameNetworkManager.Instance.localPlayerController, BundleState.Unloading);
					<>2__current = dawnMoonNetworker._currentBundle.UnloadAsync(true);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					dawnMoonNetworker._currentBundle = null;
					dawnMoonNetworker._currentBundlePath = null;
					return false;
				}
			}

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

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

		[CompilerGenerated]
		private sealed class <UnlockLever>d__28 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public DawnMoonNetworker <>4__this;

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

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

			[DebuggerHidden]
			public <UnlockLever>d__28(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0061: Unknown result type (might be due to invalid IL or missing references)
				//IL_006b: Expected O, but got Unknown
				int num = <>1__state;
				DawnMoonNetworker dawnMoonNetworker = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					dawnMoonNetworker.allPlayersDone = true;
					StartMatchLeverRefs.Instance.triggerScript.disabledHoverTip = dawnMoonNetworker._previousDisabledTooltip;
					dawnMoonNetworker._previousDisabledTooltip = null;
					<>2__current = (object)new WaitUntil((Func<bool>)(() => StartOfRound.Instance.shipTravelCoroutine == null || ((Behaviour)StartOfRound.Instance.screenLevelDescription).enabled));
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					StartOfRound.Instance.shipTravelCoroutine = null;
					StartMatchLeverRefs.Instance.triggerScript.interactable = true;
					if (!((NetworkBehaviour)dawnMoonNetworker).IsServer && !GameNetworkManager.Instance.gameHasStarted)
					{
						StartMatchLeverRefs.Instance.triggerScript.disabledHoverTip = "[ Waiting for host to start game ]";
						StartMatchLeverRefs.Instance.triggerScript.interactable = false;
					}
					if ((Object)(object)StartOfRound.Instance.currentLevel.videoReel != (Object)null)
					{
						StartOfRound.Instance.screenLevelVideoReel.clip = LethalContent.Moons[dawnMoonNetworker._currentMoonKey.AsTyped<DawnMoonInfo>()].Level.videoReel;
						((Behaviour)StartOfRound.Instance.screenLevelVideoReel).enabled = true;
						((Component)StartOfRound.Instance.screenLevelVideoReel).gameObject.SetActive(true);
						StartOfRound.Instance.screenLevelVideoReel.Play();
					}
					((Behaviour)StartOfRound.Instance.screenLevelDescription).enabled = true;
					Debuggers.Moons?.Log("Disabling RouteProgressUI.");
					((Component)Singleton<RouteProgressUI>.Instance).gameObject.SetActive(false);
					return false;
				}
			}

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

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

		private Dictionary<PlayerControllerB, BundleState> _playerStates = new Dictionary<PlayerControllerB, BundleState>();

		private string? _currentBundlePath;

		private AssetBundle? _currentBundle;

		private NamespacedKey<DawnMoonInfo> _currentMoonKey;

		private NamespacedKey<IMoonSceneInfo> _currentSceneKey;

		private string? _previousDisabledTooltip;

		private AnimatorOverrideController _animatorOverrideController;

		private RuntimeAnimatorController _originalAnimatorController;

		private AnimationClip _originalShipLandClip;

		private AnimationClip _originalShipLeaveClip;

		internal bool allPlayersDone { get; private set; }

		public override void OnNetworkSpawn()
		{
			base.OnNetworkSpawn();
			_originalAnimatorController = StartOfRoundRefs.Instance.shipAnimator.runtimeAnimatorController;
			AnimationClip[] animationClips = StartOfRoundRefs.Instance.shipAnimator.runtimeAnimatorController.animationClips;
			foreach (AnimationClip val in animationClips)
			{
				if (((Object)val).name == "HangarShipLandB")
				{
					_originalShipLandClip = val;
				}
				else if (((Object)val).name == "ShipLeave")
				{
					_originalShipLeaveClip = val;
				}
			}
		}

		internal void HostDecide(DawnMoonInfo moonInfo)
		{
			SpawnWeightContext ctx = new SpawnWeightContext(moonInfo, null, TimeOfDayRefs.GetCurrentWeatherEffect(moonInfo.Level)?.GetDawnInfo()).WithExtra(SpawnWeightExtraKeys.RoutingPriceKey, moonInfo.DawnPurchaseInfo.Cost.Provide());
			int maxValue = moonInfo.Scenes.Sum((IMoonSceneInfo it) => it.Weight.GetFor(in ctx).GetValueOrDefault().Clamp0());
			Random random = new Random(StartOfRoundRefs.Instance.randomMapSeed + 502);
			int num = random.Next(0, maxValue);
			IMoonSceneInfo moonSceneInfo = moonInfo.Scenes[0];
			for (int i = 0; i < moonInfo.Scenes.Count; i++)
			{
				moonSceneInfo = moonInfo.Scenes[i];
				num -= moonSceneInfo.Weight.GetFor(in ctx).GetValueOrDefault().Clamp0();
				if (num <= 0)
				{
					break;
				}
			}
			moonInfo.Level.sceneName = moonSceneInfo.SceneName;
			QueueMoonSceneLoadingServerRpc(moonInfo.Key, moonSceneInfo.Key);
		}

		internal void HostRebroadcastQueue()
		{
			QueueMoonSceneLoadingServerRpc(_currentMoonKey, _currentSceneKey);
		}

		[ServerRpc]
		private void QueueMoonSceneLoadingServerRpc(NamespacedKey moonKey, NamespacedKey sceneKey)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0168: Unknown result type (might be due to invalid IL or missing references)
			//IL_0172: Invalid comparison between Unknown and I4
			//IL_019d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Invalid comparison between Unknown and I4
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				if (((NetworkBehaviour)this).OwnerClientId != networkManager.LocalClientId)
				{
					if ((int)networkManager.LogLevel <= 1)
					{
						Debug.LogError((object)"Only the owner can invoke a ServerRpc that requires ownership!");
					}
					return;
				}
				ServerRpcParams val = default(ServerRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(1673613662u, val, (RpcDelivery)0);
				bool flag = moonKey != null;
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val2)).WriteValueSafe<NamespacedKey>(ref moonKey, default(ForNetworkSerializable));
				}
				bool flag2 = sceneKey != null;
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref flag2, default(ForPrimitives));
				if (flag2)
				{
					((FastBufferWriter)(ref val2)).WriteValueSafe<NamespacedKey>(ref sceneKey, default(ForNetworkSerializable));
				}
				((NetworkBehaviour)this).__endSendServerRpc(ref val2, 1673613662u, val, (RpcDelivery)0);
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
				QueueMoonSceneLoadingClientRpc(moonKey, sceneKey);
			}
		}

		[ClientRpc]
		private void QueueMoonSceneLoadingClientRpc(NamespacedKey moonKey, NamespacedKey sceneKey)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0157: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(3547185543u, val, (RpcDelivery)0);
				bool flag = moonKey != null;
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val2)).WriteValueSafe<NamespacedKey>(ref moonKey, default(ForNetworkSerializable));
				}
				bool flag2 = sceneKey != null;
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref flag2, default(ForPrimitives));
				if (flag2)
				{
					((FastBufferWriter)(ref val2)).WriteValueSafe<NamespacedKey>(ref sceneKey, default(ForNetworkSerializable));
				}
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 3547185543u, val, (RpcDelivery)0);
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 || (!networkManager.IsClient && !networkManager.IsHost))
			{
				return;
			}
			((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
			NamespacedKey sceneKey2 = sceneKey;
			DawnMoonInfo dawnMoonInfo = LethalContent.Moons[moonKey.AsTyped<DawnMoonInfo>()];
			IMoonSceneInfo sceneInfo = dawnMoonInfo.Scenes.First((IMoonSceneInfo it) => object.Equals(it.Key, sceneKey2));
			_playerStates = new Dictionary<PlayerControllerB, BundleState>();
			PlayerControllerB[] allPlayerScripts = StartOfRound.Instance.allPlayerScripts;
			foreach (PlayerControllerB val3 in allPlayerScripts)
			{
				if (val3.isPlayerControlled)
				{
					_playerStates[val3] = BundleState.Queued;
				}
			}
			Singleton<RouteProgressUI>.Instance.Setup(dawnMoonInfo.Level.PlanetName);
			CheckReadyAndUpdateUI();
			((MonoBehaviour)this).StartCoroutine(DoMoonSceneLoading(dawnMoonInfo, sceneInfo));
		}

		[Rpc(/*Could not decode attribute arguments.*/)]
		public void PlayerSetBundleStateRpc(PlayerControllerReference reference, BundleState state)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Invalid comparison between Unknown and I4
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1)
			{
				RpcAttributeParams val = new RpcAttributeParams
				{
					RequireOwnership = false
				};
				RpcParams val2 = default(RpcParams);
				FastBufferWriter val3 = ((NetworkBehaviour)this).__beginSendRpc(1144476733u, val2, val, (SendTo)6, (RpcDelivery)0);
				bool flag = reference != null;
				((FastBufferWriter)(ref val3)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val3)).WriteValueSafe<PlayerControllerReference>(ref reference, default(ForNetworkSerializable));
				}
				((FastBufferWriter)(ref val3)).WriteValueSafe<BundleState>(ref state, default(ForEnums));
				((NetworkBehaviour)this).__endSendRpc(ref val3, 1144476733u, val2, val, (SendTo)6, (RpcDelivery)0);
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1)
			{
				((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
				PlayerControllerB val4 = reference;
				_playerStates[reference] = state;
				CheckReadyAndUpdateUI();
				if (state == BundleState.Error)
				{
					DawnPlugin.Logger.LogError((object)("player: " + val4.playerUsername + " failed to load asset bundle!"));
				}
				Debuggers.Moons?.Log($"Player '{val4.playerUsername}' updated their bundle loading state to: {state}.");
			}
		}

		[IteratorStateMachine(typeof(<DoMoonSceneLoading>d__21))]
		private IEnumerator DoMoonSceneLoading(DawnMoonInfo moonInfo, IMoonSceneInfo sceneInfo)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <DoMoonSceneLoading>d__21(0)
			{
				<>4__this = this,
				moonInfo = moonInfo,
				sceneInfo = sceneInfo
			};
		}

		private bool CheckMoonBundleFailed(CustomMoonSceneInfo sceneInfo, AssetBundleCreateRequest request)
		{
			if (!((AsyncOperation)request).isDone || (Object)(object)request.assetBundle == (Object)null)
			{
				return true;
			}
			AssetBundle assetBundle = request.assetBundle;
			if (!assetBundle.isStreamedSceneAssetBundle)
			{
				DawnPlugin.Logger.LogError((object)("Bundle: " + Path.GetFileName(sceneInfo.AssetBundlePath) + " (should contain scene: " + sceneInfo.SceneName + ") is not a scene bundle?"));
				return true;
			}
			if (!assetBundle.GetAllScenePaths().Contains(sceneInfo.ScenePath))
			{
				DawnPlugin.Logger.LogError((object)("Bundle: " + Path.GetFileName(sceneInfo.AssetBundlePath) + " does not contain scene: " + sceneInfo.SceneName + "."));
				DawnPlugin.Logger.LogError((object)"If the scene was moved/renamed, you may need to reassign it in the editor.");
				return true;
			}
			return false;
		}

		public void ReplaceShipAnimations(AnimationClip originalClip, AnimationClip? newClip)
		{
			_animatorOverrideController[originalClip] = newClip;
		}

		public override void OnNetworkDespawn()
		{
			base.OnNetworkDespawn();
			AssetBundle? currentBundle = _currentBundle;
			if (currentBundle != null)
			{
				currentBundle.Unload(true);
			}
			_currentBundle = null;
			_currentBundlePath = null;
		}

		[IteratorStateMachine(typeof(<UnloadExisting>d__25))]
		private IEnumerator UnloadExisting()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <UnloadExisting>d__25(0)
			{
				<>4__this = this
			};
		}

		private void CheckReadyAndUpdateUI()
		{
			Singleton<RouteProgressUI>.Instance.Refresh(_playerStates);
			bool flag = _playerStates.Any<KeyValuePair<PlayerControllerB, BundleState>>((KeyValuePair<PlayerControllerB, BundleState> it) => it.Value == BundleState.Error);
			int num = _playerStates.Count<KeyValuePair<PlayerControllerB, BundleState>>((KeyValuePair<PlayerControllerB, BundleState> it) => it.Value != BundleState.Done);
			Debuggers.Moons?.Log(string.Format("Moon {0}. failed: {1}, remaining: {2}", "CheckReadyAndUpdateUI", flag, num));
			Debuggers.Moons?.Log($"connected players amount: {_playerStates.Count}. done players = {_playerStates.Count<KeyValuePair<PlayerControllerB, BundleState>>((KeyValuePair<PlayerControllerB, BundleState> it) => it.Value == BundleState.Done)}");
			if (num <= 0)
			{
				((MonoBehaviour)this).StartCoroutine(UnlockLever());
				return;
			}
			LockLever();
			if (flag)
			{
				StartMatchLeverRefs.Instance.triggerScript.disabledHoverTip = " [ Someone failed to pre-load the moon, report this! ] ";
			}
			else
			{
				StartMatchLeverRefs.Instance.triggerScript.disabledHoverTip = $" [ {num} player(s) still need to load ] ";
			}
		}

		private void LockLever()
		{
			if (_previousDisabledTooltip == null)
			{
				_previousDisabledTooltip = StartMatchLeverRefs.Instance.triggerScript.disabledHoverTip;
			}
			((Behaviour)StartOfRound.Instance.screenLevelVideoReel).enabled = false;
			((Component)StartOfRound.Instance.screenLevelVideoReel).gameObject.SetActive(false);
			StartOfRound.Instance.screenLevelVideoReel.Stop();
			((Behaviour)StartOfRound.Instance.screenLevelDescription).enabled = false;
			((Component)Singleton<RouteProgressUI>.Instance).gameObject.SetActive(true);
			Debuggers.Moons?.Log("Enabling RouteProgressUI.");
			StartMatchLeverRefs.Instance.triggerScript.interactable = false;
			allPlayersDone = false;
		}

		[IteratorStateMachine(typeof(<UnlockLever>d__28))]
		private IEnumerator UnlockLever()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <UnlockLever>d__28(0)
			{
				<>4__this = this
			};
		}

		protected override void __initializeVariables()
		{
			base.__initializeVariables();
		}

		protected override void __initializeRpcs()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Expected O, but got Unknown
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Expected O, but got Unknown
			((NetworkBehaviour)this).__registerRpc(1673613662u, new RpcReceiveHandler(__rpc_handler_1673613662), "QueueMoonSceneLoadingServerRpc");
			((NetworkBehaviour)this).__registerRpc(3547185543u, new RpcReceiveHandler(__rpc_handler_3547185543), "QueueMoonSceneLoadingClientRpc");
			((NetworkBehaviour)this).__registerRpc(1144476733u, new RpcReceiveHandler(__rpc_handler_1144476733), "PlayerSetBundleStateRpc");
			base.__initializeRpcs();
		}

		private static void __rpc_handler_1673613662(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Invalid comparison between Unknown and I4
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if (rpcParams.Server.Receive.SenderClientId != target.OwnerClientId)
			{
				if ((int)networkManager.LogLevel <= 1)
				{
					Debug.LogError((object)"Only the owner can invoke a ServerRpc that requires ownership!");
				}
				return;
			}
			bool flag = default(bool);
			((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
			NamespacedKey moonKey = null;
			if (flag)
			{
				((FastBufferReader)(ref reader)).ReadValueSafe<NamespacedKey>(ref moonKey, default(ForNetworkSerializable));
			}
			bool flag2 = default(bool);
			((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag2, default(ForPrimitives));
			NamespacedKey sceneKey = null;
			if (flag2)
			{
				((FastBufferReader)(ref reader)).ReadValueSafe<NamespacedKey>(ref sceneKey, default(ForNetworkSerializable));
			}
			target.__rpc_exec_stage = (__RpcExecStage)1;
			((DawnMoonNetworker)(object)target).QueueMoonSceneLoadingServerRpc(moonKey, sceneKey);
			target.__rpc_exec_stage = (__RpcExecStage)0;
		}

		private static void __rpc_handler_3547185543(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: 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_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				bool flag = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
				NamespacedKey moonKey = null;
				if (flag)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe<NamespacedKey>(ref moonKey, default(ForNetworkSerializable));
				}
				bool flag2 = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag2, default(ForPrimitives));
				NamespacedKey sceneKey = null;
				if (flag2)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe<NamespacedKey>(ref sceneKey, default(ForNetworkSerializable));
				}
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((DawnMoonNetworker)(object)target).QueueMoonSceneLoadingClientRpc(moonKey, sceneKey);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1144476733(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: 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_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				bool flag = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
				PlayerControllerReference reference = null;
				if (flag)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe<PlayerControllerReference>(ref reference, default(ForNetworkSerializable));
				}
				BundleState state = default(BundleState);
				((FastBufferReader)(ref reader)).ReadValueSafe<BundleState>(ref state, default(ForEnums));
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((DawnMoonNetworker)(object)target).PlayerSetBundleStateRpc(reference, state);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		protected internal override string __getTypeName()
		{
			return "DawnMoonNetworker";
		}
	}
	public class DawnNetworker : NetworkSingleton<DawnNetworker>
	{
		internal PersistentDataContainer SaveContainer { get; private set; }

		internal PersistentDataContainer ContractContainer { get; private set; }

		internal event Action OnSave = delegate
		{
		};

		private void Awake()
		{
			string currentSaveFileName = GameNetworkManager.Instance.currentSaveFileName;
			SaveContainer = CreateSaveContainer(currentSaveFileName);
			ContractContainer = CreateContractContainer(currentSaveFileName);
		}

		private void Start()
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected O, but got Unknown
			((UnityEvent)StartOfRoundRefs.Instance.StartNewRoundEvent).AddListener(new UnityAction(ResetDawnEnemies));
		}

		private void ResetDawnEnemies()
		{
			foreach (DawnEnemyInfo value in LethalContent.Enemies.Values)
			{
				if (!value.ShouldSkipRespectOverride())
				{
					value.EnemyType.numberSpawned = 0;
					value.EnemyType.hasSpawnedAtLeastOne = false;
				}
			}
		}

		internal static PersistentDataContainer CreateSaveContainer(string id)
		{
			return new PersistentDataContainer(Path.Combine(PersistentDataHandler.RootPath, "Save" + id));
		}

		internal static PersistentDataContainer CreateContractContainer(string id)
		{
			return new PersistentDataContainer(Path.Combine(PersistentDataHandler.RootPath, "Contract" + id));
		}

		internal void SaveData()
		{
			this.OnSave();
			if (NetworkManager.Singleton.IsHost)
			{
				if (!DawnConfig.DisableDawnItemSaving.Value)
				{
					ItemSaveDataHandler.SaveAllItems(DawnLib.GetCurrentContract());
				}
				if (!DawnConfig.DisableDawnUnlockableSaving.Value)
				{
					UnlockableSaveDataHandler.SaveAllUnlockables(DawnLib.GetCurrentContract());
				}
			}
		}

		[Rpc(/*Could not decode attribute arguments.*/)]
		internal void RequestWeatherSyncRpc(LevelWeatherType[] levelWeatherTypes, ulong clientId)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Invalid comparison between Unknown and I4
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: 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_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0153: Unknown result type (might be due to invalid IL or missing references)
			//IL_0157: Unknown result type (might be due to invalid IL or missing references)
			//IL_015c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0169: Unknown result type (might be due to invalid IL or missing references)
			//IL_016f: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1)
			{
				RpcAttributeParams val = new RpcAttributeParams
				{
					RequireOwnership = false
				};
				RpcParams val2 = default(RpcParams);
				FastBufferWriter val3 = ((NetworkBehaviour)this).__beginSendRpc(658108314u, val2, val, (SendTo)2, (RpcDelivery)0);
				bool flag = levelWeatherTypes != null;
				((FastBufferWriter)(ref val3)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val3)).WriteValueSafe<LevelWeatherType>(levelWeatherTypes, default(ForEnums));
				}
				BytePacker.WriteValueBitPacked(val3, clientId);
				((NetworkBehaviour)this).__endSendRpc(ref val3, 658108314u, val2, val, (SendTo)2, (RpcDelivery)0);
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1)
			{
				return;
			}
			((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
			BaseRpcTarget val4 = ((NetworkBehaviour)this).RpcTarget.Single(clientId, (RpcTargetUse)1);
			foreach (var item3 in LethalContent.Moons.Values.WithIndex())
			{
				int item = item3.index;
				DawnMoonInfo item2 = item3.value;
				SelectableLevel level = item2.Level;
				LevelWeatherType val5 = levelWeatherTypes[item];
				if (level.currentWeather != val5)
				{
					ChangeWeatherToRpc(item2.Key, level.currentWeather, RpcParams.op_Implicit(val4));
				}
			}
			val4.Dispose();
		}

		[Rpc(/*Could not decode attribute arguments.*/)]
		internal void ChangeWeatherToRpc(NamespacedKey moonKey, LevelWeatherType levelWeatherType, RpcParams rpcParams = default(RpcParams))
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Invalid comparison between Unknown and I4
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: 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)
			//IL_0126: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: 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_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1)
			{
				RpcAttributeParams val = default(RpcAttributeParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendRpc(2516882614u, rpcParams, val, (SendTo)8, (RpcDelivery)0);
				bool flag = moonKey != null;
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val2)).WriteValueSafe<NamespacedKey>(ref moonKey, default(ForNetworkSerializable));
				}
				((FastBufferWriter)(ref val2)).WriteValueSafe<LevelWeatherType>(ref levelWeatherType, default(ForEnums));
				((NetworkBehaviour)this).__endSendRpc(ref val2, 2516882614u, rpcParams, val, (SendTo)8, (RpcDelivery)0);
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1)
			{
				((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
				LethalContent.Moons[moonKey.AsTyped<DawnMoonInfo>()].Level.currentWeather = levelWeatherType;
				StartOfRoundRefs.Instance.SetMapScreenInfoToCurrentLevel();
			}
		}

		[ServerRpc(RequireOwnership = false)]
		public void BroadcastDisplayTipServerRpc(HUDDisplayTip displayTip)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				ServerRpcParams val = default(ServerRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(1933237721u, val, (RpcDelivery)0);
				bool flag = displayTip != null;
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val2)).WriteValueSafe<HUDDisplayTip>(ref displayTip, default(ForNetworkSerializable));
				}
				((NetworkBehaviour)this).__endSendServerRpc(ref val2, 1933237721u, val, (RpcDelivery)0);
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
				BroadcastDisplayTipClientRpc(displayTip);
			}
		}

		[ClientRpc]
		public void BroadcastDisplayTipClientRpc(HUDDisplayTip displayTip)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(1536023893u, val, (RpcDelivery)0);
				bool flag = displayTip != null;
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val2)).WriteValueSafe<HUDDisplayTip>(ref displayTip, default(ForNetworkSerializable));
				}
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 1536023893u, val, (RpcDelivery)0);
			}
			if ((int)((NetworkBehaviour)this).__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				((NetworkBehaviour)this).__rpc_exec_stage = (__RpcExecStage)0;
				HUDManager.Instance.DisplayTip(displayTip);
			}
		}

		protected override void __initializeVariables()
		{
			base.__initializeVariables();
		}

		protected override void __initializeRpcs()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Expected O, but got Unknown
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Expected O, but got Unknown
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Expected O, but got Unknown
			((NetworkBehaviour)this).__registerRpc(658108314u, new RpcReceiveHandler(__rpc_handler_658108314), "RequestWeatherSyncRpc");
			((NetworkBehaviour)this).__registerRpc(2516882614u, new RpcReceiveHandler(__rpc_handler_2516882614), "ChangeWeatherToRpc");
			((NetworkBehaviour)this).__registerRpc(1933237721u, new RpcReceiveHandler(__rpc_handler_1933237721), "BroadcastDisplayTipServerRpc");
			((NetworkBehaviour)this).__registerRpc(1536023893u, new RpcReceiveHandler(__rpc_handler_1536023893), "BroadcastDisplayTipClientRpc");
			base.__initializeRpcs();
		}

		private static void __rpc_handler_658108314(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: 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_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				bool flag = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
				LevelWeatherType[] levelWeatherTypes = null;
				if (flag)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe<LevelWeatherType>(ref levelWeatherTypes, default(ForEnums));
				}
				ulong clientId = default(ulong);
				ByteUnpacker.ReadValueBitPacked(reader, ref clientId);
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((DawnNetworker)(object)target).RequestWeatherSyncRpc(levelWeatherTypes, clientId);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_2516882614(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: 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_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				bool flag = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
				NamespacedKey moonKey = null;
				if (flag)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe<NamespacedKey>(ref moonKey, default(ForNetworkSerializable));
				}
				LevelWeatherType levelWeatherType = default(LevelWeatherType);
				((FastBufferReader)(ref reader)).ReadValueSafe<LevelWeatherType>(ref levelWeatherType, default(ForEnums));
				RpcParams ext = rpcParams.Ext;
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((DawnNetworker)(object)target).ChangeWeatherToRpc(moonKey, levelWeatherType, ext);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1933237721(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: 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_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				bool flag = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
				HUDDisplayTip displayTip = null;
				if (flag)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe<HUDDisplayTip>(ref displayTip, default(ForNetworkSerializable));
				}
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((DawnNetworker)(object)target).BroadcastDisplayTipServerRpc(displayTip);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_1536023893(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: 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_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				bool flag = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
				HUDDisplayTip displayTip = null;
				if (flag)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe<HUDDisplayTip>(ref displayTip, default(ForNetworkSerializable));
				}
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((DawnNetworker)(object)target).BroadcastDisplayTipClientRpc(displayTip);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		protected internal override string __getTypeName()
		{
			return "DawnNetworker";
		}
	}
	internal static class Debuggers
	{
		internal static DebugLogSource? ReplaceThis;

		internal static DebugLogSource? Configs;

		internal static DebugLogSource? EntityReplacements;

		internal static DebugLogSource? Sounds;

		internal static DebugLogSource? Weathers;

		internal static DebugLogSource? Enemies;

		internal static DebugLogSource? Moons;

		internal static DebugLogSource? Items;

		internal static DebugLogSource? MapObjects;

		internal static DebugLogSource? Unlockables;

		internal static DebugLogSource? AssetLoading;

		internal static DebugLogSource? Weights;

		internal static DebugLogSource? Achievements;

		internal static DebugLogSource? Dusk;

		internal static DebugLogSource? Progressive;

		internal static DebugLogSource? ExtendedTOML;

		internal static DebugLogSource? LethalConfig;

		internal static DebugLogSource? Pathfinding;

		internal static DebugLogSource? Tags;

		internal static DebugLogSource? Dungeons;

		internal static DebugLogSource? Patching;

		internal static DebugLogSource? PersistentDataContainer;

		internal static DebugLogSource? SceneManager;

		internal static DebugLogSource? SaveManager;

		internal static DebugLogSource? NamespacedKeys;

		internal static DebugLogSource? StoryLogs;

		internal static DebugLogSource? Terminal;

		internal static void Bind(ConfigFile file)
		{
			FieldInfo[] fields = typeof(Debuggers).GetFields(BindingFlags.Static | BindingFlags.NonPublic);
			foreach (FieldInfo fieldInfo in fields)
			{
				if (file.Bind<bool>("InternalDebugging", fieldInfo.Name, false, "Enable/Disable this DebugLogSource. Should only be true if you know what you are doing or have been asked to.").Value)
				{
					fieldInfo.SetValue(null, new DebugLogSource(fieldInfo.Name));
					DawnPlugin.Logger.LogDebug((object)("created a DebugLogSource for " + fieldInfo.Name + "!"));
				}
				else
				{
					fieldInfo.SetValue(null, null);
					DawnPlugin.Logger.LogDebug((object)("no DebugLogSource for " + fieldInfo.Name + "."));
				}
			}
		}
	}
	internal class DebugLogSource
	{
		[CompilerGenerated]
		private string <title>P;

		public DebugLogSource(string title)
		{
			<title>P = title;
			base..ctor();
		}

		internal void Log(object message)
		{
			DawnPlugin.Logger.LogDebug((object)$"[Debug-{<title>P}] {message}");
		}
	}
	internal class AnimationCurveConverter : TOMLConverter<AnimationCurve>
	{
		protected override string ConvertToString(AnimationCurve value)
		{
			if (value == null || value.keys.Length == 0)
			{
				return ConvertToString(AnimationCurve.Constant(0f, 1f, 0f));
			}
			Keyframe[] keys = value.keys;
			float time = ((Keyframe)(ref keys[0])).time;
			float time2 = ((Keyframe)(ref keys[^1])).time;
			int num = Math.Max(10, keys.Length);
			string[] array = new string[num];
			for (int i = 0; i < num; i++)
			{
				float num2 = (float)i / ((float)num - 1f);
				float num3 = Mathf.Lerp(time, time2, num2);
				float num4 = value.Evaluate(num3);
				string text = num3.ToString("0.00", CultureInfo.InvariantCulture);
				string text2 = num4.ToString("0.00", CultureInfo.InvariantCulture);
				array[i] = text + ", " + text2;
			}
			return string.Join(';', array);
		}

		protected override AnimationCurve ConvertToObject(string keyValuePairs)
		{
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Expected O, but got Unknown
			//IL_0162: Unknown result type (might be due to invalid IL or missing references)
			//IL_0168: Expected O, but got Unknown
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			string[] array = (from s in keyValuePairs.Split(';', StringSplitOptions.RemoveEmptyEntries)
				select s.Trim()).ToArray();
			if (array.Length == 0)
			{
				if (int.TryParse(keyValuePairs, out var result))
				{
					return new AnimationCurve((Keyframe[])(object)new Keyframe[2]
					{
						new Keyframe(0f, 0f),
						new Keyframe(1f, (float)result)
					});
				}
				DawnPlugin.Logger.LogError((object)("Invalid key-value pairs format: " + keyValuePairs));
				return AnimationCurve.Constant(0f, 1f, 0f);
			}
			List<Keyframe> list = new List<Keyframe>();
			string[] array2 = array;
			foreach (string text in array2)
			{
				string[] array3 = (from s in text.Split(',')
					select s.Trim()).ToArray();
				if (array3.Length == 2 && float.TryParse(array3[0], NumberStyles.Float, CultureInfo.InvariantCulture, out var result2) && float.TryParse(array3[1], NumberStyles.Float, CultureInfo.InvariantCulture, out var result3))
				{
					list.Add(new Keyframe(result2, result3));
					continue;
				}
				MalformedAnimationCurveConfigException ex = new MalformedAnimationCurveConfigException(text);
				ex.LogNicely(DawnPlugin.Logger);
				throw ex;
			}
			return new AnimationCurve(list.ToArray());
		}

		public override bool IsEnabled()
		{
			return !LethalQuantitiesCompat.Enabled;
		}
	}
	internal class BoundedRangeConverter : TOMLConverter<BoundedRange>
	{
		protected override string ConvertToString(BoundedRange range)
		{
			return range.Min.ToString(CultureInfo.InvariantCulture) + "," + range.Max.ToString(CultureInfo.InvariantCulture);
		}

		protected override BoundedRange ConvertToObject(string value)
		{
			string[] array = value.Split(",");
			float result = 0f;
			float result2 = 0f;
			if (array.Length != 2 || !float.TryParse(array[0], NumberStyles.Float, CultureInfo.InvariantCulture, out result) || !float.TryParse(array[1], NumberStyles.Float, CultureInfo.InvariantCulture, out result2))
			{
				DawnPlugin.Logger.LogError((object)("Failed to parse BoundedRange value: " + value));
			}
			return new BoundedRange(result, result2);
		}
	}
	internal class NamespacedKeyConverter : TOMLConverter<NamespacedKey>
	{
		protected override string ConvertToString(NamespacedKey value)
		{
			return value.ToString();
		}

		protected override NamespacedKey ConvertToObject(string value)
		{
			return NamespacedKey.Parse(value);
		}
	}
	public abstract class TOMLConverter
	{
		public abstract Type ConvertingType { get; }

		public abstract string Serialize(object raw);

		public abstract object Deserialize(string value);

		public virtual bool IsEnabled()
		{
			return true;
		}
	}
	public abstract class TOMLConverter<T> : TOMLConverter where T : notnull
	{
		public override Type ConvertingType => typeof(T);

		public override string Serialize(object raw)
		{
			return ConvertToString((T)raw);
		}

		public override object Deserialize(string value)
		{
			return ConvertToObject(value);
		}

		protected abstract string ConvertToString(T value);

		protected abstract T ConvertToObject(string value);
	}
	internal static class ExtendedTOML
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static hook_GetConverter <0>__SupplyNamespacedKeyConverter;

			public static Func<Type, string> <1>__PrettyTypeName;
		}

		private static readonly TypeConverter _namespacedKeyConverter = WrapConverter(new NamespacedKeyConverter());

		private static readonly List<TOMLConverter> _converters = new List<TOMLConverter>(3)
		{
			new BoundedRangeConverter(),
			new AnimationCurveConverter(),
			new NamespacedKeyConverter()
		};

		internal static void Init()
		{
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Expected O, but got Unknown
			foreach (TOMLConverter converter in _converters)
			{
				if (!converter.IsEnabled())
				{
					Debuggers.ExtendedTOML?.Log("[ExtendedTOML] Skipped converter for '" + converter.ConvertingType.Name + "' it disabled itself.");
					continue;
				}
				TomlTypeConverter.AddConverter(converter.ConvertingType, WrapConverter(converter));
				DawnPlugin.Logger.LogInfo((object)("[ExtendedTOML] Registered converter for '" + converter.ConvertingType.Name + "'"));
			}
			object obj = <>O.<0>__SupplyNamespacedKeyConverter;
			if (obj == null)
			{
				hook_GetConverter val = SupplyNamespacedKeyConverter;
				<>O.<0>__SupplyNamespacedKeyConverter = val;
				obj = (object)val;
			}
			TomlTypeConverter.GetConverter += (hook_GetConverter)obj;
		}

		private static void PrettyPrintConfigSettingType(ILContext il)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			ILCursor val = new ILCursor(il);
			val.GotoNext((MoveType)2, new Func<Instruction, bool>[4]
			{
				(Instruction i) => ILPatternMatchingExt.MatchLdarg(i, 1),
				(Instruction i) => ILPatternMatchingExt.MatchLdstr(i, "# Setting type: "),
				(Instruction i) => ILPatternMatchingExt.MatchLdarg(i, 0),
				(Instruction i) => ILPatternMatchingExt.MatchCall<ConfigEntryBase>(i, "get_SettingType")
			});
			val.Next = Instruction.Create(OpCodes.Nop);
			val.EmitDelegate<Func<Type, string>>((Func<Type, string>)PrettyTypeName);
		}

		private static string PrettyTypeName(Type t)
		{
			if (t.IsArray)
			{
				return PrettyTypeName(t.GetElementType()) + "[]";
			}
			if (t.IsGenericType)
			{
				return string.Format("{0}<{1}>", t.Name.Substring(0, t.Name.LastIndexOf("`", StringComparison.InvariantCulture)), string.Join(", ", t.GetGenericArguments().Select(PrettyTypeName)));
			}
			return t.Name;
		}

		private static TypeConverter SupplyNamespacedKeyConverter(orig_GetConverter orig, Type valuetype)
		{
			if (typeof(NamespacedKey).IsAssignableFrom(valuetype))
			{
				return _namespacedKeyConverter;
			}
			return orig.Invoke(valuetype);
		}

		internal static TypeConverter WrapConverter(TOMLConverter converter)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Expected O, but got Unknown
			TOMLConverter converter2 = converter;
			return new TypeConverter
			{
				ConvertToObject = (string s, Type type) => converter2.Deserialize(s),
				ConvertToString = (object obj, Type type) => converter2.Serialize(obj)
			};
		}
	}
	public static class ItemSaveDataHandler
	{
		[CompilerGenerated]
		private sealed class <EnsureItemRotatedCorrectly>d__10 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public Transform transform;

			public Vector3 rotation;

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

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

			[DebuggerHidden]
			public <EnsureItemRotatedCorrectly>d__10(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0072: Unknown result type (might be due to invalid IL or missing references)
				//IL_0077: Unknown result type (might be due to invalid IL or missing references)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = null;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<>2__current = null;
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					<>2__current = null;
					<>1__state = 3;
					return true;
				case 3:
					<>1__state = -1;
					transform.rotation = Quaternion.Euler(rotation);
					return false;
				}
			}

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

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

		private static readonly List<Collider> _validItemSpawningColliders = new List<Collider>();

		internal static GrabbableObject[] AllShipItems = Array.Empty<GrabbableObject>();

		public static IReadOnlyList<Collider> ValidItemSpawningColliders => _validItemSpawningColliders;

		public static void AddColliderForItemSaving(Collider collider)
		{
			_validItemSpawningColliders.Add(collider);
		}

		private static void ValidateColliderEntries()
		{
			for (int num = _validItemSpawningColliders.Count - 1; num >= 0; num--)
			{
				if ((Object)(object)_validItemSpawningColliders[num] == (Object)null)
				{
					_validItemSpawningColliders.RemoveAt(num);
				}
			}
		}

		internal static void LoadSavedItems(PersistentDataContainer dataContainer)
		{
			JObject val = TryGetCurrentFormat(dataContainer);
			if (val != null)
			{
				LoadFromRoot(val);
			}
		}

		internal static void SaveAllItems(PersistentDataContainer dataContainer)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			//IL_024a: Unknown result type (might be due to invalid IL or missing references)
			//IL_024f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0256: Unknown result type (might be due to invalid IL or missing references)
			//IL_0260: Expected O, but got Unknown
			//IL_0260: Unknown result type (might be due to invalid IL or missing references)
			//IL_026d: Expected O, but got Unknown
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_0142: Unknown result type (might be due to invalid IL or missing references)
			//IL_0147: Unknown result type (might be due to invalid IL or missing references)
			//IL_014b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0152: Unknown result type (might be due to invalid IL or missing references)
			//IL_016c: Unknown result type (might be due to invalid IL or missing references)
			//IL_017f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0184: Unknown result type (might be due to invalid IL or missing references)
			//IL_0188: Unknown result type (might be due to invalid IL or missing references)
			//IL_018d: Unknown result type (might be due to invalid IL or missing references)
			//IL_018f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0194: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_020d: Unknown result type (might be due to invalid IL or missing references)
			//IL_021f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0227: Unknown result type (might be due to invalid IL or missing references)
			//IL_0231: Expected O, but got Unknown
			AllShipItems = Object.FindObjectsOfType<GrabbableObject>();
			List<string> list = new List<string>();
			Dictionary<string, int> dictionary = new Dictionary<string, int>();
			JArray val = new JArray();
			GrabbableObject[] allShipItems = AllShipItems;
			Vector3 val6 = default(Vector3);
			foreach (GrabbableObject val2 in allShipItems)
			{
				DawnItemInfo dawnInfo = val2.itemProperties.GetDawnInfo();
				if (dawnInfo == null)
				{
					if (!((NetworkBehaviour)val2).NetworkObject.IsSceneObject.HasValue || !((NetworkBehaviour)val2).NetworkObject.IsSceneObject.Value)
					{
						DawnPlugin.Logger.LogError((object)("Item: " + ((Object)val2).name + " doesn't have a DawnItemInfo; cannot save. Contact the developer of this item."));
					}
					continue;
				}
				string text = dawnInfo.Key.ToString();
				if (!dictionary.TryGetValue(text, out var value))
				{
					value = list.Count;
					list.Add(text);
					dictionary[text] = value;
				}
				Debuggers.Items?.Log("Saving item: " + text + " into save data.");
				JToken val3 = JToken.op_Implicit(0);
				if (val2.itemProperties.saveItemVariable)
				{
					val3 = ((IDawnSaveData)val2).GetDawnDataToSave() ?? JToken.op_Implicit(0);
				}
				JObject val4 = DawnItemSaveEvents.Collect(val2);
				JToken val5 = (JToken)(((JToken)val4).HasValues ? ((object)val4) : ((object)JToken.op_Implicit(0)));
				Vector3 position = ((Component)val2).transform.position;
				((Vector3)(ref val6))..ctor(position.x, position.y - val2.itemProperties.verticalOffset + 0.02f, position.z);
				Quaternion rotation = ((Component)val2).transform.rotation;
				Vector3 eulerAngles = ((Quaternion)(ref rotation)).eulerAngles;
				JArray val7 = new JArray();
				val7.Add(JToken.op_Implicit(value));
				val7.Add(JToken.op_Implicit(val6.x));
				val7.Add(JToken.op_Implicit(val6.y));
				val7.Add(JToken.op_Implicit(val6.z));
				val7.Add(JToken.op_Implicit(eulerAngles.x));
				val7.Add(JToken.op_Implicit(eulerAngles.y));
				val7.Add(JToken.op_Implicit(eulerAngles.z));
				val7.Add(JToken.op_Implicit(val2.scrapValue));
				val7.Add(val3);
				val7.Add(val5);
				JArray val8 = val7;
				val.Add((JToken)(object)val8);
			}
			JObject value2 = new JObject
			{
				["keys"] = (JToken)new JArray((object)list),
				["items"] = (JToken)(object)val
			};
			using (dataContainer.CreateEditContext())
			{
				dataContainer.Set<JObject>(DawnKeys.ShipItemsSaveData, value2);
			}
		}

		private static void LoadFromRoot(JObject root)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0216: Unknown result type (might be due to invalid IL or missing references)
			//IL_021b: Unknown result type (might be due to invalid IL or missing references)
			//IL_021f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0269: Unknown result type (might be due to invalid IL or missing references)
			//IL_026b: Unknown result type (might be due to invalid IL or missing references)
			//IL_026d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0254: Unknown result type (might be due to invalid IL or missing references)
			//IL_0259: Unknown result type (might be due to invalid IL or missing references)
			//IL_035a: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f1: Invalid comparison between Unknown and I4
			//IL_02f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fb: Invalid comparison between Unknown and I4
			//IL_030d: Unknown result type (might be due to invalid IL or missing references)
			JToken obj = root["keys"];
			JArray val = (JArray)(((object)((obj is JArray) ? obj : null)) ?? ((object)new JArray()));
			JToken obj2 = root["items"];
			JArray val2 = (JArray)(((object)((obj2 is JArray) ? obj2 : null)) ?? ((object)new JArray()));
			Vector3 position = default(Vector3);
			Vector3 val4 = default(Vector3);
			foreach (JToken item in val2)
			{
				JArray val3 = (JArray)(object)((item is JArray) ? item : null);
				if (val3 == null || ((JContainer)val3).Count < 8)
				{
					DawnPlugin.Logger.LogWarning((object)"Malformed ship item row in save data; skipping.");
					continue;
				}
				int num = val3[0].ToObject<int>();
				if (num < 0 || num >= ((JContainer)val).Count)
				{
					DawnPlugin.Logger.LogWarning((object)$"Invalid key index {num} in save; skipping.");
					continue;
				}
				string text = val[num].ToObject<string>();
				if (string.IsNullOrWhiteSpace(text) || !NamespacedKey.TryParse(text, out NamespacedKey result))
				{
					DawnPlugin.Logger.LogWarning((object)("Invalid item key '" + text + "' in save; skipping."));
					continue;
				}
				if (!LethalContent.Items.TryGetValue(result, out DawnItemInfo value))
				{
					DawnPlugin.Logger.LogWarning((object)$"Item: {result} no longer exists (mod removed?); skipping.");
					continue;
				}
				float num2 = val3[1].ToObject<float>();
				float num3 = val3[2].ToObject<float>();
				float num4 = val3[3].ToObject<float>();
				((Vector3)(ref position))..ctor(num2, num3, num4);
				float num5 = val3[4].ToObject<float>();
				float num6 = val3[5].ToObject<float>();
				float num7 = val3[6].ToObject<float>();
				((Vector3)(ref val4))..ctor(num5, num6, num7);
				int scrapValue = val3[7].ToObject<int>();
				JToken val5 = ((((JContainer)val3).Count > 8) ? val3[8] : JToken.op_Implicit(0));
				JToken extraSaveData = ((((JContainer)val3).Count > 9) ? val3[9] : JToken.op_Implicit(0));
				AddColliderForItemSaving(StartOfRoundRefs.Instance.shipInnerRoomBounds);
				ValidateColliderEntries();
				bool flag = false;
				foreach (Collider validItemSpawningCollider in ValidItemSpawningColliders)
				{
					Bounds bounds = validItemSpawningCollider.bounds;
					if (((Bounds)(ref bounds)).Contains(position))
					{
						flag = true;
						break;
					}
				}
				if (!flag)
				{
					position = StartOfRoundRefs.Instance.playerSpawnPositions[1].position;
				}
				GrabbableObject grabbable = Object.Instantiate<GameObject>(value.Item.spawnPrefab, position, Quaternion.Euler(val4), StartOfRoundRefs.Instance.elevatorTransform).GetComponent<GrabbableObject>();
				grabbable.fallTime = 0f;
				grabbable.scrapPersistedThroughRounds = true;
				grabbable.isInElevator = true;
				grabbable.isInShipRoom = true;
				grabbable.SetScrapValue(scrapValue);
				if (grabbable.itemProperties.saveItemVariable && val5 != null && (int)val5.Type != 10 && ((int)val5.Type != 6 || Extensions.Value<int>((IEnumerable<JToken>)val5) != 0))
				{
					((IDawnSaveData)grabbable).LoadDawnSaveData(val5);
				}
				((NetworkBehaviour)grabbable).NetworkObject.Spawn(false);
				((NetworkBehaviour)grabbable).NetworkObject.OnSpawn(delegate
				{
					//IL_000e: Unknown result type (might be due to invalid IL or missing references)
					//IL_0015: Invalid comparison between Unknown and I4
					//IL_001d: Unknown result type (might be due to invalid IL or missing references)
					//IL_0023: Invalid comparison between Unknown and I4
					if (extraSaveData != null && (int)extraSaveData.Type != 10 && ((int)extraSaveData.Type != 6 || Extensions.Value<int>((IEnumerable<JToken>)extraSaveData) != 0))
					{
						DawnItemSaveEvents.Restore(grabbable, extraSaveData);
					}
				});
				((MonoBehaviour)StartOfRound.Instance).StartCoroutine(EnsureItemRotatedCorrectly(((Component)grabbable).transform, val4));
			}
		}

		private static JObject? TryGetCurrentFormat(PersistentDataContainer dataContainer)
		{
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Invalid comparison between Unknown and I4
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Expected O, but got Unknown
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Expected O, but got Unknown
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Expected O, but got Unknown
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Expected O, but got Unknown
			JObject orCreateDefault;
			try
			{
				orCreateDefault = ((DataContainer)dataContainer).GetOrCreateDefault<JObject>(DawnKeys.ShipItemsSaveData);
			}
			catch (Exception ex)
			{
				DawnPlugin.Logger.LogWarning((object)("Failed to read ship items save data. (" + ex.GetType().Name + ": " + ex.Message + ")"));
				return null;
			}
			if (orCreateDefault == null || (int)((JToken)orCreateDefault).Type != 1)
			{
				return null;
			}
			JToken val = orCreateDefault["keys"];
			JToken val2 = orCreateDefault["items"];
			if (val == null && val2 == null)
			{
				orCreateDefault["keys"] = (JToken)new JArray();
				orCreateDefault["items"] = (JToken)new JArray();
				return orCreateDefault;
			}
			if (val == null)
			{
				orCreateDefault["keys"] = (JToken)new JArray();
			}
			if (val2 == null)
			{
				orCreateDefault["items"] = (JToken)new JArray();
			}
			if (!(orCreateDefault["keys"] is JArray) || !(orCreateDefault["items"] is JArray))
			{
				return null;
			}
			return orCreateDefault;
		}

		[IteratorStateMachine(typeof(<EnsureItemRotatedCorrectly>d__10))]
		private static IEnumerator EnsureItemRotatedCorrectly(Transform transform, Vector3 rotation)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <EnsureItemRotatedCorrectly>d__10(0)
			{
				transform = transform,
				rotation = rotation
			};
		}
	}
	public static class DawnItemSaveEvents
	{
		public static event Action<GrabbableObject, JObject>? OnCollectExtraSaveData;

		public static event Action<GrabbableObject, JObject>? OnLoadExtraSaveData;

		internal static JObject Collect(GrabbableObject item)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Expected O, but got Unknown
			JObject val = new JObject();
			DawnItemSaveEvents.OnCollectExtraSaveData?.Invoke(item, val);
			return val;
		}

		internal static void Restore(GrabbableObject item, JToken? token)
		{
			JObject val = (JObject)(object)((token is JObject) ? token : null);
			if (val != null)
			{
				DawnItemSaveEvents.OnLoadExtraSaveData?.Invoke(item, val);
			}
		}
	}
	internal static class DungeonGenerationPlusCompat
	{
		internal const string COMPATIBLE_VERSION = "1.5.0";

		internal static bool RemovedHotloading;

		private static object? extenderObject;

		public static bool Enabled
		{
			get
			{
				if (Chainloader.PluginInfos.ContainsKey("dev.ladyalice.dungenplus"))
				{
					return Chainloader.PluginInfos["dev.ladyalice.dungenplus"].Metadata.Version >= Version.Parse("1.5.0");
				}
				return false;
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
		internal static void HandleExtenderForBundle(AssetBundle assetBundle, DungeonFlow dungeonFlow, bool register)
		{
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Expected O, but got Unknown
			if (register)
			{
				DunGenExtender[] array = assetBundle.LoadAllAssets<DunGenExtender>();
				if (array.Length != 0)
				{
					if (array.Length > 1)
					{
						DawnPlugin.Logger.LogWarning((object)("Multiple DunGenExtender assets found in bundle " + ((Object)assetBundle).name + ", there should only be one."));
					}
					extenderObject = array[0];
					((DunGenExtender)extenderObject).DungeonFlow = dungeonFlow;
					API.AddDunGenExtender(dungeonFlow, (DunGenExtender)extenderObject);
				}
			}
			else if (extenderObject != null)
			{
				API.RemoveDunGenExtender(dungeonFlow);
				extenderObject = null;
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
		internal static bool IsDebugOn()
		{
			if (PluginConfig.EnableDevDebugTools.Value)
			{
				return true;
			}
			return false;
		}
	}
	internal static class GoodItemScanCompat
	{
		private static bool? _enabled;

		public static bool Enabled
		{
			get
			{
				bool valueOrDefault = _enabled.GetValueOrDefault();
				if (!_enabled.HasValue)
				{
					valueOrDefault = Chainloader.PluginInfos.ContainsKey("TestAccount666.GoodItemScan");
					_enabled = valueOrDefault;
				}
				return _enabled.Value;
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
		public static bool TryGetRectTransform(ScanNodeProperties scanNodeProperties, [NotNullWhen(true)] out RectTransform? rectTransform)
		{
			rectTransform = null;
			if (GoodItemScan.scanner == null)
			{
				return false;
			}
			foreach (ScannedNode activeNode in GoodItemScan.scanner.activeNodes)
			{
				if (!((Object)(object)activeNode.ScanNodeProperties != (Object)(object)scanNodeProperties))
				{
					rectTransform = activeNode.RectTransform;
					return true;
				}
			}
			return false;
		}

		[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
		public static bool TryGetScanNode(RectTransform rectTransform, [NotNullWhen(true)] out ScanNodeProperties? scanNodeProperties)
		{
			scanNodeProperties = null;
			if (GoodItemScan.scanner == null)
			{
				return false;
			}
			foreach (ScannedNode activeNode in GoodItemScan.scanner.activeNodes)
			{
				if (!((Object)(object)rectTransform != (Object)(object)activeNode.RectTransform))
				{
					scanNodeProperties = activeNode.ScanNodeProperties;
					return true;
				}
			}
			return false;
		}
	}
	internal static class LCBetterSaveCompat
	{
		private static bool alreadyHooked;

		public static bool Enabled => Chainloader.PluginInfos.ContainsKey("LCBetterSaves");

		[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
		public static void Init()
		{
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Expected O, but got Unknown
			if (!alreadyHooked)
			{
				alreadyHooked = true;
				DawnPlugin.Hooks.Add(new Hook((MethodBase)AccessTools.DeclaredMethod(typeof(DeleteFileButton_BetterSaves), "DeleteFile", (Type[])null, (Type[])null), (Delegate)new Action<Action<DeleteFileButton_BetterSaves>, DeleteFileButton_BetterSaves>(OnFileDeleteSaveDataPatch)));
			}
		}

		private static void OnFileDeleteSaveDataPatch(Action<DeleteFileButton_BetterSaves> orig, DeleteFileButton_BetterSaves self)
		{
			PersistentDataContainer persistentDataContainer = DawnNetworker.CreateContractContainer($"LCSaveFile{self.fileToDelete}");
			persistentDataContainer.Clear();
			PersistentDataContainer persistentDataContainer2 = DawnNetworker.CreateSaveContainer($"LCSaveFile{self.fileToDelete}");
			persistentDataContainer2.Clear();
			orig.Invoke(self);
		}
	}
	internal static class LethalConfigCompat
	{
		internal const string VERSION = "1.4.6";

		private static ConfigFile _dummyConfig;

		private static readonly FieldInfo _typedValueField = typeof(ConfigEntry<>).GetField("_typedValue", BindingFlags.Instance | BindingFlags.NonPublic);

		public static bool Enabled
		{
			get
			{
				if (Chainloader.PluginInfos.ContainsKey("ainavt.lc.lethalconfig"))
				{
					return DawnConfig.LethalConfigCompatibility.Value.ShouldRunCompatibility("1.4.6", Chainloader.PluginInfos["ainavt.lc.lethalconfig"].Metadata.Version);
				}
				return false;
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
		public 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_0021: Expected O, but got Unknown
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Expected O, but got Unknown
			_dummyConfig = new ConfigFile(Path.Combine(Application.persistentDataPath, "dawnlib.dummy.youshouldneverseethis.cfg"), false)
			{
				SaveOnConfigSet = false
			};
			DawnPlugin.Hooks.Add(new Hook((MethodBase)AccessTools.DeclaredMethod(typeof(AutoConfigGenerator), "GenerateConfigForEntry", (Type[])null, (Type[])null), (Delegate)new Func<Func<ConfigEntryBase, BaseConfigItem>, ConfigEntryBase, BaseConfigItem>(ExtendGenerateConfigForEntry)));
		}

		private static BaseConfigItem? ExtendGenerateConfigForEntry(Func<ConfigEntryBase, BaseConfigItem> orig, ConfigEntryBase configEntryBase)
		{
			ConfigEntryBase configEntryBase2 = configEntryBase;
			try
			{
				BaseConfigItem val = orig.Invoke(configEntryBase2);
				if (val != null)
				{
					return val;
				}
				if (!TomlTypeConverter.CanConvert(configEntryBase2.SettingType))
				{
					Debuggers.LethalConfig?.Log($"toml type converter can't support: {configEntryBase2.SettingType}");
					return null;
				}
				Debuggers.LethalConfig?.Log($"toml type converter can actually support: {configEntryBase2.SettingType}");
				ConfigEntry<string> proxyEntry = _dummyConfig.Bind<string>(configEntryBase2.Definition.Section, configEntryBase2.Definition.Key, TomlTypeConverter.ConvertToString(configEntryBase2.BoxedValue, configEntryBase2.SettingType), configEntryBase2.Description.Description);
				Debuggers.LethalConfig?.Log($"created proxy entry for {configEntryBase2.Definition.Section}.{configEntryBase2.Definition.Key} with type {configEntryBase2.SettingType} and value {proxyEntry.Value}");
				proxyEntry.SettingChanged += delegate
				{
					configEntryBase2.BoxedValue = TomlTypeConverter.ConvertToValue(proxyEntry.Value, configEntryBase2.SettingType);
				};
				_dummyConfig.SettingChanged += delegate(object sender, SettingChangedEventArgs args)
				{
					if (args.ChangedSetting == configEntryBase2)
					{
						_typedValueField.SetValue(proxyEntry, TomlTypeConverter.ConvertToString(configEntryBase2.BoxedValue, configEntryBase2.SettingType));
					}
				};
				return orig.Invoke((ConfigEntryBase)(object)proxyEntry);
			}
			catch (Exception arg)
			{
				DawnPlugin.Logger.LogError((object)$"Caught actual LethalConfig error: \n{arg}");
				return null;
			}
		}
	}
	internal static class LethalLevelLoaderCompat
	{
		internal const string VERSION = "1.6.9";

		public static bool Enabled => Chainloader.PluginInfos.ContainsKey("imabatby.lethallevelloader");

		[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
		public static void ScrewWithLLLDynamicDungeonRarity()
		{
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Expected O, but got Unknown
			DawnPlugin.Hooks.Add(new Hook((MethodBase)AccessTools.DeclaredMethod(typeof(LevelMatchingProperties), "GetDynamicRarity", (Type[])null, (Type[])null), (Delegate)new Func<Func<LevelMatchingProperties, ExtendedLevel, int>, LevelMatchingProperties, ExtendedLevel, int>(EnsureCorrectDawnDungeonDynamicRarity)));
		}

		[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
		public static void LetLLLHandleGeneration()
		{
			Patches.InjectHostDungeonSizeSelection(RoundManager.Instance);
		}

		[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
		public static BoundedRange GetDungeonClamp(DungeonFlow dungeonFlow)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			ExtendedDungeonFlow val = default(ExtendedDungeonFlow);
			if (DungeonManager.TryGetExtendedDungeonFlow(dungeonFlow, ref val, (ContentType)2))
			{
				if (val.IsDynamicDungeonSizeRestrictionEnabled)
				{
					return new BoundedRange(val.DynamicDungeonSizeMinMax.x, val.DynamicDungeonSizeMinMax.y);
				}
				return new BoundedRange(0f, 999f);
			}
			return new BoundedRange(0f, 999f);
		}

		[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
		public static List<IntWithRarity> GetCustomDungeonsWithRarities(SelectableLevel selectableLevel)
		{
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Expected O, but got Unknown
			List<ExtendedDungeonFlow> customExtendedDungeonFlows = PatchedContent.CustomExtendedDungeonFlows;
			List<IntWithRarity> list = new List<IntWithRarity>();
			foreach (ExtendedDungeonFlow item in customExtendedDungeonFlows)
			{
				if ((Object)(object)item.LevelMatchingProperties == (Object)null)
				{
					continue;
				}
				ExtendedLevel extendedLevel = LevelManager.GetExtendedLevel(selectableLevel);
				if ((Object)(object)extendedLevel == (Object)null)
				{
					continue;
				}
				int dynamicRarity = item.LevelMatchingProperties.GetDynamicRarity(extendedLevel);
				IntWithRarity val = new IntWithRarity(0, 0, (LevelAmbienceLibrary)null);
				for (int i = 0; i < RoundManagerRefs.Instance.dungeonFlowTypes.Length; i++)
				{
					if ((Object)(object)RoundManagerRefs.Instance.dungeonFlowTypes[i].dungeonFlow == (Object)(object)item.DungeonFlow)
					{
						val.id = i;
						val.rarity = dynamicRarity;
						break;
					}
				}
				list.Add(val);
			}
			return list;
		}

		private static int EnsureCorrectDawnDungeonDynamicRarity(Func<LevelMatchingProperties, ExtendedLevel, int> orig, LevelMatchingProperties self, ExtendedLevel extendedLevel)
		{
			ExtendedDungeonFlow val = null;
			foreach (ExtendedDungeonFlow extendedDungeonFlow in PatchedContent.ExtendedDungeonFlows)
			{
				if (((object)extendedDungeonFlow.LevelMatchingProperties).Equals((object?)self))
				{
					val = extendedDungeonFlow;
					break;
				}
			}
			DungeonFlow val2 = ((val != null) ? val.DungeonFlow : null);
			if ((Object)(object)val2 != (Object)null && val2.TryGetDawnInfo(out DawnDungeonInfo dungeonInfo) && !dungeonInfo.ShouldSkipRespectOverride())
			{
				SpawnWeightContext ctx = new SpawnWeightContext(extendedLevel.SelectableLevel.GetDawnInfo(), dungeonInfo, TimeOfDayRefs.GetCurrentWeatherEffect(extendedLevel.SelectableLevel)?.GetDawnInfo()).WithExtra(SpawnWeightExtraKeys.RoutingPriceKey, extendedLevel.SelectableLevel.GetDawnInfo().DawnPurchaseInfo.Cost.Provide());
				return dungeonInfo.Weights.GetFor(in ctx).GetValueOrDefault().Clamp0();
			}
			return orig.Invoke(self, extendedLevel);
		}

		[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
		public static void TryRemoveLLLDungeonTranspiler()
		{
			MethodBase method = typeof(RoundManager).GetMethod("GenerateNewFloor");
			DawnPlugin._harmony.Unpatch(method, (HarmonyPatchType)3, "imabatby.lethallevelloader");
		}

		[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
		public static bool TryGetExtendedLevelModName(SelectableLevel level, out string modName)
		{
			modName = "lethal_level_loader";
			ExtendedLevel val = default(ExtendedLevel);
			if (LevelManager.TryGetExtendedLevel(level, ref val, (ContentType)2))
			{
				modName = ((ExtendedContent)val).ModName;
				return true;
			}
			return false;
		}

		[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
		public static bool ExtendedLevelIsModded(SelectableLevel level, [NotNullWhen(true)] out object? extendedLevelObject)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Invalid comparison between Unknown and I4
			extendedLevelObject = null;
			ExtendedLevel val = default(ExtendedLevel);
			if (LevelManager.TryGetExtendedLevel(level, ref val, (ContentType)2))
			{
				extendedLevelObject = val;
				return (int)((ExtendedContent)val).ContentType == 1;
			}
			return false;
		}

		[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
		public static bool TryGetExtendedDungeonModName(DungeonFlow dungeonFlow, out string modName)
		{
			modName = "lethal_level_loader";
			ExtendedDungeonFlow val = default(ExtendedDungeonFlow);
			if (DungeonManager.TryGetExtendedDungeonFlow(dungeonFlow, ref val, (ContentType)2))
			{
				modName = ((ExtendedContent)val).ModName;
				return true;
			}
			return false;
		}

		[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
		public static bool TryGetExtendedEnemyTypeModName(EnemyType enemyType, out string modName)
		{
			modName = "lethal_level_loader";
			foreach (ExtendedEnemyType extendedEnemyType in PatchedContent.ExtendedEnemyTypes)
			{
				if ((Object)(object)extendedEnemyType.EnemyType == (Object)(object)enemyType)
				{
					modName = ((ExtendedContent)extendedEnemyType).ModName;
					return true;
				}
			}
			return false;
		}

		[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
		public static bool TryGetExtendedItemModName(Item item, out string modName)
		{
			modName = "lethal_level_loader";
			foreach (ExtendedItem extendedItem in PatchedContent.ExtendedItems)
			{
				if ((Object)(object)extendedItem.Item == (Object)(object)item)
				{
					modName = ((ExtendedContent)extendedItem).ModName;
					return true;
				}
			}
			return false;
		}

		[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
		public static bool TryGetExtendedMapObjectModName(GameObject mapObject, out string modName)
		{
			modName = "lethal_level_loader";
			foreach (ExtendedLevel extendedLevel in PatchedContent.ExtendedLevels)
			{
				SelectableLevel selectableLevel = extendedLevel.SelectableLevel;
				if ((Object)(object)selectableLevel == (Object)null)
				{
					continue;
				}
				for (int i = 0; i < selectableLevel.indoorMapHazards?.Length; i++)
				{
					if ((Object)(object)selectableLevel.indoorMapHazards[i]?.hazardType != (Object)null && (Object)(object)selectableLevel.indoorMapHazards[i].hazardType.prefabToSpawn == (Object)(object)mapObject)
					{
						modName = ((ExtendedContent)extendedLevel).ModName;
						return true;
					}
				}
				for (int j = 0; j < selectableLevel.spawnableOutsideObjects?.Length; j++)
				{
					if ((Object)(object)selectableLevel.spawnableOutsideObjects[j]?.spawnableObject != (Object)null && (Object)(object)selectableLevel.spawnableOutsideObjects[j].spawnableObject.prefabToSpawn == (Object)(object)mapObject)
					{
						modName = ((ExtendedContent)extendedLevel).ModName;
						return true;
					}
				}
			}
			return false;
		}

		[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
		public static bool TryGetAllTagsWithModNames(SelectableLevel selectableLevel, out List<(string modName, string tagName)> allTagsWithModNames)
		{
			allTagsWithModNames = new List<(string, string)>();
			ExtendedLevel val = default(ExtendedLevel);
			if (!LevelManager.TryGetExtendedLevel(selectableLevel, ref val, (ContentType)2))
			{
				return false;
			}
			foreach (ContentTag contentTag in ((ExtendedContent)val).ContentTags)
			{
				allTagsWithModNames.Add((((ExtendedContent)val).ModName, contentTag.contentTagName));
			}
			return true;
		}

		[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
		public static bool TryGetAllTagsWithModNames(DungeonFlow dungeonFlow, out List<(string modName, string tagName)> allTagsWithModNames)
		{
			allTagsWithModNames = new List<(string, string)>();
			ExtendedDungeonFlow val = default(ExtendedDungeonFlow);
			if (!DungeonManager.TryGetExtendedDungeonFlow(dungeonFlow, ref val, (ContentType)2))
			{
				return false;
			}
			foreach (ContentTag contentTag in ((ExtendedContent)val).ContentTags)
			{
				allTagsWithModNames.Add((((ExtendedContent)val).ModName, contentTag.contentTagName));
			}
			return true;
		}

		[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
		public static bool TryGetAllTagsWithModNames(Item item, out List<(string modName, string tagName)> allTagsWithModNames)
		{
			allTagsWithModNames = new List<(string, string)>();
			ExtendedItem val = null;
			foreach (ExtendedItem extendedItem in PatchedContent.ExtendedItems)
			{
				if ((Object)(object)extendedItem.Item == (Object)(object)item)
				{
					val = extendedItem;
					break;
				}
			}
			if ((Object)(object)val == (Object)null)
			{
				return false;
			}
			foreach (ContentTag contentTag in ((ExtendedContent)val).ContentTags)
			{
				allTagsWithModNames.Add((((ExtendedContent)val).ModName, contentTag.contentTagName));
			}
			return true;
		}

		[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
		public static bool TryGetAllTagsWithModNames(EnemyType enemyType, out List<(string modName, string tagName)> allTagsWithModNames)
		{
			allTagsWithModNames = new List<(string, string)>();
			ExtendedEnemyType val = null;
			foreach (ExtendedEnemyType extendedEnemyType in PatchedContent.ExtendedEnemyTypes)
			{
				if ((Object)(object)extendedEnemyType.EnemyType == (Object)(object)enemyType)
				{
					val = extendedEnemyType;
					break;
				}
			}
			if ((Object)(object)val == (Object)null)
			{
				return false;
			}
			foreach (ContentTag contentTag in ((ExtendedContent)val).ContentTags)
			{
				allTagsWithModNames.Add((((ExtendedContent)val).ModName, contentTag.contentTagName));
			}
			return true;
		}
	}
	internal static class LethalLibCompat
	{
		public static bool Enabled => Chainloader.PluginInfos.ContainsKey("evaisa.lethallib");

		[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
		public static bool TryGetWeatherEffectFromLethalLib(string weatherName, out string modName)
		{
			modName = "lethal_lib";
			foreach (CustomWeather value in Weathers.customWeathers.Values)
			{
				if (value.name == weatherName)
				{
					return true;
				}
			}
			return false;
		}

		[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
		public static bool TryGetUnlockableItemFromLethalLib(UnlockableItem unlockableItem, out string modName)
		{
			modName = "lethal_lib";
			foreach (RegisteredUnlockable registeredUnlockable in Unlockables.registeredUnlockables)
			{
				if (registeredUnlockable.unlockable == unlockableItem)
				{
					modName = registeredUnlockable.modName;
					return true;
				}
			}
			return false;
		}

		[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
		public static bool TryGetItemFromLethalLib(Item item, out string modName)
		{
			modName = "lethal_lib";
			foreach (ScrapItem scrapItem in Items.scrapItems)
			{
				if ((Object)(object)scrapItem.item == (Object)(object)item)
				{
					modName = scrapItem.modName;
					return true;
				}
			}
			foreach (ShopItem shopItem in Items.shopItems)
			{
				if ((Object)(object)shopItem.item == (Object)(object)item)
				{
					modName = shopItem.modName;
					return true;
				}
			}
			foreach (PlainItem plainItem in Items.plainItems)
			{
				if ((Object)(object)plainItem.item == (Object)(object)item)
				{
					modName = plainItem.modName;
					return true;
				}
			}
			return false;
		}

		[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
		public static bool TryGetEnemyTypeFromLethalLib(EnemyType enemyType, out string modName)
		{
			modName = "lethal_lib";
			foreach (SpawnableEnemy spawnableEnemy in Enemies.spawnableEnemies)
			{
				if ((Object)(object)spawnableEnemy.enemy == (Object)(object)enemyType)
				{
					modName = spawnableEnemy.modName;
					return true;
				}
			}
			return false;
		}

		[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
		public static bool TryGetMapObjectFromLethalLib(GameObject mapObject, out string modName)
		{
			modName = "lethal_lib";
			foreach (RegisteredMapObject mapObject2 in MapObjects.mapObjects)
			{
				if ((Object)(object)mapObject2.indoorMapHazardType != (Object)null && (Object)(object)mapObject2.indoorMapHazardType.prefabToSpawn == (Object)(object)mapObject)
				{
					return true;
				}
				if (mapObject2.outsideObject != null && (Object)(object)mapObject2.outsideObject.spawnableObject.prefabToSpawn == (Object)(object)mapObject)
				{
					return true;
				}
			}
			return false;
		}
	}
	internal static class LethalQuantitiesCompat
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static Action<Action<RoundManager>, RoundManager> <0>__MarkShouldUseLQConverter;

			public static hook_GetConverter <1>__ReplaceAnimationCurveConverter;
		}

		private static bool _useLQConverter;

		private static TypeConverter _lqConverter;

		private static TypeConverter _dawnConverter;

		public static bool Enabled => Chainloader.PluginInfos.ContainsKey("LethalQuantities");

		[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
		public static void Init()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Expected O, but got Unknown
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Expected O, but got Unknown
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Expected O, but got Unknown
			_lqConverter = (TypeConverter)new AnimationCurveTypeConverter();
			_dawnConverter = ExtendedTOML.WrapConverter(new AnimationCurveConverter());
			DawnPlugin.Hooks.Add(new Hook((MethodBase)AccessTools.DeclaredMethod(typeof(RoundManagerPatch), "onStartPrefix", (Type[])null, (Type[])null), (Delegate)new Action<Action<RoundManager>, RoundManager>(MarkShouldUseLQConverter)));
			object obj = <>O.<1>__ReplaceAnimationCurveConverter;
			if (obj == null)
			{
				hook_GetConverter val = ReplaceAnimationCurveConverter;
				<>O.<1>__ReplaceAnimationCurveConverter = val;
				obj = (object)val;
			}
			TomlTypeConverter.GetConverter += (hook_GetConverter)obj;
		}

		private static TypeConverter ReplaceAnimationCurveConverter(orig_GetConverter orig, Type valuetype)
		{
			if (valuetype != typeof(AnimationCurve))
			{
				return orig.Invoke(valuetype);
			}
			if (_useLQConverter)
			{
				return _lqConverter;
			}
			return _dawnConverter;
		}

		private static void MarkShouldUseLQConverter(Action<RoundManager> orig, RoundManager __instance)
		{
			_useLQConverter = true;
			orig.Invoke(__instance);
			_useLQConverter = false;
		}
	}
	internal static class MoonDaySpeedMultiplierPatcherCompat
	{
		public static bool Enabled => Chainloader.PluginInfos.ContainsKey("com.github.WhiteSpike.MoonDaySpeedMultiplierPatcher");
	}
	internal static class StarlancerAIFixCompat
	{
		public static bool Enabled => Chainloader.PluginInfos.ContainsKey("AudioKnight.StarlancerAIFix");
	}
	internal static class TerminalFormatterCompat
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static Manipulator <0>__UseFailedNameResults;
		}

		public static bool Enabled => Chainloader.PluginInfos.ContainsKey("TerminalFormatter");

		internal static void Init()
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Expected O, but got Unknown
			MethodInfo methodInfo = AccessTools.DeclaredMethod(typeof(Store), "GetNodeText", (Type[])null, (Type[])null);
			object obj = <>O.<0>__UseFailedNameResults;
			if (obj == null)
			{
				Manipulator val = TerminalPatches.UseFailedNameResults;
				<>O.<0>__UseFailedNameResults = val;
				obj = (object)val;
			}
			new ILHook((MethodBase)methodInfo, (Manipulator)obj);
		}
	}
	internal static class WeatherRegistryCompat
	{
		public static bool Enabled => Chainloader.PluginInfos.ContainsKey("mrov.WeatherRegistry");

		[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
		public static void Init()
		{
			((CustomEvent<(SelectableLevel, Weather)>)(object)EventManager.WeatherChanged).AddListener((ParameterEvent<(SelectableLevel, Weather)>)WeatherRegistry_EventManager_WeatherChanged);
		}

		private static void WeatherRegistry_EventManager_WeatherChanged((SelectableLevel selectableLevel, Weather weather) args)
		{
			if (!LethalContent.Weathers.IsFrozen)
			{
				EnemyRegistrationHandler.UpdateEnemyWeightsOnLevel(args.selectableLevel);
				ItemRegistrationHandler.UpdateItemWeightsOnLevel(args.selectableLevel);
				MapObjectRegistrationHandler.UpdateIndoorMapHazardSpawnWeightsOnLevel(args.selectableLevel);
				MapObjectRegistrationHandler.UpdateOutsideMapObjectSpawnWeightsOnLevel(args.selectableLevel);
				DungeonRegistrationHandler.UpdateDungeonWeightOnLevel(args.selectableLevel);
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
		public static bool TryGetWeatherFromWeatherRegistry(string weatherName, out string modName)
		{
			modName = "weather_registry";
			foreach (Weather registeredWeather in WeatherManager.RegisteredWeathers)
			{
				if (registeredWeather.Effect.VanillaWeatherEffect.name == weatherName)
				{
					return true;
				}
			}
			return false;
		}

		[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
		public static void SetCurrentWeather(SelectableLevel level, LevelWeatherType levelWeatherType)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			WeatherController.ChangeWeather(level, levelWeatherType);
		}

		[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
		public static bool IsWeatherManagerReady()
		{
			return WeatherManager.IsSetupFinished;
		}
	}
	internal static class NetworkVariableInitalizer
	{
		internal static void Init()
		{
			NetworkVariableSerializationTypes.InitializeSerializer_UnmanagedByMemcpy<bool>();
			NetworkVariableSerializationTypes.InitializeEqualityChecker_UnmanagedIEquatable<bool>();
			NetworkVariableSerializationTypes.InitializeSerializer_UnmanagedByMemcpy<float>();
			NetworkVariableSerializationTypes.InitializeEqualityChecker_UnmanagedIEquatable<float>();
			NetworkVariableSerializationTypes.InitializeSerializer_UnmanagedByMemcpy<double>();
			NetworkVariableSerializationTypes.InitializeEqualityChecker_UnmanagedIEquatable<double>();
			NetworkVariableSerializationTypes.InitializeSerializer_UnmanagedByMemcpy<int>();
			NetworkVariableSerializationTypes.InitializeEqualityChecker_UnmanagedIEquatable<int>();
			NetworkVariableSerializationTypes.InitializeSerializer_UnmanagedByMemcpy<Vector2>();
			NetworkVariableSerializationTypes.InitializeEqualityChecker_UnmanagedIEquatable<Vector2>();
			NetworkVariableSerializationTypes.InitializeSerializer_UnmanagedByMemcpy<Vector3>();
			NetworkVariableSerializationTypes.InitializeEqualityChecker_UnmanagedIEquatable<Vector3>();
			NetworkVariableSerializationTypes.InitializeSerializer_UnmanagedINetworkSerializable<NetworkTransformState>();
			NetworkVariableSerializationTypes.InitializeEqualityChecker_UnmanagedValueEquals<NetworkTransformState>();
			NetworkVariableSerializationTypes.InitializeSerializer_ManagedINetworkSerializable<PlayerControllerReference>();
			NetworkVariableSerializationTypes.InitializeEqualityChecker_ManagedIEquatable<PlayerControllerReference>();
		}
	}
	internal static class DebugPatches
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static hook_Start <0>__AddDebugFixes;

			public static hook_Show <1>__TMPDropdownShow;

			public static hook_Hide <2>__TMPDropdownHide;
		}

		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
			object obj = <>O.<0>__AddDebugFixes;
			if (obj == null)
			{
				hook_Start val = AddDebugFixes;
				<>O.<0>__AddDebugFixes = val;
				obj = (object)val;
			}
			QuickMenuManager.Start += (hook_Start)obj;
			object obj2 = <>O.<1>__TMPDropdownShow;
			if (obj2 == null)
			{
				hook_Show val2 = TMPDropdownShow;
				<>O.<1>__TMPDropdownShow = val2;
				obj2 = (object)val2;
			}
			TMP_Dropdown.Show += (hook_Show)obj2;
			object obj3 = <>O.<2>__TMPDropdownHide;
			if (obj3 == null)
			{
				hook_Hide val3 = TMPDropdownHide;
				<>O.<2>__TMPDropdownHide = val3;
				obj3 = (object)val3;
			}
			TMP_Dropdown.Hide += (hook_Hide)obj3;
		}

		private static void TMPDropdownHide(orig_Hide orig, TMP_Dropdown self)
		{
			TMPDropDownFixer tMPDropDownFixer = default(TMPDropDownFixer);
			if (((Component)self).gameObject.TryGetComponent<TMPDropDownFixer>(ref tMPDropDownFixer))
			{
				tMPDropDownFixer.OnCloseDropdown();
			}
			orig.Invoke(self);
		}

		private static void TMPDropdownShow(orig_Show orig, TMP_Dropdown self)
		{
			orig.Invoke(self);
			TMPDropDownFixer tMPDropDownFixer = default(TMPDropDownFixer);
			if (((Component)self).gameObject.TryGetComponent<TMPDropDownFixer>(ref tMPDropDownFixer))
			{
				tMPDropDownFixer.OnOpenDropdown(self);
			}
		}

		private static void AddDebugFixes(orig_Start orig, QuickMenuManager self)
		{
			orig.Invoke(self);
			((Component)self.allItemsDropdown).gameObject.AddComponent<TMPDropDownFixer>();
			((Component)self.debugEnemyDropdown).gameObject.AddComponent<TMPDropDownFixer>();
		}
	}
	internal static class EnemyDataPatch
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static hook_Start <0>__CreateAdditionalEnemyData;

			public static hook_HitEnemy <1>__HandleEnemyDeathData;

			public static hook_SetClientCalculatingAI <2>__HandleClientCalculatingAI;
		}

		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
			object obj = <>O.<0>__CreateAdditionalEnemyData;
			if (obj == null)
			{
				hook_Start val = CreateAdditionalEnemyData;
				<>O.<0>__CreateAdditionalEnemyData = val;
				obj = (object)val;
			}
			EnemyAI.Start += (hook_Start)obj;
			object obj2 = <>O.<1>__HandleEnemyDeathData;
			if (obj2 == null)
			{
				hook_HitEnemy val2 = HandleEnemyDeathData;
				<>O.<1>__HandleEnemyDeathData = val2;
				obj2 = (object)val2;
			}
			EnemyAI.HitEnemy += (hook_HitEnemy)obj2;
			object obj3 = <>O.<2>__HandleClientCalculatingAI;
			if (obj3 == null)
			{
				hook_SetClientCalculatingAI val3 = HandleClientCalculatingAI;
				<>O.<2>__HandleClientCalculatingAI = val3;
				obj3 = (object)val3;
			}
			EnemyAI.SetClientCalculatingAI += (hook_SetClientCalculatingAI)obj3;
		}

		private static void HandleClientCalculatingAI(orig_SetClientCalculatingAI orig, EnemyAI self, bool enable)
		{
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)self.agent == (Object)null)
			{
				orig.Invoke(self, enable);
				return;
			}
			bool enabled = ((Behaviour)self.agent).enabled;
			orig.Invoke(self, enable);
			DawnEnemyAdditionalData dawnEnemyAdditionalData = DawnEnemyAdditionalData.CreateOrGet(self);
			if ((Object)(object)dawnEnemyAdditionalData.SmartAgentNavigator != (Object)null && dawnEnemyAdditionalData.SmartAgentNavigator.CanTryToFlyToDestination && dawnEnemyAdditionalData.SmartAgentNavigator.pointToGo != Vector3.zero && dawnEnemyAdditionalData.SmartAgentNavigator.pointToStart != Vector3.zero)
			{
				((Behaviour)self.agent).enabled = enabled;
			}
		}

		private static void HandleEnemyDeathData(orig_HitEnemy orig, EnemyAI self, int force, PlayerControllerB playerWhoHit, bool playHitSFX, int hitID)
		{
			DawnEnemyAdditionalData dawnEnemyAdditionalData = DawnEnemyAdditionalData.CreateOrGet(self);
			ExtraEnemyEvents.eventListeners.TryGetValue(self, out ExtraEnemyEvents value);
			if (Object.op_Implicit((Object)(object)playerWhoHit))
			{
				dawnEnemyAdditionalData.PlayerThatLastHit = playerWhoHit;
			}
			if (!self.isEnemyDead && self.enemyHP - force <= 0)
			{
				if ((Object)(object)playerWhoHit != (Object)null)
				{
					dawnEnemyAdditionalData.KilledByPlayer = true;
					if (Object.op_Implicit((Object)(object)value))
					{
						value.onKilledByPlayer.Invoke();
					}
				}
				if (Object.op_Implicit((Object)(object)value))
				{
					value.onKilled.Invoke();
				}
			}
			orig.Invoke(self, force, playerWhoHit, playHitSFX, hitID);
		}

		private static void CreateAdditionalEnemyData(orig_Start orig, EnemyAI self)
		{
			orig.Invoke(self);
			DawnEnemyAdditionalData.CreateOrGet(self);
		}
	}
	internal static class ExtraItemEventsPatch
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static hook_OnBroughtToShip <0>__GrabbableObject_OnBroughtToShip;
		}

		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
			object obj = <>O.<0>__GrabbableObject_OnBroughtToShip;
			if (obj == null)
			{
				hook_OnBroughtToShip val = GrabbableObject_OnBroughtToShip;
				<>O.<0>__GrabbableObject_OnBroughtToShip = val;
				obj = (object)val;
			}
			GrabbableObject.OnBroughtToShip += (hook_OnBroughtToShip)obj;
		}

		private static void GrabbableObject_OnBroughtToShip(orig_OnBroughtToShip orig, GrabbableObject self)
		{
			orig.Invoke(self);
			if (ExtraItemEvents.eventListeners.TryGetValue(self, out ExtraItemEvents value))
			{
				value.onCollectInShip.Invoke();
			}
		}
	}
	internal static class ExtraScanEventsPatch
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static hook_AttemptScanNode <0>__OnAttemptScanNode;
		}

		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
			object obj = <>O.<0>__OnAttemptScanNode;
			if (obj == null)
			{
				hook_AttemptScanNode val = OnAttemptScanNode;
				<>O.<0>__OnAttemptScanNode = val;
				obj = (object)val;
			}
			HUDManager.AttemptScanNode += (hook_AttemptScanNode)obj;
		}

		private static void OnAttemptScanNode(orig_AttemptScanNode orig, HUDManager self, ScanNodeProperties node, int i, PlayerControllerB playerscript)
		{
			bool flag = self.scanNodes.ContainsValue(node);
			orig.Invoke(self, node, i, playerscript);
			ExtraScanEvents extraScanEvents = default(ExtraScanEvents);
			if (!flag && self.scanNodes.ContainsValue(node) && self.MeetsScanNodeRequirements(node, playerscript) && ((Component)node).gameObject.TryGetComponent<ExtraScanEvents>(ref extraScanEvents))
			{
				extraScanEvents.OnScan();
			}
		}
	}
	internal static class HandleCorruptedDataPatch
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static hook_Awake <0>__TryShowCorruptedWarning;

			public static hook_EraseFileAndRestart <1>__ErasePersistentDataContainers;
		}

		[CompilerGenerated]
		private sealed class <DelayedClose>d__2 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public float delay;

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

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

			[DebuggerHidden]
			public <DelayedClose>d__2(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_001e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0028: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForSeconds(delay);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					Application.Quit();
					return false;
				}
			}

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

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

		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
			object obj = <>O.<0>__TryShowCorruptedWarning;
			if (obj == null)
			{
				hook_Awake val = TryShowCorruptedWarning;
				<>O.<0>__TryShowCorruptedWarning = val;
				obj = (object)val;
			}
			PreInitSceneScript.Awake += (hook_Awake)obj;
			object obj2 = <>O.<1>__ErasePersistentDataContainers;
			if (obj2 == null)
			{
				hook_EraseFileAndRestart val2 = ErasePersistentDataContainers;
				<>O.<1>__ErasePersistentDataContainers = val2;
				obj2 = (object)val2;
			}
			PreInitSceneScript.EraseFileAndRestart += (hook_EraseFileAndRestart)obj2;
		}

		private static void ErasePersistentDataContainers(orig_EraseFileAndRestart orig, PreInitSceneScript self)
		{
			if (PersistentDataContainer.HasCorruptedData.Count > 0)
			{
				foreach (PersistentDataContainer hasCorruptedDatum in PersistentDataContainer.HasCorruptedData)
				{
					hasCorruptedDatum.DeleteFile();
				}
				((MonoBehaviour)self).StartCoroutine(DelayedClose(2f));
			}
			else
			{
				orig.Invoke(self);
			}
		}

		[IteratorStateMachine(typeof(<DelayedClose>d__2))]
		private static IEnumerator DelayedClose(float delay)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <DelayedClose>d__2(0)
			{
				delay = delay
			};
		}

		private static void TryShowCorruptedWarning(orig_Awake orig, PreInitSceneScript self)
		{
			orig.Invoke(self);
			int count = PersistentDataContainer.HasCorruptedData.Count;
			if (count <= 0)
			{
				return;
			}
			self.EnableFileCorruptedScreen();
			DawnPlugin.Logger.LogFatal((object)$"The following {count} PersistentDataContainer(s) failed to load:");
			foreach (PersistentDataContainer hasCorruptedDatum in PersistentDataContainer.HasCorruptedData)
			{
				DawnPlugin.Logger.LogFatal((object)(" - " + hasCorruptedDatum.FileName));
			}
			DawnPlugin.Logger.LogFatal((object)"If you wish to try recover the saved information, please ALT+F4 now.");
			DawnPlugin.Logger.LogFatal((object)"If you do not care, click the button to DELETE the missing files.");
			((Component)self.FileCorruptedDialoguePanel.transform.Find("NotificationText")).GetComponent<TMP_Text>().text = $"[DawnLib] Failed to read {count} PersistentDataContainer(s), your files may be corrupted. Read the console for more information. If you do not care, click the button below to DELETE the missing files.";
		}
	}
	internal static class MiscFixesPatch
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static hook_Start <0>__AddNetworkPrefabToNetworkConfig;

			public static hook_Start <1>__DoSoundFixes;

			public static hook_Start <2>__FixButlerBlankReferences;

			public static Action<Action<EnemyAINestSpawnObject>, EnemyAINestSpawnObject> <3>__FixNestBlankReferences;

			public static hook_Start <4>__FixKiwiBlankReferences;

			public static Action<Action<HauntedMaskItem>, HauntedMaskItem> <5>__FixHauntedMaskBlankReferences;

			public static hook_Start <6>__FixLungPropBlankReferences;

			public static Action <7>__FixTileSetSockets;

			public static Action <8>__FixItemSpawnPositionTypes;
		}

		internal static HashSet<GameObject> networkPrefabsToAdd = new HashSet<GameObject>();

		internal static HashSet<GameObject> soundPrefabsToFix = new HashSet<GameObject>();

		internal static HashSet<GameObject> tilesToFixSockets = new HashSet<GameObject>();

		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_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Expected O, but got Unknown
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Expected O, but got Unknown
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: 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
			object obj = <>O.<0>__AddNetworkPrefabToNetworkConfig;
			if (obj == null)
			{
				hook_Start val = AddNetworkPrefabToNetworkConfig;
				<>O.<0>__AddNetworkPrefabToNetworkConfig = val;
				obj = (object)val;
			}
			GameNetworkManager.Start += (hook_Start)obj;
			object obj2 = <>O.<1>__DoSoundFixes;
			if (obj2 == null)
			{
				hook_Start val2 = DoSoundFixes;
				<>O.<1>__DoSoundFixes = val2;
				obj2 = (object)val2;
			}
			MenuManager.Start += (hook_Start)obj2;
			object obj3 = <>O.<2>__FixButlerBlankReferences;
			if (obj3 == null)
			{
				hook_Start val3 = FixButlerBlankReferences;
				<>O.<2>__FixButlerBlankReferences = val3;
				obj3 = (object)val3;
			}
			ButlerEnemyAI.Start += (hook_Start)obj3;
			DawnPlugin.Hooks.Add(new Hook((MethodBase)AccessTools.DeclaredMethod(typeof(EnemyAINestSpawnObject), "Awake", (Type[])null, (Type[])null), (Delegate)new Action<Action<EnemyAINestSpawnObject>, EnemyAINestSpawnObject>(FixNestBlankReferences)));
			object obj4 = <>O.<4>__FixKiwiBlankReferences;
			if (obj4 == null)
			{
				hook_Start val4 = FixKiwiBlankReferences;
				<>O.<4>__FixKiwiBlankReferences = val4;
				obj4 = (object)val4;
			}
			GiantKiwiAI.Start += (hook_Start)obj4;
			DawnPlugin.Hooks.Add(new Hook((MethodBase)AccessTools.DeclaredMethod(typeof(HauntedMaskItem), "Awake", (Type[])null, (Type[])null), (Delegate)new Action<Action<HauntedMaskItem>, HauntedMaskItem>(FixHauntedMaskBlankReferences)));
			object obj5 = <>O.<6>__FixLungPropBlankReferences;
			if (obj5 == null)
			{
				hook_Start val5 = FixLungPropBlankReferences;
				<>O.<6>__FixLungPropBlankReferences = val5;
				obj5 = (object)val5;
			}
			LungProp.Start += (hook_Start)obj5;
			LethalContent.Dungeons.OnFreeze += FixTileSetSockets;
			LethalContent.Items.OnFreeze += FixItemSpawnPositionTypes;
		}

		private static void FixLungPropBlankReferences(orig_Start orig, LungProp self)
		{
			foreach (DawnEnemyInfo value in LethalContent.Enemies.Values)
			{
				if (value.Key.IsVanilla() && !((Object)(object)self.radMechEnemyType == (Object)null) && (((Object)value.EnemyType).name == ((Object)self.radMechEnemyType).name || value.EnemyType.enemyName == self.radMechEnemyType.enemyName) && (Object)(object)self.radMechEnemyType != (Object)(object)value.EnemyType)
				{
					self.radMechEnemyType = value.EnemyType;
					break;
				}
			}
			orig.Invoke(self);
		}

		private static void FixKiwiBlankReferences(orig_Start orig, GiantKiwiAI self)
		{
			foreach (DawnEnemyInfo value in LethalContent.Enemies.Values)
			{
				if (value.Key.IsVanilla() && !((Object)(object)self.baboonHawkType == (Object)null) && (((Object)value.EnemyType).name == ((Object)self.baboonHawkType).name || value.EnemyType.enemyName == self.baboonHawkType.enemyName) && (Object)(object)self.baboonHawkType != (Object)(object)value.EnemyType)
				{
					self.baboonHawkType = value.EnemyType;
					break;
				}
			}
			orig.Invoke(self);
		}

		private static void FixButlerBlankReferences(orig_Start orig, ButlerEnemyAI self)
		{
			foreach (DawnEnemyInfo value in LethalContent.Enemies.Values)
			{
				if (value.Key.IsVanilla() && !((Object)(object)self.butlerBeesEnemyType == (Object)null) && (((Object)value.EnemyType).name == ((Object)self.butlerBeesEnemyType).name || value.EnemyType.enemyName == self.butlerBeesEnemyType.enemyName) && (Object)(object)self.butlerBeesEnemyType != (Object)(object)value.EnemyType)
				{
					self.butlerBeesEnemyType = value.EnemyType;
					break;
				}
			}
			orig.Invoke(self);
		}

		private static void FixNestBlankReferences(Action<EnemyAINestSpawnObject> orig, EnemyAINestSpawnObject self)
		{
			foreach (DawnEnemyInfo value in LethalContent.Enemies.Values)
			{
				if (value.Key.IsVanilla() && !((Object)(object)self.enemyType == (Object)null) && (((Object)value.EnemyType).name == ((Object)self.enemyType).name || value.EnemyType.enemyName == self.enemyType.enemyName) && (Object)(object)self.enemyType != (Object)(object)value.EnemyType)
				{
					self.enemyType = value.EnemyType;
					break;
				}
			}
			orig.Invoke(self);
		}

		private static void FixHauntedMaskBlankReferences(Action<HauntedMaskItem> orig, HauntedMaskItem self)
		{
			foreach (DawnEnemyInfo value in LethalContent.Enemies.Values)
			{
				if (value.Key.IsVanilla() && !((Object)(object)self.mimicEnemy == (Object)null) && (((Object)value.EnemyType).name == ((Object)self.mimicEnemy).name || value.EnemyType.enemyName == self.mimicEnemy.enemyName) && (Object)(object)self.mimicEnemy != (Object)(object)value.EnemyType)
				{
					self.mimicEnemy = value.EnemyType;
					break;
				}
			}
			orig.Invoke(self);
		}

		private static void FixItemSpawnPositionTypes()
		{
			List<ItemGroup> list = new List<ItemGroup>();
			foreach (DawnItemInfo value in LethalContent.Items.Values)
			{
				if (!value.Key.IsVanilla())
				{
					continue;
				}
				foreach (ItemGroup spawnPositionType in value.Item.spawnPositionTypes)
				{
					if (!((Object)(object)spawnPositionType == (Object)null) && !list.Contains(spawnPositionType))
					{
						list.Add(spawnPositionType);
					}
				}
			}
			foreach (DawnItemInfo value2 in LethalContent.Items.Values)
			{
				if (value2.Key.IsVanilla())
				{
					continue;
				}
				ItemGroup[] array = value2.Item.spawnPositionTypes.ToArray();
				foreach (ItemGroup val in array)
				{
					if ((Object)(object)val == (Object)null)
					{
						continue;
					}
					foreach (ItemGroup item in list)
					{
						if (!((Object)(object)item == (Object)null) && ((Object)val).name == ((Object)item).name)
						{
							Debuggers.Items?.Log("Replacing non-vanilla spawn type " + ((Object)val).name + " with original.");
							value2.Item.spawnPositionTypes.Remove(val);
							value2.Item.spawnPositionTypes.Add(item);
						}
					}
				}
			}
		}

		private static void DoSoundFixes(orig_Start orig, MenuManager self)
		{
			orig.Invoke(self);
			AudioSource component = ((Component)self).gameObject.GetComponent<AudioSource>();
			if ((Object)(object)component == (Object)null)
			{
				return;
			}
			AudioMixer audioMixer = component.outputAudioMixerGroup.audioMixer;
			foreach (GameObject item in soundPrefabsToFix)
			{
				AudioSource[] componentsInChildren = item.GetComponentsInChildren<AudioSource>();
				AudioSource[] array = componentsInChildren;
				foreach (AudioSource val in array)
				{
					if (!((Object)(object)val.outputAudioMixerGroup == (Object)null) && !(((Object)val.outputAudioMixerGroup.audioMixer).name != "NonDiagetic"))
					{
						AudioMixerGroup val2 = audioMixer.FindMatchingGroups(((Object)val.outputAudioMixerGroup).name)[0];
						if (!((Object)(object)val2 == (Object)null))
						{
							val.outputAudioMixerGroup = val2;
							Debuggers.Sounds?.Log("Set mixer group for " + ((Object)val).name + " in " + ((Object)item).name + " to NonDiagetic:" + ((Object)val2).name);
						}
					}
				}
			}
			soundPrefabsToFix.Clear();
		}

		private static void FixTileSetSockets()
		{
			Dictionary<string, DoorwaySocket> dictionary = new Dictionary<string, DoorwaySocket>();
			foreach (DawnDungeonInfo value in LethalContent.Dungeons.Values)
			{
				Debuggers.Dungeons?.Log($"Mapping sockets for {value.Key}");
				foreach (DoorwaySocket socket in value.Sockets)
				{
					Debuggers.Dungeons?.Log(" - " + ((Object)socket).name);
					dictionary[((Object)socket).name] = socket;
				}
			}
			foreach (GameObject tilesToFixSocket in tilesToFixSockets)
			{
				Doorway[] componentsInChildren = tilesToFixSocket.GetComponentsInChildren<Doorway>();
				Doorway[] array = componentsInChildren;
				foreach (Doorway val in array)
				{
					val.socket = dictionary[((Object)val.socket).name];
				}
			}
			tilesToFixSockets.Clear();
		}

		private static void AddNetworkPrefabToNetworkConfig(orig_Start orig, GameNetworkManager self)
		{
			orig.Invoke(self);
			foreach (GameObject item in networkPrefabsToAdd)
			{
				if (!NetworkManager.Singleton.NetworkConfig.Prefabs.Contains(item))
				{
					NetworkManager.Singleton.AddNetworkPrefab(item);
				}
			}
			networkPrefabsToAdd.Clear();
		}
	}
	[HarmonyPatch]
	internal static class SaveDataPatch
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static hook_Start <0>__LCBetterSaveInit;

			public static hook_Start <1>__SetLastDawnVersion;

			public static hook_Start <2>__ResetInvalidSaveFiles;

			public static hook_DeleteFile <3>__ResetSaveFile;

			public static hook_ResetSavedGameValues <4>__ResetSaveFile;

			public static hook_AutoSaveShipData <5>__SaveData;

			public static Action<Action<PlaceableShipObject>, PlaceableShipObject> <6>__OnPlaceableShipObjectAwake;

			public static Action<Action<PlaceableShipObject>, PlaceableShipObject> <7>__OnPlaceableShipObjectOnDestroy;
		}

		private static readonly Regex SaveFileRegex = new Regex("^ContractLCSaveFile\\d+$");

		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
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Expected O, but got Unknown
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Expected O, but got Unknown
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Expected O, but got Unknown
			//IL_0136: Unknown result type (might be due to invalid IL or missing references)
			//IL_0140: Expected O, but got Unknown
			object obj = <>O.<0>__LCBetterSaveInit;
			if (obj == null)
			{
				hook_Start val = LCBetterSaveInit;
				<>O.<0>__LCBetterSaveInit = val;
				obj = (object)val;
			}
			MenuManager.Start += (hook_Start)obj;
			object obj2 = <>O.<1>__SetLastDawnVersion;
			if (obj2 == null)
			{
				hook_Start val2 = SetLastDawnVersion;
				<>O.<1>__SetLastDawnVersion = val2;
				obj2 = (object)val2;
			}
			MenuManager.Start += (hook_Start)obj2;
			object obj3 = <>O.<2>__ResetInvalidSaveFiles;
			if (obj3 == null)
			{
				hook_Start val3 = ResetInvalidSaveFiles;
				<>O.<2>__ResetInvalidSaveFiles = val3;
				obj3 = (object)val3;
			}
			MenuManager.Start += (hook_Start)obj3;
			object obj4 = <>O.<3>__ResetSaveFile;
			if (obj4 == null)
			{
				hook_DeleteFile val4 = ResetSaveFile;
				<>O.<3>__ResetSaveFile = val4;
				obj4 = (object)val4;
			}
			DeleteFileButton.DeleteFile += (hook_DeleteFile)obj4;
			object obj5 = <>O.<4>__ResetSaveFile;
			if (obj5 == null)
			{
				hook_ResetSavedGameValues val5 = ResetSaveFile;
				<>O.<4>__ResetSaveFile = val5;
				obj5 = (object)val5;
			}
			GameNetworkManager.ResetSavedGameValues += (hook_ResetSavedGameValues)obj5;
			object obj6 = <>O.<5>__SaveData;
			if (obj6 == null)
			{
				hook_AutoSaveShipData val6 = SaveData;
				<>O.<5>__SaveData = val6;
				obj6 = (object)val6;
			}
			StartOfRound.AutoSaveShipData += (hook_AutoSaveShipData)obj6;
			DawnPlugin.Hooks.Add(new Hook((MethodBase)AccessTools.DeclaredMethod(typeof(PlaceableShipObject), "Awake", (Type[])null, (Type[])null), (Delegate)new Action<Action<PlaceableShipObject>, PlaceableShipObject>(OnPlaceableShipObjectAwake)));
			DawnPlugin.Hooks.Add(new Hook((MethodBase)AccessTools.DeclaredMethod(typeof(PlaceableShipObject), "OnDestroy", (Type[])null, (Type[])null), (Delegate)new Action<Action<PlaceableShipObject>, PlaceableShipObject>(OnPlaceableShipObjectOnDestroy)));
		}

		private static List<string> GetDawnSaveFiles()
		{
			return Directory.EnumerateFiles(PersistentDataHandler.RootPath, "ContractLCSaveFile*", SearchOption.TopDirectoryOnly).Where(delegate(string file)
			{
				string fileName = Path.GetFileName(file);
				return SaveFileRegex.IsMatch(fileName);
			}).ToList();
		}

		private static void ResetInvalidSaveFiles(orig_Start orig, MenuManager self)
		{
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Expected O, but got Unknown
			if (!DawnPlugin.PersistentData.TryGet<string>(DawnKeys.LastVersion, out string value) || Version.Parse(value) <= Version.Parse("0.9.18"))
			{
				orig.Invoke(self);
				return;
			}
			string text = DawnKeys.DawnSave.ToString();
			foreach (string dawnSaveFile in GetDawnSaveFiles())
			{
				int length = dawnSaveFile.Length;
				int num = length - 1;
				int num2 = int.Parse(dawnSaveFile.Substring(num, length - num));
				string text2 = $"LCSaveFile{num2}";
				string text3 = Path.Combine(Application.persistentDataPath, text2);
				bool flag = File.Exists(text3);
				if (flag)
				{
					continue;
				}
				ES3Settings val = new ES3Settings(text3, (ES3Settings)null);
				if (!ES3.KeyExists(text, val))
				{
					PersistentDataContainer persistentDataContainer = DawnNetworker.CreateContractContainer(text2);
					persistentDataContainer.Clear();
					PersistentDataContainer persistentDataContainer2 = DawnNetworker.CreateSaveContainer(text2);
					persistentDataContainer2.Clear();
					Debuggers.SaveManager?.Log("Clearing potential invalid save: " + dawnSaveFile + ".");
					if (flag)
					{
						ES3.Save<bool>(text, true, val);
					}
				}
			}
			orig.Invoke(self);
		}

		private static void SetLastDawnVersion(orig_Start orig, MenuManager self)
		{
			orig.Invoke(self);
			DawnPlugin.PersistentData.Set(DawnKeys.LastVersion, "0.9.21");
		}

		private static void LCBetterSaveInit(orig_Start orig, MenuManager self)
		{
			orig.Invoke(self);
			if (LCBetterSaveCompat.Enabled)
			{
				LCBetterSaveCompat.Init();
			}
		}

		private static void OnPlaceableShipObjectAwake(Action<PlaceableShipObject> orig, PlaceableShipObject self)
		{
			PlaceableShipObject self2 = self;
			UnlockableSaveDataHandler.placeableShipObjects.Add(self2);
			orig.Invoke(self2);
			if ((Object)(object)self2.parentObject == (Object)null)
			{
				DawnPlugin.Logger.LogError((object)("Parent object is null for object: " + ((Object)((Component)self2).gameObject).name));
			}
			else if ((Object)(object)((NetworkBehaviour)self2.parentObject).NetworkObject == (Object)null)
			{
				DawnPlugin.Logger.LogError((object)("Network object is null for object: " + ((Object)((Component)self2.parentObject).gameObject).name));
			}
			else
			{
				if (!NetworkManager.Singleton.IsServer)
				{
					return;
				}
				((NetworkBehaviour)self2.parentObject).NetworkObject.OnSpawn(delegate
				{
					if (!((NetworkBehaviour)self2.parentObject).NetworkObject.TrySetParent(StartOfRoundRefs.Instance.shipAnimatorObject, true))
					{
						DawnPlugin.Logger.LogError((object)("Parenting of object: " + ((Object)((Component)self2.parentObject).gameObject).name + " failed."));
					}
				});
			}
		}

		private static void OnPlaceableShipObjectOnDestroy(Action<PlaceableShipObject> orig, PlaceableShipObject self)
		{
			UnlockableSaveDataHandler.placeableShipObjects.Remove(self);
			orig.Invoke(self);
		}

		[HarmonyPatch(typeof(StartOfRound), "LoadUnlockables")]
		[HarmonyPrefix]
		private static bool LoadUnlockables()
		{
			if (DawnConfig.DisableDawnUnlockableSaving.Value)
			{
				return true;
			}
			if (NetworkManager.Singleton.IsServer)
			{
				PersistentDataContainer dataContainer = DawnLib.GetCurrentContract() ?? DawnNetworker.CreateContractContainer(GameNetworkManager.Instance.currentSaveFileName);
				UnlockableSaveDataHandler.LoadSavedUnlockables(dataContainer);
			}
			return false;
		}

		[HarmonyPatch(typeof(StartOfRound), "LoadShipGrabbableItems")]
		[HarmonyPrefix]
		private static bool LoadShipGrabbableItems()
		{
			if (DawnConfig.DisableDawnItemSaving.Value)
			{
				return true;
			}
			PersistentDataContainer dataContainer = DawnLib.GetCurrentContract() ?? DawnNetworker.CreateContractContainer(GameNetworkManager.Instance.currentSaveFileName);
			ItemSaveDataHandler.LoadSavedItems(dataContainer);
			return false;
		}

		private static void SaveData(orig_AutoSaveShipData orig, StartOfRound self)
		{
			orig.Invoke(self);
			NetworkSingleton<DawnNetworker>.Instance?.SaveData();
		}

		[HarmonyPatch(typeof(GameNetworkManager), "SaveItemsInShip")]
		[HarmonyPrefix]
		private static bool SaveData()
		{
			NetworkSingleton<DawnNetworker>.Instance?.SaveData();
			if (DawnConfig.DisableDawnItemSaving.Value)
			{
				return true;
			}
			return false;
		}

		private static void ResetSaveFile(orig_ResetSavedGameValues orig, GameNetworkManager self)
		{
			orig.Invoke(self);
			PersistentDataContainer persistentDataContainer = NetworkSingleton<DawnNetworker>.Instance?.ContractContainer ?? DawnNetworker.CreateContractContainer(self.currentSaveFileName);
			persistentDataContainer.Clear();
		}

		private static void ResetSaveFile(orig_DeleteFile orig, DeleteFileButton self)
		{
			orig.Invoke(self);
			PersistentDataContainer persistentDataContainer = DawnNetworker.CreateContractContainer($"LCSaveFile{self.fileToDelete + 1}");
			persistentDataContainer.Clear();
			PersistentDataContainer persistentDataContainer2 = DawnNetworker.CreateSaveContainer($"LCSaveFile{self.fileToDelete + 1}");
			persistentDataContainer2.Clear();
		}
	}
	internal static class TerminalPatches
	{
		internal delegate void TextPostProcess(ref string currentText, TerminalNode node);

		[CompilerGenerated]
		private static class <>O
		{
			public static hook_LoadNewNodeIfAffordable <0>__HandlePredicate;

			public static hook_TextPostProcess <1>__UpdateItemPrices;

			public static hook_LoadNewNode <2>__UpdateItemPrices;

			public static hook_TextPostProcess <3>__HandleTerminalTextModifiers;

			public static Manipulator <4>__HideResults;

			public static Manipulator <5>__UseFailedNameResults;
		}

		internal static event TextPostProcess? OnProcessNodeText;

		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
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Expected O, but got Unknown
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Expected O, but got Unknown
			object obj = <>O.<0>__HandlePredicate;
			if (obj == null)
			{
				hook_LoadNewNodeIfAffordable val = HandlePredicate;
				<>O.<0>__HandlePredicate = val;
				obj = (object)val;
			}
			Terminal.LoadNewNodeIfAffordable += (hook_LoadNewNodeIfAffordable)obj;
			object obj2 = <>O.<1>__UpdateItemPrices;
			if (obj2 == null)
			{
				hook_TextPostProcess val2 = UpdateItemPrices;
				<>O.<1>__UpdateItemPrices = val2;
				obj2 = (object)val2;
			}
			Terminal.TextPostProcess += (hook_TextPostProcess)obj2;
			object obj3 = <>O.<2>__UpdateItemPrices;
			if (obj3 == null)
			{
				hook_LoadNewNode val3 = UpdateItemPrices;
				<>O.<2>__UpdateItemPrices = val3;
				obj3 = (object)val3;
			}
			Terminal.LoadNewNode += (hook_LoadNewNode)obj3;
			object obj4 = <>O.<3>__HandleTerminalTextModifiers;
			if (obj4 == null)
			{
				hook_TextPostProcess val4 = HandleTerminalTextModifiers;
				<>O.<3>__HandleTerminalTextModifiers = val4;
				obj4 = (object)val4;
			}
			Terminal.TextPostProcess += (hook_TextPostProcess)obj4;
			object obj5 = <>O.<4>__HideResults;
			if (obj5 == null)
			{
				Manipulator val5 = HideResults;
				<>O.<4>__HideResults = val5;
				obj5 = (object)val5;
			}
			Terminal.TextPostProcess += (Manipulator)obj5;
			object obj6 = <>O.<5>__UseFailedNameResults;
			if (obj6 == null)
			{
				Manipulator val6 = UseFailedNameResults;
				<>O.<5>__UseFailedNameResults = val6;
				obj6 = (object)val6;
			}
			Terminal.TextPostProcess += (Manipulator)obj6;
		}

		private static void UpdateItemPrices(orig_LoadNewNode orig, Terminal self, TerminalNode node)
		{
			ItemRegistrationHandler.UpdateAllShopItemPrices();
			UnlockableRegistrationHandler.UpdateAllUnlockablePrices();
			MoonRegistrationHandler.UpdateAllPrices();
			orig.Invoke(self, node);
		}

		private static void HideResults(ILContext il)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Expected O, but got Unknown
			//IL_018d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_033a: Unknown result type (might be due to invalid IL or missing references)
			//IL_038a: Unknown result type (might be due to invalid IL or missing references)
			ILCursor val = new ILCursor(il);
			ILLabel loopStart = null;
			Debuggers.Patching?.Log(string.Format("transpiling {0} with {1}. instructions: {2}", ((MemberReference)il.Method).Name, "HideResults", val.Instrs.Count));
			val.GotoNext(new Func<Instruction, bool>[6]
			{
				(Instruction i) => ILPatternMatchingExt.MatchLdloc(i, 7),
				(Instruction i) => ILPatternMatchingExt.MatchLdarg(i, 0),
				(Instruction i) => ILPatternMatchingExt.MatchLdfld<Terminal>(i, "buyableItemsList"),
				(Instruction i) => ILPatternMatchingExt.MatchLdlen(i),
				(Instruction i) => ILPatternMatchingExt.MatchConvI4(i),
				(Instruction i) => ILPatternMatchingExt.MatchBlt(i, ref loopStart)
			});
			int num = val.Index + 2;
			Debuggers.Patching?.Log($"target index = {num}");
			Debuggers.Patching?.Log($"loopStart = {loopStart}, target = {loopStart.Target}, offset = {loopStart.Target.Offset}");
			val.GotoLabel(loopStart, (MoveType)1, false);
			val.Emit(OpCodes.Ldarg_0);
			val.EmitLdfld<Terminal>("buyableItemsList");
			val.EmitLdloc(7);
			val.Emit(OpCodes.Ldelem_Ref);
			val.EmitDelegate<Func<Item, bool>>((Func<Item, bool>)delegate(Item item)
			{
				Debuggers.Items?.Log("Checking " + item.itemName);
				DawnItemInfo dawnInfo2 = item.GetDawnInfo();
				DawnShopItemInfo shopInfo = dawnInfo2.ShopInfo;
				if (shopInfo == null)
				{
					return true;
				}
				TerminalPurchaseResult terminalPurchaseResult2 = shopInfo.DawnPurchaseInfo.PurchasePredicate.CanPurchase();
				if (terminalPurchaseResult2 is TerminalPurchaseResult.HiddenPurchaseResult)
				{
					Debuggers.Items?.Log($"Hiding {dawnInfo2.Key}");
					return false;
				}
				return true;
			});
			val.Emit(OpCodes.Brfalse, val.Instrs[num]);
			Debuggers.Patching?.Log("did shopitem hidden patch!");
			val.Index = 0;
			val.GotoNext(new Func<Instruction, bool>[4]
			{
				(Instruction i) => ILPatternMatchingExt.MatchLdloc(i, 15),
				(Instruction i) => ILPatternMatchingExt.MatchLdcI4(i, 1),
				(Instruction i) => ILPatternMatchingExt.MatchAdd(i),
				(Instruction i) => ILPatternMatchingExt.MatchStloc(i, 15)
			});
			val.GotoNext(new Func<Instruction, bool>[1]
			{
				(Instruction i) => ILPatternMatchingExt.MatchBlt(i, ref loopStart)
			});
			num = val.Index - 2;
			Debuggers.Patching?.Log($"decors target index = {num}");
			Debuggers.Patching?.Log($"decors loopStart = {loopStart}, decors target = {loopStart.Target}, decors offset = {loopStart.Target.Offset}");
			val.GotoLabel(loopStart, (MoveType)1, false);
			val.Emit(OpCodes.Ldarg_0);
			val.EmitLdfld<Terminal>("ShipDecorSelection");
			val.EmitLdloc(15);
			val.EmitCallvirt<List<TerminalNode>>("get_Item");
			val.EmitDelegate<Func<TerminalNode, bool>>((Func<TerminalNode, bool>)delegate(TerminalNode unlockableNode)
			{
				Debuggers.Items?.Log("Checking " + unlockableNode.creatureName);
				if (unlockableNode.shipUnlockableID < 0 || unlockableNode.shipUnlockableID > StartOfRound.Instance.unlockablesList.unlockables.Count)
				{
					DawnPlugin.Logger.LogWarning((object)$"{unlockableNode.creatureName} ({((Object)unlockableNode).name}) has a ship unlockable id of {unlockableNode.shipUnlockableID} which doesn't make sense.");
					return true;
				}
				UnlockableItem val2 = StartOfRound.Instance.unlockablesList.unlockables[unlockableNode.shipUnlockableID];
				DawnUnlockableItemInfo dawnInfo = val2.GetDawnInfo();
				if (dawnInfo == null)
				{
					DawnPlugin.Logger.LogWarning((object)(unlockableNode.creatureName + " (" + ((Object)unlockableNode).name + ") of " + val2.unlockableName + " has no dawn info."));
					return true;
				}
				TerminalPurchaseResult terminalPurchaseResult = dawnInfo.DawnPurchaseInfo.PurchasePredicate.CanPurchase();
				if (terminalPurchaseResult is TerminalPurchaseResult.HiddenPurchaseResult)
				{
					Debuggers.Unlockables?.Log($"Hiding {dawnInfo.Key}");
					return false;
				}
				return true;
			});
			val.Emit(OpCodes.Brfalse, val.Instrs[num]);
		}

		private static string HandleTerminalTextModifiers(orig_TextPostProcess orig, Terminal self, string modifieddisplaytext, TerminalNode node)
		{
			modifieddisplaytext = orig.Invoke(self, modifieddisplaytext, node);
			TerminalPatches.OnProcessNodeText?.Invoke(ref modifieddisplaytext, node);
			return modifieddisplaytext;
		}

		private static string UpdateItemPrices(orig_TextPostProcess orig, Terminal self, string modifieddisplaytext, TerminalNode node)
		{
			ItemRegistrationHandler.UpdateAllShopItemPrices();
			UnlockableRegistrationHandler.UpdateAllUnlockablePrices();
			MoonRegistrationHandler.UpdateAllPrices();
			return orig.Invoke(self, modifieddisplaytext, node);
		}

		internal static void UseFailedNameResults(ILContext il)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			ILCursor val = new ILCursor(il);
			DawnPlugin.Logger.LogDebug((object)string.Format("transpiling {0} with {1}. instructions: {2}", ((MemberReference)il.Method).Name, "UseFailedNameResults", val.Instrs.Count));
			if (val.TryGotoNext(new Func<Instruction, bool>[1]
			{
				(Instruction i) => ILPatternMatchingExt.MatchLdfld<Item>(i, "itemName")
			}))
			{
				val.Next.OpCode = OpCodes.Nop;
				val.EmitDelegate<Func<Item, string>>((Func<Item, string>)delegate(Item item)
				{
					if (!item.HasDawnInfo())
					{
						DawnPlugin.Logger.LogWarning((object)("Item: " + item.itemName + " hasn't been found by DawnLib prior to the terminal being run, please report this!"));
						return item.itemName;
					}
					DawnItemInfo dawnInfo2 = item.GetDawnInfo();
					DawnShopItemInfo shopInfo = dawnInfo2.ShopInfo;
					if (shopInfo == null)
					{
						return item.itemName;
					}
					TerminalPurchaseResult terminalPurchaseResult2 = shopInfo.DawnPurchaseInfo.PurchasePredicate.CanPurchase();
					if (terminalPurchaseResult2 is TerminalPurchaseResult.FailedPurchaseResult failedPurchaseResult2)
					{
						if (failedPurchaseResult2.OverrideName != null)
						{
							Debuggers.Items?.Log($"Overriding name of {dawnInfo2.Key} with {failedPurchaseResult2.OverrideName}");
						}
						return failedPurchaseResult2.OverrideName ?? item.itemName;
					}
					return item.itemName;
				});
			}
			val.Index = 0;
			if (!val.TryGotoNext(new Func<Instruction, bool>[1]
			{
				(Instruction i) => ILPatternMatchingExt.MatchLdfld<UnlockableItem>(i, "unlockableName")
			}))
			{
				return;
			}
			val.Next.OpCode = OpCodes.Nop;
			val.EmitDelegate<Func<UnlockableItem, string>>((Func<UnlockableItem, string>)delegate(UnlockableItem unlockable)
			{
				if (!unlockable.HasDawnInfo())
				{
					DawnPlugin.Logger.LogWarning((object)("Unlockable: " + unlockable.unlockableName + " hasn't been found by DawnLib prior to the terminal being run, please report this!"));
					return unlockable.unlockableName;
				}
				DawnUnlockableItemInfo dawnInfo = unlockable.GetDawnInfo();
				TerminalPurchaseResult terminalPurchaseResult = dawnInfo.DawnPurchaseInfo.PurchasePredicate.CanPurchase();
				if (terminalPurchaseResult is TerminalPurchaseResult.FailedPurchaseResult failedPurchaseResult && !string.IsNullOrEmpty(failedPurchaseResult.OverrideName))
				{
					Debuggers.Unlockables?.Log($"Overriding name of {dawnInfo.Key} with {failedPurchaseResult.OverrideName}");
					return failedPurchaseResult.OverrideName;
				}
				return unlockable.unlockableName;
			});
		}

		private static void HandlePredicate(orig_LoadNewNodeIfAffordable orig, Terminal self, TerminalNode node)
		{
			Debuggers.Patching?.Log($"HandlePredicate: {node}");
			ItemRegistrationHandler.UpdateAllShopItemPrices();
			UnlockableRegistrationHandler.UpdateAllUnlockablePrices();
			ITerminalPurchase terminalPurchase = null;
			if (node.buyItemIndex != -1)
			{
				Debuggers.Patching?.Log($"buyItemIndex = {node.buyItemIndex}");
				Item val = self.buyableItemsList[node.buyItemIndex];
				if (!val.HasDawnInfo())
				{
					DawnPlugin.Logger.LogWarning((object)("Item: " + val.itemName + " hasn't been found by DawnLib prior to the terminal being run, please report this!"));
					orig.Invoke(self, node);
					return;
				}
				DawnItemInfo dawnInfo = val.GetDawnInfo();
				DawnShopItemInfo shopInfo = dawnInfo.ShopInfo;
				if (shopInfo != null)
				{
					terminalPurchase = shopInfo.DawnPurchaseInfo;
				}
			}
			if (node.shipUnlockableID != -1)
			{
				Debuggers.Patching?.Log($"shipUnlockableID = {node.shipUnlockableID}");
				UnlockableItem val2 = StartOfRound.Instance.unlockablesList.unlockables[node.shipUnlockableID];
				if (!val2.HasDawnInfo())
				{
					DawnPlugin.Logger.LogWarning((object)("Unlockable: " + val2.unlockableName + " hasn't been found by DawnLib prior to the terminal being run, please report this!"));
					orig.Invoke(self, node);
					return;
				}
				DawnUnlockableItemInfo dawnInfo2 = val2.GetDawnInfo();
				terminalPurchase = dawnInfo2.DawnPurchaseInfo;
			}
			if (node.buyRerouteToMoon >= 0)
			{
				Debuggers.Patching?.Log($"buyRerouteToMoon = {node.buyRerouteToMoon}");
				terminalPurchase = StartOfRound.Instance.levels[node.buyRerouteToMoon].GetDawnInfo().DawnPurchaseInfo;
			}
			if (terminalPurchase != null)
			{
				Debuggers.Patching?.Log("has predicate");
				TerminalPurchaseResult terminalPurchaseResult = terminalPurchase.PurchasePredicate.CanPurchase();
				if (terminalPurchaseResult is TerminalPurchaseResult.FailedPurchaseResult failedPurchaseResult)
				{
					Debuggers.Patching?.Log("predicate fail");
					self.LoadNewNode(failedPurchaseResult.ReasonNode);
					return;
				}
				if (terminalPurchaseResult is TerminalPurchaseResult.HiddenPurchaseResult hiddenPurchaseResult && hiddenPurchaseResult.IsFailure)
				{
					Debuggers.Patching?.Log("predicate hidden failure");
					self.LoadNewNode(hiddenPurchaseResult.ReasonNode);
					return;
				}
			}
			orig.Invoke(self, node);
		}
	}
	internal static class PersistentDataHandler
	{
		private static Dictionary<BaseUnityPlugin, PersistentDataContainer> _containers = new Dictionary<BaseUnityPlugin, PersistentDataContainer>();

		internal static readonly string RootPath = Path.Combine(Application.persistentDataPath, "DawnLib");

		internal static void Init()
		{
			Directory.CreateDirectory(Path.Combine(RootPath, "PluginData"));
		}

		internal static PersistentDataContainer Get(BaseUnityPlugin plugin)
		{
			if (_containers.TryGetValue(plugin, out PersistentDataContainer value))
			{
				return value;
			}
			BepInPlugin metadata = MetadataHelper.GetMetadata(((object)plugin).GetType());
			value = new PersistentDataContainer(Path.Combine(RootPath, "PluginData", metadata.GUID + ".dawndata"));
			_containers[plugin] = value;
			return value;
		}
	}
	public static class ItemDropshipRefs
	{
		private static ItemDropship _instance;

		public static ItemDropship Instance
		{
			get
			{
				if ((Object)(object)_instance == (Object)null)
				{
					_instance = Object.FindFirstObjectByType<ItemDropship>();
				}
				return _instance;
			}
		}
	}
	public static class QuickMenuManagerRefs
	{
		private static QuickMenuManager _instance;

		public static QuickMenuManager Instance
		{
			get
			{
				if ((Object)(object)_instance == (Object)null)
				{
					_instance = Object.FindFirstObjectByType<QuickMenuManager>();
				}
				return _instance;
			}
		}
	}
	public static class RoundManagerRefs
	{
		private static RoundManager _instance;

		public static RoundManager Instance
		{
			get
			{
				if ((Object)(object)_instance == (Object)null)
				{
					if ((Object)(object)RoundManager.Instance != (Object)null)
					{
						_instance = RoundManager.Instance;
					}
					else
					{
						_instance = Object.FindFirstObjectByType<RoundManager>();
					}
				}
				return _instance;
			}
		}
	}
	public static class StartMatchLeverRefs
	{
		private static StartMatchLever _instance;

		public static StartMatchLever Instance
		{
			get
			{
				if ((Object)(object)_instance == (Object)null)
				{
					_instance = Object.FindFirstObjectByType<StartMatchLever>();
				}
				return _instance;
			}
		}
	}
	public static class StartOfRoundRefs
	{
		private static StartOfRound _instance;

		public static StartOfRound Instance
		{
			get
			{
				if ((Object)(object)_instance == (Object)null)
				{
					if ((Object)(object)StartOfRound.Instance != (Object)null)
					{
						_instance = StartOfRound.Instance;
					}
					else
					{
						_instance = Object.FindFirstObjectByType<StartOfRound>();
					}
				}
				return _instance;
			}
		}
	}
	public static class TerminalRefs
	{
		private static Terminal _instance;

		public static Terminal Instance
		{
			get
			{
				if ((Object)(object)_instance == (Object)null)
				{
					_instance = Object.FindFirstObjectByType<Terminal>();
					if ((Object)(object)_instance == (Object)null)
					{
						return null;
					}
					BuyKeyword = _instance.terminalNodes.allKeywords.First((TerminalKeyword keyword) => keyword.word == "buy");
					InfoKeyword = _instance.terminalNodes.allKeywords.First((TerminalKeyword keyword) => keyword.word == "info");
					RouteKeyword = _instance.terminalNodes.allKeywords.First((TerminalKeyword keyword) => keyword.word == "route");
					ViewKeyword = _instance.terminalNodes.allKeywords.First((TerminalKeyword keyword) => keyword.word == "view");
					ConfirmPurchaseKeyword = _instance.terminalNodes.allKeywords.First((TerminalKeyword keyword) => keyword.word == "confirm");
					DenyKeyword = _instance.terminalNodes.allKeywords.First((TerminalKeyword keyword) => keyword.word == "deny");
					MoonsKeyword = _instance.terminalNodes.allKeywords.First((TerminalKeyword keyword) => keyword.word == "moons");
					CancelPurchaseNode = BuyKeyword.compatibleNouns[0].result.terminalOptions[1].result;
					CancelRouteNode = RouteKeyword.compatibleNouns[0].result.terminalOptions[0].result;
					MoonCatalogueNode = MoonsKeyword.specialKeywordResult;
				}
				return _instance;
			}
		}

		public static TerminalKeyword BuyKeyword { get; private set; }

		public static TerminalKeyword InfoKeyword { get; private set; }

		public static TerminalKeyword RouteKeyword { get; private set; }

		public static TerminalKeyword ConfirmPurchaseKeyword { get; private set; }

		public static TerminalKeyword DenyKeyword { get; private set; }

		public static TerminalKeyword ViewKeyword { get; internal set; }

		public static TerminalKeyword MoonsKeyword { get; private set; }

		public static TerminalNode CancelPurchaseNode { get; private set; }

		public static TerminalNode CancelRouteNode { get; private set; }

		public static TerminalNode MoonCatalogueNode { get; private set; }

		public static int LastVehicleDelivered { get; internal set; } = -1;

	}
	public static class TimeOfDayRefs
	{
		private static TimeOfDay _instance;

		public static TimeOfDay Instance
		{
			get
			{
				if ((Object)(object)_instance == (Object)null)
				{
					if ((Object)(object)TimeOfDay.Instance != (Object)null)
					{
						_instance = TimeOfDay.Instance;
					}
					else
					{
						_instance = Object.FindFirstObjectByType<TimeOfDay>();
					}
				}
				return _instance;
			}
		}

		public static WeatherEffect? GetCurrentWeatherEffect(SelectableLevel? selectableLevel)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Invalid comparison between Unknown and I4
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			WeatherEffect result = null;
			if ((Object)(object)selectableLevel != (Object)null && (int)selectableLevel.currentWeather != -1)
			{
				result = TimeOfDay.Instance.effects[selectableLevel.currentWeather];
			}
			return result;
		}
	}
	internal static class DawnNetworkSceneManager
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static hook_GenerateScenesInBuild <0>__LogExtraDebugInformation;

			public static hook_SceneHashFromNameOrPath <1>__HashFromScene;

			public static hook_ScenePathFromHash <2>__SceneFromHash;

			public static hook_ValidateSceneEvent <3>__ValidateSceneEvent;
		}

		private static readonly Dictionary<string, uint> _pathToHash = new Dictionary<string, uint>();

		private static readonly Dictionary<uint, string> _hashToPath = new Dictionary<uint, string>();

		private static readonly Dictionary<string, string> _nameToPath = new Dictionary<string, string>();

		internal static void AddScenePath(string scenePath)
		{
			string sceneNameFromPath = GetSceneNameFromPath(scenePath);
			uint num = XXHash.Hash32(scenePath);
			_pathToHash[scenePath] = num;
			_hashToPath[num] = scenePath;
			_nameToPath[sceneNameFromPath] = scenePath;
			Debuggers.SceneManager?.Log($"Added new network scene: '{sceneNameFromPath}' (hash: {num})");
		}

		internal static string GetSceneNameFromPath(string scenePath)
		{
			int num = scenePath.LastIndexOf("/", StringComparison.Ordinal) + 1;
			int num2 = scenePath.LastIndexOf(".", StringComparison.Ordinal);
			return scenePath.Substring(num, num2 - num);
		}

		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>__LogExtraDebugInformation;
			if (obj == null)
			{
				hook_GenerateScenesInBuild val = LogExtraDebugInformation;
				<>O.<0>__LogExtraDebugInformation = val;
				obj = (object)val;
			}
			NetworkSceneManager.GenerateScenesInBuild += (hook_GenerateScenesInBuild)obj;
			object obj2 = <>O.<1>__HashFromScene;
			if (obj2 == null)
			{
				hook_SceneHashFromNameOrPath val2 = HashFromScene;
				<>O.<1>__HashFromScene = val2;
				obj2 = (object)val2;
			}
			NetworkSceneManager.SceneHashFromNameOrPath += (hook_SceneHashFromNameOrPath)obj2;
			object obj3 = <>O.<2>__SceneFromHash;
			if (obj3 == null)
			{
				hook_ScenePathFromHash val3 = SceneFromHash;
				<>O.<2>__SceneFromHash = val3;
				obj3 = (object)val3;
			}
			NetworkSceneManager.ScenePathFromHash += (hook_ScenePathFromHash)obj3;
			object obj4 = <>O.<3>__ValidateSceneEvent;
			if (obj4 == null)
			{
				hook_ValidateSceneEvent val4 = ValidateSceneEvent;
				<>O.<3>__ValidateSceneEvent = val4;
				obj4 = (object)val4;
			}
			NetworkSceneManager.ValidateSceneEvent += (hook_ValidateSceneEvent)obj4;
		}

		private static void LogExtraDebugInformation(orig_GenerateScenesInBuild orig, NetworkSceneManager self)
		{
			orig.Invoke(self);
			Debuggers.SceneManager?.Log($"DawnLibSceneManager has {_nameToPath.Count} scenes.");
		}

		private static string SceneFromHash(orig_ScenePathFromHash orig, NetworkSceneManager self, uint sceneHash)
		{
			if (_hashToPath.TryGetValue(sceneHash, out string value))
			{
				return value;
			}
			return orig.Invoke(self, sceneHash);
		}

		private static uint HashFromScene(orig_SceneHashFromNameOrPath orig, NetworkSceneManager self, string sceneNameOrPath)
		{
			if (_nameToPath.TryGetValue(sceneNameOrPath, out string value))
			{
				return _pathToHash[value];
			}
			if (_pathToHash.TryGetValue(sceneNameOrPath, out var value2))
			{
				return value2;
			}
			return orig.Invoke(self, sceneNameOrPath);
		}

		private static object ValidateSceneEvent(orig_ValidateSceneEvent orig, NetworkSceneManager self, string sceneName, bool isUnloading)
		{
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Expected O, but got Unknown
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Expected O, but got Unknown
			Debuggers.SceneManager?.Log($"On.ValidateSceneEvent: {sceneName}, {isUnloading}");
			if (_nameToPath.TryGetValue(sceneName, out string value))
			{
				Debuggers.SceneManager?.Log("_nameToPath hit");
				SceneEventProgress val = new SceneEventProgress(self.NetworkManager, (SceneEventProgressStatus)1)
				{
					SceneHash = _pathToHash[value]
				};
				self.SceneEventProgressTracking.Add(val.Guid, val);
				self.m_IsSceneEventActive = true;
				val.OnComplete = new OnCompletedDelegate(self.OnSceneEventProgressCompleted);
				return val;
			}
			return orig.Invoke(self, sceneName, isUnloading);
		}
	}
	internal static class TagExporter
	{
		private const string _datetimeFormat = "dd_MM_yyyy-HH_mm";

		private static StreamWriter _outputFile;

		internal static void Init()
		{
			Directory.CreateDirectory(GetFolder());
			_outputFile = new StreamWriter(Path.Combine(GetFolder(), GetFileName(".md")));
			Application.quitting += delegate
			{
				_outputFile.Close();
				_outputFile.Dispose();
			};
			AddRegistry("Enemies", LethalContent.Enemies);
			AddRegistry("Moons", LethalContent.Moons);
			AddRegistry("MapObjects", LethalContent.MapObjects);
			AddRegistry("Items", LethalContent.Items);
			AddRegistry("Weathers", LethalContent.Weathers);
			AddRegistry("Dungeons", LethalContent.Dungeons);
			AddRegistry("Unlockables", LethalContent.Unlockables);
		}

		private static string GetFileName(string extension)
		{
			return DateTime.Now.ToString("dd_MM_yyyy-HH_mm") + extension;
		}

		private static string GetFolder()
		{
			return Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "tag-exports");
		}

		private static void AddRegistry<T>(string name, TaggedRegistry<T> registry) where T : DawnBaseInfo<T>
		{
			string name2 = name;
			TaggedRegistry<T> registry2 = registry;
			registry2.AfterTagging += delegate
			{
				_outputFile.WriteLine("## " + name2);
				foreach (var (arg, val2) in registry2)
				{
					_outputFile.WriteLine($"{arg}:");
					WriteList(_outputFile, from it in val2.AllTags()
						select it.ToString());
					_outputFile.WriteLine("");
					_outputFile.WriteLine("");
				}
				_outputFile.Flush();
			};
		}

		private static void WriteList(StreamWriter stream, IEnumerable<string> list)
		{
			stream.WriteLine(string.Join("<br/>\n", list.Select((string it) => "- " + it)));
		}
	}
	[Serializable]
	public class StringEvent : UnityEvent<string>
	{
	}
	[Serializable]
	public class FloatEvent : UnityEvent<float>
	{
	}
	[Serializable]
	public class IntEvent : UnityEvent<int>
	{
	}
	[Serializable]
	public class BoolEvent : UnityEvent<bool>
	{
	}
	[Serializable]
	public class Vector3Event : UnityEvent<Vector3>
	{
	}
	[Serializable]
	public class ColorEvent : UnityEvent<Color>
	{
	}
	[Serializable]
	public class AnimationCurveEvent : UnityEvent<AnimationCurve>
	{
	}
	[Serializable]
	public class BoundedRangeEvent : UnityEvent<BoundedRange>
	{
	}
	public class PlayerNameplateUI : MonoBehaviour
	{
		[SerializeField]
		private RawImage _image;

		[SerializeField]
		private TMP_Text _usernameText;

		public Color TextColor
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				return ((Graphic)_usernameText).color;
			}
			set
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				((Graphic)_usernameText).color = value;
			}
		}

		public async void Setup(PlayerControllerB player)
		{
			try
			{
				Image? val = await SteamFriends.GetLargeAvatarAsync(SteamId.op_Implicit(player.playerSteamId));
				_image.texture = (Texture)(object)HUDManager.GetTextureFromImage(val);
			}
			catch (Exception ex)
			{
				DawnPlugin.Logger.LogDebug((object)"Hiding error for `PlayerNameplateUI.Setup` because it's like a false positive.");
				DawnPlugin.Logger.LogDebug((object)("Failed to set up player nameplate UI for player " + player.playerUsername + ": " + ex.Message));
			}
			_usernameText.text = player.playerUsername;
		}
	}
	public class RouteProgressUI : Singleton<RouteProgressUI>
	{
		[Serializable]
		public class BundleStateColour
		{
			public DawnMoonNetworker.BundleState State;

			public Color Color;
		}

		[Header("Progress Bar")]
		[SerializeField]
		private TMP_Text _routingToText;

		[SerializeField]
		private Slider _progressSlider;

		[Header("Nameplate UI")]
		[SerializeField]
		private PlayerNameplateUI _nameplatePrefab;

		[SerializeField]
		private Transform _nameplateParent;

		[SerializeField]
		private List<BundleStateColour> _colours;

		private Dictionary<PlayerControllerB, PlayerNameplateUI> _nameplates = new Dictionary<PlayerControllerB, PlayerNameplateUI>();

		private float _targetProgress;

		private List<Image> imagesToBeRedOrBlue = new List<Image>();

		private void Start()
		{
			Image[] componentsInChildren = ((Component)_progressSlider).GetComponentsInChildren<Image>();
			foreach (Image val in componentsInChildren)
			{
				if (!(((Object)((Component)val).gameObject).name != "Fill") || !(((Object)((Component)val).gameObject).name != "ShipIcon"))
				{
					imagesToBeRedOrBlue.Add(val);
				}
			}
			((Component)this).gameObject.SetActive(false);
		}

		public void Refresh(Dictionary<PlayerControllerB, DawnMoonNetworker.BundleState> states)
		{
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_015f: Unknown result type (might be due to invalid IL or missing references)
			float num = states.Count;
			float num2 = 0f;
			bool flag = false;
			using (Dictionary<PlayerControllerB, DawnMoonNetworker.BundleState>.ValueCollection.Enumerator enumerator = states.Values.GetEnumerator())
			{
				while (enumerator.MoveNext())
				{
					switch (enumerator.Current)
					{
					case DawnMoonNetworker.BundleState.Error:
						flag = true;
						goto end_IL_005a;
					case DawnMoonNetworker.BundleState.Queued:
						num2 += 0.25f;
						break;
					case DawnMoonNetworker.BundleState.Loading:
						num2 += 0.65f;
						break;
					case DawnMoonNetworker.BundleState.Done:
						num2 += 1f;
						break;
					}
					continue;
					end_IL_005a:
					break;
				}
			}
			if (flag)
			{
				foreach (Image item in imagesToBeRedOrBlue)
				{
					((Graphic)item).color = Color.red;
				}
			}
			_targetProgress = num2 / num;
			foreach (PlayerControllerB key in _nameplates.Keys)
			{
				if (!states.ContainsKey(key))
				{
					Object.Destroy((Object)(object)((Component)_nameplates[key]).gameObject);
					_nameplates.Remove(key);
				}
			}
			foreach (PlayerControllerB key2 in states.Keys)
			{
				if (!_nameplates.TryGetValue(key2, out PlayerNameplateUI value))
				{
					value = CreateUI(key2);
				}
				value.TextColor = GetBundleStateColour(states[key2]);
			}
		}

		private void Update()
		{
			_progressSlider.value = Mathf.Lerp(_progressSlider.value, _targetProgress, Time.deltaTime);
		}

		public void Setup(string moonName)
		{
			_routingToText.text = "  " + moonName;
			_nameplateParent.KillAllChildren();
			_nameplates.Clear();
			_progressSlider.value = 0f;
			_targetProgress = 0f;
		}

		private PlayerNameplateUI CreateUI(PlayerControllerB player)
		{
			PlayerNameplateUI playerNameplateUI = Object.Instantiate<PlayerNameplateUI>(_nameplatePrefab, _nameplateParent);
			playerNameplateUI.Setup(player);
			_nameplates[player] = playerNameplateUI;
			return playerNameplateUI;
		}

		private Color GetBundleStateColour(DawnMoonNetworker.BundleState state)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			return _colours.FirstOrDefault((BundleStateColour it) => it.State == state)?.Color ?? Color.magenta;
		}
	}
	public static class UnlockableSaveDataHandler
	{
		public struct UnlockableSaveData
		{
			public NamespacedKey UnlockableNamespacedKey;

			[JsonConverter(typeof(Vector3Converter))]
			public Vector3 SavedSpawnPosition;

			[JsonConverter(typeof(Vector3Converter))]
			public Vector3 SavedSpawnRotation;

			public bool InStorage;

			public bool HasBeenMoved;

			public bool PlacedAtQuotaStart;

			public JToken SavedData;

			public UnlockableSaveData(NamespacedKey unlockableNamespacedKey, Vector3 savePosition, Vector3 saveRotation, bool inStorage, bool hasBeenMoved, bool placedAtQuotaStart, JToken savedData)
			{
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				//IL_0009: Unknown result type (might be due to invalid IL or missing references)
				//IL_000f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0010: Unknown result type (might be due to invalid IL or missing references)
				UnlockableNamespacedKey = unlockableNamespacedKey;
				SavedSpawnPosition = savePosition;
				SavedSpawnRotation = saveRotation;
				InStorage = inStorage;
				HasBeenMoved = hasBeenMoved;
				PlacedAtQuotaStart = placedAtQuotaStart;
				SavedData = savedData;
			}
		}

		internal static List<PlaceableShipObject> placeableShipObjects = new List<PlaceableShipObject>();

		internal static void LoadSavedUnlockables(PersistentDataContainer dataContainer)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0221: Unknown result type (might be due to invalid IL or missing references)
			//IL_022b: 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_02b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02be: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0311: Unknown result type (might be due to invalid IL or missing references)
			//IL_0318: Unknown result type (might be due to invalid IL or missing references)
			JObject val = TryGetNewFormat(dataContainer);
			if (val == null)
			{
				val = TryMigrateLegacyFormat(dataContainer);
				if (val == null)
				{
					return;
				}
			}
			JToken obj = val["keys"];
			JArray val2 = (JArray)(((object)((obj is JArray) ? obj : null)) ?? ((object)new JArray()));
			JToken obj2 = val["items"];
			JArray val3 = (JArray)(((object)((obj2 is JArray) ? obj2 : null)) ?? ((object)new JArray()));
			List<int> list = new List<int>();
			Vector3 val5 = default(Vector3);
			Vector3 val6 = default(Vector3);
			foreach (JToken item in val3)
			{
				JArray val4 = (JArray)(object)((item is JArray) ? item : null);
				if (val4 == null || ((JContainer)val4).Count < 10)
				{
					DawnPlugin.Logger.LogWarning((object)"Malformed unlockable row in save data; skipping.");
					continue;
				}
				int num = val4[0].ToObject<int>();
				if (num < 0 || num >= ((JContainer)val2).Count)
				{
					DawnPlugin.Logger.LogWarning((object)$"Invalid unlockable key index {num} in save; skipping.");
					continue;
				}
				string text = val2[num].ToObject<string>();
				if (string.IsNullOrWhiteSpace(text) || !NamespacedKey.TryParse(text, out NamespacedKey result))
				{
					DawnPlugin.Logger.LogWarning((object)("Invalid unlockable key '" + text + "' in save; skipping."));
					continue;
				}
				if (!LethalContent.Unlockables.TryGetValue(result, out DawnUnlockableItemInfo value))
				{
					DawnPlugin.Logger.LogWarning((object)$"Unlockable: {result} doesn't exist anymore (mod removed?); skipping.");
					continue;
				}
				float num2 = val4[1].ToObject<float>();
				float num3 = val4[2].ToObject<float>();
				float num4 = val4[3].ToObject<float>();
				((Vector3)(ref val5))..ctor(num2, num3, num4);
				float num5 = val4[4].ToObject<float>();
				float num6 = val4[5].ToObject<float>();
				float num7 = val4[6].ToObject<float>();
				((Vector3)(ref val6))..ctor(num5, num6, num7);
				bool flag = val4[7].ToObject<bool>();
				bool flag2 = val4[8].ToObject<bool>();
				bool flag3 = val4[9].ToObject<bool>();
				JToken val7 = ((((JContainer)val4).Count > 10) ? val4[10] : JToken.op_Implicit(0));
				Debuggers.SaveManager?.Log($"Loading unlockable: {result} from save data with information: " + $"{val5}, {val6}, {flag}, {flag2}, {flag3}.");
				UnlockableItem unlockableItem = value.UnlockableItem;
				int num8 = StartOfRound.Instance.unlockablesList.unlockables.IndexOf(unlockableItem);
				if (flag3)
				{
					list.Add(num8);
				}
				if (unlockableItem.alreadyUnlocked && !unlockableItem.IsPlaceable)
				{
					continue;
				}
				unlockableItem.hasBeenUnlockedByPlayer = !unlockableItem.alreadyUnlocked;
				unlockableItem.placedPosition = val5;
				unlockableItem.placedRotation = val6;
				unlockableItem.inStorage = flag;
				unlockableItem.hasBeenMoved = flag2;
				if (flag)
				{
					if (!flag2 || unlockableItem.spawnPrefab)
					{
						continue;
					}
					foreach (PlaceableShipObject placeableShipObject2 in placeableShipObjects)
					{
						if (placeableShipObject2.unlockableID == num8)
						{
							ShipBuildModeManager.Instance.PlaceShipObject(unlockableItem.placedPosition, unlockableItem.placedRotation, placeableShipObject2, false);
						}
					}
				}
				else if (!StartOfRoundRefs.Instance.SpawnedShipUnlockables.ContainsKey(num8))
				{
					StartOfRound.Instance.SpawnUnlockable(num8, false);
				}
			}
			if (list.Count > 0)
			{
				TimeOfDayRefs.Instance.furniturePlacedAtQuotaStart = list;
				TimeOfDayRefs.Instance.CalculateLuckValue();
			}
			foreach (PlaceableShipObject placeableShipObject3 in placeableShipObjects)
			{
				if (!StartOfRoundRefs.Instance.unlockablesList.unlockables[placeableShipObject3.unlockableID].spawnPrefab && StartOfRoundRefs.Instance.unlockablesList.unlockables[placeableShipObject3.unlockableID].inStorage)
				{
					placeableShipObject3.parentObject.disableObject = true;
				}
			}
			for (int i = 0; i < StartOfRoundRefs.Instance.unlockablesList.unlockables.Count; i++)
			{
				if ((i != 0 || !StartOfRoundRefs.Instance.isChallengeFile) && (StartOfRoundRefs.Instance.unlockablesList.unlockables[i].alreadyUnlocked || (StartOfRoundRefs.Instance.unlockablesList.unlockables[i].unlockedInChallengeFile && StartOfRoundRefs.Instance.isChallengeFile)) && !StartOfRoundRefs.Instance.unlockablesList.unlockables[i].IsPlaceable)
				{
					StartOfRoundRefs.Instance.SpawnUnlockable(i, false);
				}
			}
			foreach (PlaceableShipObject placeableShipObject in placeableShipObjects)
			{
				((NetworkBehaviour)placeableShipObject.parentObject).NetworkObject.OnSpawn(delegate
				{
					if (!((NetworkBehaviour)placeableShipObject.parentObject).NetworkObject.TrySetParent(StartOfRoundRefs.Instance.shipAnimatorObject, true))
					{
						DawnPlugin.Logger.LogError((object)("Parenting of object: " + ((Object)((Component)placeableShipObject.parentObject).gameObject).name + " failed."));
					}
				});
				placeableShipObject.parentObject.MoveToOffset();
			}
			Physics.SyncTransforms();
		}

		internal static void SaveAllUnlockables(PersistentDataContainer dataContainer)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Expected O, but got Unknown
			//IL_0298: Unknown result type (might be due to invalid IL or missing references)
			//IL_029d: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ae: Expected O, but got Unknown
			//IL_02ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bb: Expected O, but got Unknown
			//IL_0198: Unknown result type (might be due to invalid IL or missing references)
			//IL_019d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_0206: Unknown result type (might be due to invalid IL or missing references)
			//IL_021d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0234: Unknown result type (might be due to invalid IL or missing references)
			//IL_0246: Unknown result type (might be due to invalid IL or missing references)
			//IL_0258: Unknown result type (might be due to invalid IL or missing references)
			//IL_0265: Unknown result type (might be due to invalid IL or missing references)
			//IL_026f: Expected O, but got Unknown
			List<string> list = new List<string>();
			Dictionary<string, int> dictionary = new Dictionary<string, int>();
			JArray val = new JArray();
			for (int i = 0; i < StartOfRound.Instance.unlockablesList.unlockables.Count; i++)
			{
				UnlockableItem val2 = StartOfRound.Instance.unlockablesList.unlockables[i];
				if (val2.unlockableType == 753)
				{
					Debuggers.SaveManager?.Log("Skipping saving unlockable: " + val2.unlockableName + " into save data, this is probably moresuits adding a bajillion extra orange suit duplicates.");
					continue;
				}
				Debuggers.SaveManager?.Log("Checking whether to save unlockable: " + val2.unlockableName + " into save data.");
				if (!val2.hasBeenUnlockedByPlayer && !val2.alreadyUnlocked)
				{
					continue;
				}
				DawnUnlockableItemInfo dawnInfo = val2.GetDawnInfo();
				if (dawnInfo == null)
				{
					DawnPlugin.Logger.LogError((object)("Unlockable: " + val2.unlockableName + " doesn't have a DawnUnlockableInfo, this means this unlockable cannot be committed to the savefile, contact the developer of this unlockable to fix this ASAP!"));
					continue;
				}
				string text = dawnInfo.Key.ToString();
				if (!dictionary.TryGetValue(text, out var value))
				{
					value = list.Count;
					list.Add(text);
					dictionary[text] = value;
				}
				Debuggers.SaveManager?.Log($"Saving unlockable: {dawnInfo.Key} into save data.");
				bool flag = TimeOfDayRefs.Instance.furniturePlacedAtQuotaStart.Contains(i);
				if (!val2.alreadyUnlocked && !val2.inStorage)
				{
					GameObject gameObject = StartOfRound.Instance.SpawnedShipUnlockables[i].gameObject;
					Debuggers.SaveManager?.Log($"Unlockable: {dawnInfo.TypedKey} has GameObject: {gameObject}.");
				}
				JToken val3 = JToken.op_Implicit(0);
				JArray val4 = new JArray();
				val4.Add(JToken.op_Implicit(value));
				val4.Add(JToken.op_Implicit(val2.placedPosition.x));
				val4.Add(JToken.op_Implicit(val2.placedPosition.y));
				val4.Add(JToken.op_Implicit(val2.placedPosition.z));
				val4.Add(JToken.op_Implicit(val2.placedRotation.x));
				val4.Add(JToken.op_Implicit(val2.placedRotation.y));
				val4.Add(JToken.op_Implicit(val2.placedRotation.z));
				val4.Add(JToken.op_Implicit(val2.inStorage));
				val4.Add(JToken.op_Implicit(val2.hasBeenMoved));
				val4.Add(JToken.op_Implicit(flag));
				val4.Add(val3);
				JArray val5 = val4;
				val.Add((JToken)(object)val5);
			}
			JObject value2 = new JObject
			{
				["keys"] = (JToken)new JArray((object)list),
				["items"] = (JToken)(object)val
			};
			using (dataContainer.CreateEditContext())
			{
				dataContainer.Set<JObject>(DawnKeys.ShipUnlockablesSaveData, value2);
			}
		}

		private static JObject? TryGetNewFormat(PersistentDataContainer dataContainer)
		{
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Invalid comparison between Unknown and I4
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Expected O, but got Unknown
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Expected O, but got Unknown
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Expected O, but got Unknown
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Expected O, but got Unknown
			JObject orCreateDefault;
			try
			{
				orCreateDefault = ((DataContainer)dataContainer).GetOrCreateDefault<JObject>(DawnKeys.ShipUnlockablesSaveData);
			}
			catch (Exception ex)
			{
				DawnPlugin.Logger.LogWarning((object)("Failed to read ship unlockables as new-format JObject; will try legacy migration. (" + ex.GetType().Name + ": " + ex.Message + ")"));
				return null;
			}
			if (orCreateDefault == null || (int)((JToken)orCreateDefault).Type != 1)
			{
				return null;
			}
			JToken val = orCreateDefault["keys"];
			JToken val2 = orCreateDefault["items"];
			if (val == null && val2 == null)
			{
				orCreateDefault["keys"] = (JToken)new JArray();
				orCreateDefault["items"] = (JToken)new JArray();
				return orCreateDefault;
			}
			if (val == null)
			{
				orCreateDefault["keys"] = (JToken)new JArray();
			}
			if (val2 == null)
			{
				orCreateDefault["items"] = (JToken)new JArray();
			}
			if (!(orCreateDefault["keys"] is JArray) || !(orCreateDefault["items"] is JArray))
			{
				return null;
			}
			return orCreateDefault;
		}

		private static JObject? TryMigrateLegacyFormat(PersistentDataContainer dataContainer)
		{
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Expected O, but got Unknown
			//IL_01df: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f5: Expected O, but got Unknown
			//IL_01f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0203: Expected O, but got Unknown
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_0136: 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_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0150: Unknown result type (might be due to invalid IL or missing references)
			//IL_0164: Unknown result type (might be due to invalid IL or missing references)
			//IL_0167: Unknown result type (might be due to invalid IL or missing references)
			//IL_017b: Unknown result type (might be due to invalid IL or missing references)
			//IL_018d: Unknown result type (might be due to invalid IL or missing references)
			//IL_019f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bb: Expected O, but got Unknown
			List<UnlockableSaveData> orCreateDefault;
			try
			{
				orCreateDefault = dataContainer.GetOrCreateDefault<List<UnlockableSaveData>>(DawnKeys.ShipUnlockablesSaveData);
			}
			catch (Exception ex)
			{
				DawnPlugin.Logger.LogWarning((object)("Failed to read legacy ship unlockables for migration: " + ex.GetType().Name + ": " + ex.Message));
				return null;
			}
			if (orCreateDefault == null || orCreateDefault.Count == 0)
			{
				return null;
			}
			DawnPlugin.Logger.LogInfo((object)$"Migrating {orCreateDefault.Count} legacy ship unlockables to new compact format.");
			List<string> list = new List<string>();
			Dictionary<NamespacedKey, int> dictionary = new Dictionary<NamespacedKey, int>();
			JArray val = new JArray();
			foreach (UnlockableSaveData item in orCreateDefault)
			{
				NamespacedKey unlockableNamespacedKey = item.UnlockableNamespacedKey;
				if (!dictionary.TryGetValue(unlockableNamespacedKey, out var value))
				{
					value = list.Count;
					list.Add(unlockableNamespacedKey.ToString());
					dictionary[unlockableNamespacedKey] = value;
				}
				JToken val2 = item.SavedData ?? JToken.op_Implicit(0);
				JArray val3 = new JArray();
				val3.Add(JToken.op_Implicit(value));
				val3.Add(JToken.op_Implicit(item.SavedSpawnPosition.x));
				val3.Add(JToken.op_Implicit(item.SavedSpawnPosition.y));
				val3.Add(JToken.op_Implicit(item.SavedSpawnPosition.z));
				val3.Add(JToken.op_Implicit(item.SavedSpawnRotation.x));
				val3.Add(JToken.op_Implicit(item.SavedSpawnRotation.y));
				val3.Add(JToken.op_Implicit(item.SavedSpawnRotation.z));
				val3.Add(JToken.op_Implicit(item.InStorage));
				val3.Add(JToken.op_Implicit(item.HasBeenMoved));
				val3.Add(JToken.op_Implicit(item.PlacedAtQuotaStart));
				val3.Add(val2);
				JArray val4 = val3;
				val.Add((JToken)(object)val4);
			}
			JObject val5 = new JObject
			{
				["keys"] = (JToken)new JArray((object)list),
				["items"] = (JToken)(object)val
			};
			using (dataContainer.CreateEditContext())
			{
				dataContainer.Set<JObject>(DawnKeys.ShipUnlockablesSaveData, val5);
			}
			DawnPlugin.Logger.LogInfo((object)$"Migration complete. Migrated {((JContainer)val).Count} unlockables into new compact format.");
			return val5;
		}
	}
}
namespace Dawn.Utils
{
	[AddComponentMenu("DawnLib/Misc Utilities/StoryLog Spawner")]
	public class DawnStoryLogSpawner : MonoBehaviour
	{
		[field: SerializeField]
		[field: InspectorName("Namespace")]
		public NamespacedKey NamespacedKey { get; private set; }

		public void Start()
		{
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			if (!LethalContent.StoryLogs.TryGetValue(NamespacedKey, out DawnStoryLogInfo value))
			{
				DawnPlugin.Logger.LogWarning((object)$"StoryLog: '{NamespacedKey}' not found to spawn.");
				return;
			}
			if ((Object)(object)value.StoryLogGameObject == (Object)null)
			{
				DawnPlugin.Logger.LogWarning((object)$"StoryLog: '{NamespacedKey}' has no game object to spawn, this is likely because this is a vanilla story log and zeekerss never made prefabs so it's not possible for DawnLib to grab them... yeah.");
				return;
			}
			GameObject val = Object.Instantiate<GameObject>(value.StoryLogGameObject, ((Component)this).transform.position, ((Component)this).transform.rotation, ((Component)this).transform);
			val.GetComponent<NetworkObject>().Spawn(true);
		}
	}
	[RequireComponent(typeof(Collider))]
	[AddComponentMenu("DawnLib/Dawn Surface")]
	public class DawnSurface : MonoBehaviour
	{
		[field: SerializeField]
		[field: InspectorName("Namespace")]
		public NamespacedKey NamespacedKey { get; private set; }

		[field: SerializeField]
		[field: InspectorName("NamespacesForTerrain")]
		[field: Tooltip("Match this list to the list of your terrain's AlphaMasks")]
		public List<NamespacedKey> NamespacedKeysForTerrain { get; private set; } = new List<NamespacedKey>();


		[field: SerializeField]
		[field: InspectorName("Center Of Gravity")]
		public GameObject? GravityCenter { get; private set; }

		[field: SerializeField]
		public float GravityStrength { get; private set; } = 1f;


		public int SurfaceIndex { get; private set; } = -1;


		public Terrain? Terrain { get; private set; }

		public float[,,] TerrainAlphamaps { get; private set; } = new float[0, 0, 0];


		public List<int> TerrainIndices { get; private set; } = new List<int>();


		public void Start()
		{
			Terrain val = default(Terrain);
			if (((Component)this).TryGetComponent<Terrain>(ref val))
			{
				TerrainData terrainData = val.terrainData;
				TerrainAlphamaps = terrainData.GetAlphamaps(0, 0, terrainData.alphamapWidth, terrainData.alphamapHeight);
				Terrain = val;
			}
			foreach (NamespacedKey item in NamespacedKeysForTerrain)
			{
				if (LethalContent.Surfaces.TryGetValue(item, out DawnSurfaceInfo value))
				{
					TerrainIndices.Add(value.SurfaceIndex);
				}
			}
			if (NamespacedKey == null || string.IsNullOrEmpty(NamespacedKey.Namespace) || string.IsNullOrEmpty(NamespacedKey.Key) || !LethalContent.Surfaces.TryGetValue(NamespacedKey, out DawnSurfaceInfo value2))
			{
				if ((Object)(object)Terrain == (Object)null)
				{
					DawnPlugin.Logger.LogWarning((object)$"Surface: '{NamespacedKey}' not found.");
				}
			}
			else if (value2.Surface == null)
			{
				if ((Object)(object)Terrain == (Object)null)
				{
					DawnPlugin.Logger.LogWarning((object)$"Surface: '{NamespacedKey}' has no footstep surface defined.");
				}
			}
			else
			{
				SurfaceIndex = value2.SurfaceIndex;
			}
		}

		public bool TryGetFootstepIndex(Vector3 point, bool checkStandingOnTerrain, out int footstepIndex, PlayerControllerB? playerControllerB = null)
		{
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			footstepIndex = -1;
			if ((Object)(object)Terrain != (Object)null)
			{
				if ((Object)(object)playerControllerB != (Object)null)
				{
					playerControllerB.standingOnTerrain = true;
				}
				if (checkStandingOnTerrain)
				{
					return false;
				}
				StartOfRound.Instance.currentTerrainAlphaMaps = TerrainAlphamaps;
				StartOfRound.Instance.gotCurrentTerrainAlphamaps = true;
				Vector3 val = ConvertToSplatMapCoordinate(point, Terrain);
				int num = 0;
				float num2 = 0f;
				TerrainData terrainData = Terrain.terrainData;
				int num3 = TerrainAlphamaps.Length / (terrainData.alphamapWidth * terrainData.alphamapHeight);
				for (int i = 0; i < num3; i++)
				{
					float num4 = TerrainAlphamaps[(int)val.z, (int)val.x, i];
					if (num2 < num4)
					{
						num2 = num4;
						num = i;
					}
				}
				if (TerrainIndices.Count <= num)
				{
					if (SurfaceIndex == -1)
					{
						return false;
					}
					footstepIndex = SurfaceIndex;
				}
				else
				{
					footstepIndex = TerrainIndices[num];
				}
			}
			else
			{
				footstepIndex = SurfaceIndex;
			}
			return footstepIndex != -1;
		}

		private static Vector3 ConvertToSplatMapCoordinate(Vector3 worldPosition, Terrain terrain)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			Vector3 result = default(Vector3);
			Vector3 position = ((Component)terrain).transform.position;
			result.x = (worldPosition.x - position.x) / terrain.terrainData.size.x * (float)terrain.terrainData.alphamapWidth;
			result.z = (worldPosition.z - position.z) / terrain.terrainData.size.z * (float)terrain.terrainData.alphamapHeight;
			return result;
		}
	}
	public static class AssetBundleUtils
	{
		public static AssetBundle LoadBundle(Assembly assembly, string filePath)
		{
			string text = Path.Combine(Path.GetDirectoryName(assembly.Location), "Assets", filePath);
			if (!File.Exists(text))
			{
				string path = Path.Combine(Path.GetDirectoryName(assembly.Location), filePath);
				bool flag = File.Exists(path);
				string text2 = "The assetbundle at plugins/" + Path.GetRelativePath(Paths.PluginPath, text) + " does not exist!";
				if (flag)
				{
					text2 = text2 + " The bundle was found at the incorrect spot: plugins/" + Path.GetRelativePath(Paths.PluginPath, path) + ". It should be within the Assets/ subfolder";
				}
				throw new FileNotFoundException(text2);
			}
			return AssetBundle.LoadFromFile(text);
		}
	}
	[Serializable]
	public class BoundedRange
	{
		[field: SerializeField]
		public float Min { get; private set; }

		[field: SerializeField]
		public float Max { get; private set; }

		public BoundedRange(float min, float max)
		{
			Min = min;
			Max = max;
			if (Min > Max)
			{
				DawnPlugin.Logger.LogWarning((object)$"Min ({Min}) is bigger than Max ({Max}), setting Min to {Max}");
				Min = Max;
			}
		}

		public bool IsInRange(float value)
		{
			if (value > Min)
			{
				return value <= Max;
			}
			return false;
		}

		public float GetAverage()
		{
			return (Min + Max) / 2f;
		}

		public float GetRandomInRange(Random random)
		{
			return random.NextFloat(Min, Max);
		}
	}
	public enum CompatibilityBool
	{
		Never,
		Always,
		IfVersionMatches,
		IfMajorVersionMatches
	}
	public static class CompatibilityBoolExtensions
	{
		public static bool ShouldRunCompatibility(this CompatibilityBool value, string compatibilityVersion, Version currentModVersion)
		{
			return value switch
			{
				CompatibilityBool.Never => false, 
				CompatibilityBool.Always => true, 
				CompatibilityBool.IfVersionMatches => Version.Parse(compatibilityVersion) == currentModVersion, 
				CompatibilityBool.IfMajorVersionMatches => Version.Parse(compatibilityVersion).Major == currentModVersion.Major, 
				_ => throw new ArgumentOutOfRangeException("value", value, null), 
			};
		}
	}
	public class DawnEnemyAdditionalData : MonoBehaviour
	{
		private static readonly Dictionary<EnemyAI, DawnEnemyAdditionalData> _additionalData = new Dictionary<EnemyAI, DawnEnemyAdditionalData>();

		private EnemyAI _enemy;

		private List<EnemyAICollisionDetect> _enemyAICollisionDetects = new List<EnemyAICollisionDetect>();

		public IReadOnlyList<EnemyAICollisionDetect> EnemyAICollisionDetects => _enemyAICollisionDetects.AsReadOnly();

		public SmartAgentNavigator? SmartAgentNavigator { get; internal set; }

		public PlayerControllerB? PlayerThatLastHit { get; internal set; }

		public bool KilledByPlayer { get; internal set; }

		private void OnDestroy()
		{
			_additionalData.Remove(_enemy);
		}

		public static DawnEnemyAdditionalData CreateOrGet(EnemyAI enemyAI)
		{
			if (_additionalData.TryGetValue(enemyAI, out DawnEnemyAdditionalData value))
			{
				return value;
			}
			value = ((Component)enemyAI).gameObject.AddComponent<DawnEnemyAdditionalData>();
			value._enemy = enemyAI;
			value._enemyAICollisionDetects = ((Component)enemyAI).GetComponentsInChildren<EnemyAICollisionDetect>().ToList();
			value.SmartAgentNavigator = ((Component)enemyAI).GetComponent<SmartAgentNavigator>();
			_additionalData[enemyAI] = value;
			return value;
		}
	}
	public static class AssemblyExtensions
	{
		public static IEnumerable<Type> GetLoadableTypes(this Assembly assembly)
		{
			if (assembly == null)
			{
				throw new ArgumentNullException("assembly");
			}
			try
			{
				return assembly.GetTypes();
			}
			catch (ReflectionTypeLoadException ex)
			{
				return ex.Types.Where((Type t) => t != null);
			}
		}
	}
	public static class BepInPluginExtensions
	{
		public static PersistentDataContainer GetPersistentDataContainer(this BaseUnityPlugin plugin)
		{
			return PersistentDataHandler.Get(plugin);
		}
	}
	public static class ConfigFileExtensions
	{
		public static void ClearUnusedEntries(this ConfigFile configFile)
		{
			PropertyInfo property = ((object)configFile).GetType().GetProperty("OrphanedEntries", BindingFlags.Instance | BindingFlags.NonPublic);
			Dictionary<ConfigDefinition, string> dictionary = (Dictionary<ConfigDefinition, string>)property.GetValue(configFile, null);
			dictionary.Clear();
			configFile.Save();
		}

		public static ConfigEntry<T> CleanedBind<T>(this ConfigFile ModConfig, string section, string configItemName, T defaultValue, string ConfigDescription)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Expected O, but got Unknown
			return ModConfig.Bind<T>(section.CleanStringForConfig(), configItemName.CleanStringForConfig(), defaultValue, new ConfigDescription(ConfigDescription, (AcceptableValueBase)null, Array.Empty<object>()));
		}

		public static ConfigEntry<T> CleanedBind<T>(this ConfigFile ModConfig, string section, string configItemName, T defaultValue, string description, AcceptableValueList<T> acceptableValues = null) where T : IEquatable<T>
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Expected O, but got Unknown
			return ModConfig.Bind<T>(section.CleanStringForConfig(), configItemName.CleanStringForConfig(), defaultValue, new ConfigDescription(description, (AcceptableValueBase)(object)acceptableValues, Array.Empty<object>()));
		}

		public static ConfigEntry<T> CleanedBind<T>(this ConfigFile ModConfig, string section, string configItemName, T defaultValue, string description, T minValue, T maxValue) where T : IComparable
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Expected O, but got Unknown
			AcceptableValueRange<T> val = new AcceptableValueRange<T>(minValue, maxValue);
			return ModConfig.Bind<T>(section.CleanStringForConfig(), configItemName.CleanStringForConfig(), defaultValue, new ConfigDescription(description, (AcceptableValueBase)(object)val, Array.Empty<object>()));
		}
	}
	public static class HUDManagerExtensions
	{
		public static void DisplayTip(this HUDManager instance, HUDDisplayTip displayTip)
		{
			instance.DisplayTip(displayTip.Header, displayTip.Body, displayTip.Type == HUDDisplayTip.AlertType.Warning, false, "LC_Tip1");
		}
	}
	public static class IEnumerableExtensions
	{
		[CompilerGenerated]
		private sealed class <WithIndex>d__1<T> : IEnumerable<(int index, T value)>, IEnumerable, IEnumerator<(int index, T value)>, IEnumerator, IDisposable where T : notnull
		{
			private int <>1__state;

			private (int index, T value) <>2__current;

			private int <>l__initialThreadId;

			private IEnumerable<T> list;

			public IEnumerable<T> <>3__list;

			private int <i>5__2;

			private IEnumerator<T> <>7__wrap2;

			(int, T) IEnumerator<(int, T)>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

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

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

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

			private bool MoveNext()
			{
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<i>5__2 = 0;
						<>7__wrap2 = list.GetEnumerator();
						<>1__state = -3;
						break;
					case 1:
						<>1__state = -3;
						<i>5__2++;
						break;
					}
					if (<>7__wrap2.MoveNext())
					{
						T current = <>7__wrap2.Current;
						<>2__current = (<i>5__2, current);
						<>1__state = 1;
						return true;
					}
					<>m__Finally1();
					<>7__wrap2 = null;
					return false;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<>7__wrap2 != null)
				{
					<>7__wrap2.Dispose();
				}
			}

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

			[DebuggerHidden]
			IEnumerator<(int index, T value)> IEnumerable<(int, T)>.GetEnumerator()
			{
				<WithIndex>d__1<T> <WithIndex>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<WithIndex>d__ = this;
				}
				else
				{
					<WithIndex>d__ = new <WithIndex>d__1<T>(0);
				}
				<WithIndex>d__.list = <>3__list;
				return <WithIndex>d__;
			}

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

		public static VertexGradient ToVertexGradient(this IEnumerable<Color> colors)
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: 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_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			List<Color> list = colors.Take(4).ToList();
			Color val;
			Color val2;
			Color val3;
			Color val4;
			switch (list.Count)
			{
			case 0:
				val = (val2 = (val3 = (val4 = Color.white)));
				break;
			case 1:
				val = (val2 = (val3 = (val4 = list[0])));
				break;
			case 2:
				val = (val2 = list[0]);
				val3 = (val4 = list[1]);
				break;
			case 3:
				val = list[0];
				val2 = (val3 = list[1]);
				val4 = list[2];
				break;
			default:
				val = list[0];
				val2 = list[1];
				val3 = list[2];
				val4 = list[3];
				break;
			}
			return new VertexGradient(val, val2, val3, val4);
		}

		[IteratorStateMachine(typeof(<WithIndex>d__1<>))]
		public static IEnumerable<(int index, T value)> WithIndex<T>(this IEnumerable<T> list)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <WithIndex>d__1<T>(-2)
			{
				<>3__list = list
			};
		}
	}
	public static class ILCursorExtensions
	{
		public static void EmitLdfld(this ILCursor c, Type type, string fieldName)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			FieldInfo field = type.GetField(fieldName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			c.Emit(OpCodes.Ldfld, field);
		}

		public static void EmitLdflda(this ILCursor c, Type type, string fieldName)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			FieldInfo field = type.GetField(fieldName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			c.Emit(OpCodes.Ldflda, field);
		}

		public static void EmitLdfld<T>(this ILCursor c, string fieldName)
		{
			c.EmitLdfld(typeof(T), fieldName);
		}

		public static void EmitLdflda<T>(this ILCursor c, string fieldName)
		{
			c.EmitLdflda(typeof(T), fieldName);
		}

		public static void EmitVanillaLdfld(this ILCursor c, string typeName, string fieldName)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			FieldInfo field = ReflectionUtils.GetVanillaType(typeName).GetField(fieldName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			c.Emit(OpCodes.Ldfld, field);
		}

		public static void EmitVanillaLdflda(this ILCursor c, string typeName, string fieldName)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			FieldInfo field = ReflectionUtils.GetVanillaType(typeName).GetField(fieldName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			c.Emit(OpCodes.Ldflda, field);
		}

		public static void EmitCallvirt<T>(this ILCursor c, string methodName)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			MethodInfo method = typeof(T).GetMethod(methodName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			c.Emit(OpCodes.Callvirt, (MethodBase)method);
		}

		public static void EmitLdloc(this ILCursor c, int index)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			c.Emit(OpCodes.Ldloc, index);
		}
	}
	public static class IListExtensions
	{
		public static IList<T> Shuffle<T>(this IList<T> ts)
		{
			int count = ts.Count;
			int num = count - 1;
			for (int i = 0; i < num; i++)
			{
				int num2 = Random.Range(i, count);
				int index = i;
				int index2 = num2;
				T value = ts[num2];
				T value2 = ts[i];
				ts[index] = value;
				ts[index2] = value2;
			}
			return ts;
		}
	}
	public static class MathfExtensions
	{
		public static int Clamp0(this int value)
		{
			return Mathf.Clamp(value, 0, int.MaxValue);
		}
	}
	public static class NetworkObjectExtensions
	{
		[CompilerGenerated]
		private sealed class <>c__DisplayClass0_0
		{
			public NetworkObject networkObject;

			internal bool <WaitUntilSpawned>b__0()
			{
				return networkObject.IsSpawned;
			}
		}

		[CompilerGenerated]
		private sealed class <RunActionAfterSpawned>d__1 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public NetworkObject networkObject;

			public Action action;

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

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

			[DebuggerHidden]
			public <RunActionAfterSpawned>d__1(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = networkObject.WaitUntilSpawned();
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					action();
					return false;
				}
			}

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

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

		[CompilerGenerated]
		private sealed class <WaitUntilSpawned>d__0 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public NetworkObject networkObject;

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

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

			[DebuggerHidden]
			public <WaitUntilSpawned>d__0(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0036: Unknown result type (might be due to invalid IL or missing references)
				//IL_0040: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitUntil((Func<bool>)new <>c__DisplayClass0_0
					{
						networkObject = networkObject
					}.<WaitUntilSpawned>b__0);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					return false;
				}
			}

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

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

		[IteratorStateMachine(typeof(<WaitUntilSpawned>d__0))]
		public static IEnumerator WaitUntilSpawned(this NetworkObject networkObject)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <WaitUntilSpawned>d__0(0)
			{
				networkObject = networkObject
			};
		}

		[IteratorStateMachine(typeof(<RunActionAfterSpawned>d__1))]
		private static IEnumerator RunActionAfterSpawned(NetworkObject networkObject, Action action)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <RunActionAfterSpawned>d__1(0)
			{
				networkObject = networkObject,
				action = action
			};
		}

		public static void OnSpawn(this NetworkObject networkObject, Action action)
		{
			((MonoBehaviour)networkObject).StartCoroutine(RunActionAfterSpawned(networkObject, action));
		}
	}
	public static class PlayerControllerBExtensions
	{
		public static bool IsLocalPlayer(this PlayerControllerB playerController)
		{
			return (Object)(object)playerController == (Object)(object)GameNetworkManager.Instance.localPlayerController;
		}
	}
	public static class RandomExtensions
	{
		public static float Next(this Random random, BoundedRange range)
		{
			return (float)(random.NextDouble() * (double)(range.Max - range.Min) + (double)range.Min);
		}

		public static double NextDouble(this Random random, double min, double max)
		{
			return random.NextDouble() * (max - min) + min;
		}

		public static float NextFloat(this Random random, float min, float max)
		{
			return (float)random.NextDouble(min, max);
		}

		public static T NextEnum<T>(this Random random) where T : struct, Enum
		{
			Array values = Enum.GetValues(typeof(T));
			return (T)values.GetValue(random.Next(values.Length));
		}

		public static T NextItem<T>(this Random random, IList<T> collection)
		{
			int index = random.Next(collection.Count);
			return collection[index];
		}

		public static bool NextBool(this Random random)
		{
			return random.Next(2) == 0;
		}

		public static int NextSign(this Random random)
		{
			if (!random.NextBool())
			{
				return -1;
			}
			return 1;
		}

		public static Quaternion NextQuaternion(this Random random)
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			return Quaternion.Euler(random.NextFloat(0f, 360f), random.NextFloat(0f, 360f), random.NextFloat(0f, 360f));
		}

		public static T NextWeighted<T>(this Random random, IList<T> list) where T : IWeighted
		{
			int num = list.Sum((T it) => it.GetWeight());
			int num2 = random.Next(0, num + 1);
			T result = list.First();
			foreach (T item in list)
			{
				result = item;
				num2 -= item.GetWeight();
				if (num2 <= 0)
				{
					break;
				}
			}
			return result;
		}

		public static T NextContextualWeighted<T, TContext>(this Random random, IList<T> list, TContext context) where T : IContextualWeighted<TContext>
		{
			TContext context2 = context;
			int num = list.Sum((T it) => it.GetWeight(context2));
			int num2 = random.Next(0, num + 1);
			T result = list.First();
			foreach (T item in list)
			{
				result = item;
				num2 -= item.GetWeight(context2);
				if (num2 <= 0)
				{
					break;
				}
			}
			return result;
		}
	}
	public static class StringExtensions
	{
		private static readonly Regex LeadingNumberRegex = new Regex("^[0-9]+");

		private static readonly Regex ConfigCleanerRegex = new Regex("[\\n\\t\"`\\[\\]']");

		public static string ToCapitalized(this string input)
		{
			if (string.IsNullOrWhiteSpace(input))
			{
				return string.Empty;
			}
			return input.Substring(0, 1).ToUpperInvariant() + input.Substring(1, input.Length - 1);
		}

		public static string RemoveEnd(this string input, string end)
		{
			if (input.EndsWith(end))
			{
				int length = end.Length;
				return input.Substring(0, input.Length - length);
			}
			return input;
		}

		public static string StripSpecialCharacters(this string input)
		{
			string text = string.Empty;
			for (int i = 0; i < input.Length; i++)
			{
				char c = input[i];
				if (char.IsLetter(c))
				{
					text += c;
				}
			}
			return text;
		}

		public static string RemoveLeadingNumbers(this string input)
		{
			return LeadingNumberRegex.Replace(input, string.Empty);
		}

		public static string ReplaceNumbersWithWords(this string input)
		{
			return string.Concat(input.Select((char c) => c switch
			{
				'0' => "zero", 
				'1' => "one", 
				'2' => "two", 
				'3' => "three", 
				'4' => "four", 
				'5' => "five", 
				'6' => "six", 
				'7' => "seven", 
				'8' => "eight", 
				'9' => "nine", 
				_ => c.ToString(), 
			}));
		}

		public static bool CompareStringsInvariant(this string input, string str2, bool ignoreCase = true)
		{
			StringComparison comparisonType = (ignoreCase ? StringComparison.InvariantCultureIgnoreCase : StringComparison.InvariantCulture);
			return input.Equals(str2, comparisonType);
		}

		public static bool StringStartsWithInvariant(this string input, char ch, bool ignoreCase = true)
		{
			StringComparison comparisonType = (ignoreCase ? StringComparison.InvariantCultureIgnoreCase : StringComparison.InvariantCulture);
			return input.StartsWith($"{ch}", comparisonType);
		}

		public static bool StringStartsWithInvariant(this string input, string str, bool ignoreCase = true)
		{
			StringComparison comparisonType = (ignoreCase ? StringComparison.InvariantCultureIgnoreCase : StringComparison.InvariantCulture);
			return input.StartsWith(str, comparisonType);
		}

		public static bool StringContainsInvariant(this string input, string query, bool ignoreCase = true)
		{
			StringComparison comparisonType = (ignoreCase ? StringComparison.InvariantCultureIgnoreCase : StringComparison.InvariantCulture);
			return input.Contains(query, comparisonType);
		}

		public static int StringMatchScore(this string input, string query, bool ignoreCase = true)
		{
			int num = 0;
			if (ignoreCase)
			{
				input = input.ToLowerInvariant();
				query = query.ToLowerInvariant();
			}
			for (int i = 0; i < input.Length && query.Length > i; i++)
			{
				if (input[i].Equals(query[i]))
				{
					num++;
				}
			}
			return num;
		}

		public static string GetExactMatch(this string input, string query, bool ignoreCase = true)
		{
			string text = string.Empty;
			if (ignoreCase)
			{
				input = input.ToLowerInvariant();
				query = query.ToLowerInvariant();
			}
			input = input.Trim();
			query = query.Trim();
			for (int i = 0; i < input.Length && query.Length > i && input[i].Equals(query[i]); i++)
			{
				text += input[i];
			}
			return text;
		}

		public static string TextModify(this string value, MatchIndex indexStyle, MatchInsert insertStyle, string matching, string addedContent)
		{
			if (string.IsNullOrEmpty(value) || !value.Contains(matching))
			{
				return value;
			}
			int num;
			switch (indexStyle)
			{
			case MatchIndex.All:
				return insertStyle switch
				{
					MatchInsert.ReplaceMatch => value.Replace(matching, addedContent), 
					MatchInsert.Before => value.Replace(matching, addedContent + matching), 
					MatchInsert.After => value.Replace(matching, matching + addedContent), 
					MatchInsert.Before | MatchInsert.After => value.Replace(matching, addedContent + matching + addedContent), 
					_ => value, 
				};
			default:
				num = value.LastIndexOf(matching);
				break;
			case MatchIndex.First:
				num = value.IndexOf(matching);
				break;
			}
			int num2 = num;
			return insertStyle switch
			{
				MatchInsert.ReplaceMatch => value.Remove(num2, matching.Length).Insert(num2, addedContent), 
				MatchInsert.Before => value.Insert(num2, addedContent), 
				MatchInsert.After => value.Insert(num2 + matching.Length, addedContent), 
				MatchInsert.Before | MatchInsert.After => value.Remove(num2, matching.Length).Insert(num2, addedContent + matching + addedContent), 
				_ => value, 
			};
		}

		internal static string CleanStringForConfig(this string input)
		{
			return ConfigCleanerRegex.Replace(input, string.Empty);
		}
	}
	public static class TerminalExtensions
	{
		private static List<TerminalKeyword> WordsThatAcceptInput = new List<TerminalKeyword>();

		private static readonly List<string> VanillaEvents = new List<string>(4) { "setUpTerminal", "cheat_ResetCredits", "switchCamera", "ejectPlayers" };

		private static readonly List<string> VanillaWords = new List<string>(11)
		{
			"company", "moons", "store", "help", "other", "bestiary", "storage", "scan", "upgrades", "decor",
			"sigurd"
		};

		public static bool GetKeywordAcceptingInput(this TerminalKeyword word)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return ((ITerminalKeyword)word).DawnAcceptAdditionalText;
		}

		public static List<TerminalKeyword> GetKeywordsAcceptingInput()
		{
			return WordsThatAcceptInput;
		}

		public static void SetKeywordAcceptInput(this TerminalKeyword word, bool value)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			if (value)
			{
				WordsThatAcceptInput.Add(word);
			}
			else
			{
				WordsThatAcceptInput.Remove(word);
			}
			((ITerminalKeyword)word).DawnAcceptAdditionalText = value;
		}

		public static string GetKeywordCategory(this TerminalKeyword word)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return ((ITerminalKeyword)word).DawnKeywordCategory;
		}

		public static void SetKeywordCategory(this TerminalKeyword word, string value)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			((ITerminalKeyword)word).DawnKeywordCategory = value;
		}

		public static string GetKeywordDescription(this TerminalKeyword word)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return ((ITerminalKeyword)word).DawnKeywordDescription;
		}

		public static void SetKeywordDescription(this TerminalKeyword word, string value)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			((ITerminalKeyword)word).DawnKeywordDescription = value;
		}

		internal static void SetLastCommand(this Terminal terminal, string value)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			((ITerminal)terminal).DawnLastCommand = value;
		}

		public static string GetLastCommand(this Terminal terminal)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return ((ITerminal)terminal).DawnLastCommand;
		}

		internal static void SetLastNoun(this Terminal terminal, TerminalKeyword value)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			((ITerminal)terminal).DawnLastNoun = value;
		}

		public static TerminalKeyword GetLastNoun(this Terminal terminal)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return ((ITerminal)terminal).DawnLastNoun;
		}

		internal static void SetLastVerb(this Terminal terminal, TerminalKeyword value)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			((ITerminal)terminal).DawnLastVerb = value;
		}

		public static TerminalKeyword GetLastVerb(this Terminal terminal)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return ((ITerminal)terminal).DawnLastVerb;
		}

		public static bool TryGetKeywordInfoText(this TerminalKeyword terminalKeyword, [NotNullWhen(true)] out string? text)
		{
			TerminalKeyword terminalKeyword2 = terminalKeyword;
			text = null;
			CompatibleNoun val = ((IEnumerable<CompatibleNoun>)TerminalRefs.InfoKeyword.compatibleNouns).FirstOrDefault((Func<CompatibleNoun, bool>)((CompatibleNoun x) => x.noun.word == terminalKeyword2.word));
			if (val == null)
			{
				return false;
			}
			text = val.result.displayText;
			return true;
		}

		public static bool TryGetKeyword(this Terminal terminal, string keyWord, [NotNullWhen(true)] out TerminalKeyword? terminalKeyword)
		{
			List<TerminalKeyword> list = terminal.terminalNodes.allKeywords.ToList();
			foreach (TerminalKeyword item in list)
			{
				if (keyWord.CompareStringsInvariant(item.word))
				{
					terminalKeyword = item;
					return true;
				}
			}
			terminalKeyword = null;
			return false;
		}

		internal static void TryAssignType(this TerminalKeyword terminalKeyword)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			TerminalKeyword terminalKeyword2 = terminalKeyword;
			if ((int)terminalKeyword2.GetKeywordPriority() != 0)
			{
				return;
			}
			if (terminalKeyword2.isVerb || VanillaWords.Contains(terminalKeyword2.word.ToLowerInvariant()))
			{
				terminalKeyword2.SetKeywordPriority((DawnKeywordType)1);
				return;
			}
			if (terminalKeyword2.accessTerminalObjects)
			{
				terminalKeyword2.SetKeywordPriority((DawnKeywordType)2);
				return;
			}
			if ((Object)(object)terminalKeyword2.specialKeywordResult != (Object)null)
			{
				terminalKeyword2.SetKeywordPriority(terminalKeyword2.specialKeywordResult.TryGetTerminalNodeType());
				return;
			}
			if ((Object)(object)terminalKeyword2.defaultVerb != (Object)null)
			{
				CompatibleNoun val = ((IEnumerable<CompatibleNoun>)terminalKeyword2.defaultVerb.compatibleNouns).FirstOrDefault((Func<CompatibleNoun, bool>)((CompatibleNoun x) => x.noun.word.CompareStringsInvariant(terminalKeyword2.word)));
				if (val != null)
				{
					DawnKeywordType val2 = val.result.TryGetTerminalNodeType();
					terminalKeyword2.SetKeywordPriority(val2);
					Debuggers.Terminal?.Log($"{terminalKeyword2.word} priority set to {val2}");
					return;
				}
				Debuggers.Terminal?.Log("Unable to determine keyword type for word: [ " + terminalKeyword2.word + " ]\nKeywordPriority is set to other!");
			}
			terminalKeyword2.SetKeywordPriority((DawnKeywordType)10);
		}

		public static DawnKeywordType TryGetTerminalNodeType(this TerminalNode terminalNode)
		{
			TerminalNode terminalNode2 = terminalNode;
			if ((Object)(object)terminalNode2 == (Object)null)
			{
				Debuggers.Terminal?.Log("Null TerminalNode provided to TryGetTerminalNodeType, returning lowest priority");
				return (DawnKeywordType)10;
			}
			if (!string.IsNullOrEmpty(terminalNode2.terminalEvent))
			{
				if (!VanillaEvents.Any((string x) => x.CompareStringsInvariant(terminalNode2.terminalEvent)))
				{
					return (DawnKeywordType)8;
				}
				return (DawnKeywordType)1;
			}
			if (terminalNode2.buyRerouteToMoon <= -1 && terminalNode2.displayPlanetInfo <= -1)
			{
				if (terminalNode2.buyVehicleIndex <= -1)
				{
					if (terminalNode2.shipUnlockableID <= -1 && terminalNode2.buyItemIndex <= -1)
					{
						if (terminalNode2.creatureFileID <= -1)
						{
							if (terminalNode2.storyLogFileID <= -1)
							{
								return (DawnKeywordType)10;
							}
							return (DawnKeywordType)7;
						}
						return (DawnKeywordType)6;
					}
					return (DawnKeywordType)5;
				}
				return (DawnKeywordType)4;
			}
			return (DawnKeywordType)3;
		}

		public static DawnKeywordType GetKeywordPriority(this TerminalKeyword terminalKeyword)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			return ((ITerminalKeyword)terminalKeyword).DawnKeywordPriority;
		}

		public static void SetKeywordPriority(this TerminalKeyword terminalKeyword, DawnKeywordType keywordType)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			((ITerminalKeyword)terminalKeyword).DawnKeywordPriority = keywordType;
		}

		public static void UpdateLastKeywordParsed(this Terminal self, TerminalKeyword terminalKeyword)
		{
			if (!((Object)(object)self == (Object)null) && !((Object)(object)terminalKeyword == (Object)null))
			{
				if (terminalKeyword.isVerb)
				{
					self.SetLastVerb(terminalKeyword);
				}
				else
				{
					self.SetLastNoun(terminalKeyword);
				}
			}
		}

		private static bool MatchInputKeyword(string input, out List<TerminalKeyword> words)
		{
			string input2 = input;
			if (input2.Contains(' '))
			{
				input2 = input2.Split(' ')[0];
			}
			words = WordsThatAcceptInput.FindAll((TerminalKeyword x) => x.word.StringContainsInvariant(input2));
			return words.Count != 0;
		}

		private static TerminalKeyword GetBestMatchFromList(string input, List<TerminalKeyword> keywordList)
		{
			//IL_01bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: Expected I4, but got Unknown
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Expected I4, but got Unknown
			TerminalKeyword val = null;
			int num = 0;
			if (keywordList.Count == 0)
			{
				return val;
			}
			Dictionary<TerminalKeyword, int> dictionary = new Dictionary<TerminalKeyword, int>();
			foreach (TerminalKeyword keyword in keywordList)
			{
				int value = keyword.word.StringMatchScore(input);
				dictionary.TryAdd(keyword, value);
			}
			foreach (KeyValuePair<TerminalKeyword, int> item in dictionary)
			{
				if ((Object)(object)item.Key == (Object)null)
				{
					continue;
				}
				if ((Object)(object)val == (Object)null || num == 0)
				{
					val = item.Key;
					num = item.Value;
				}
				else
				{
					if (num > item.Value)
					{
						continue;
					}
					if (num == item.Value)
					{
						Debuggers.Terminal?.Log("Attempting to resolve conflict between matching results [" + val.word + "] & [" + item.Key.word + "] by comparing keyword priorities!");
						int num2 = (int)val.GetKeywordPriority();
						int num3 = (int)item.Key.GetKeywordPriority();
						if (num3 < num2)
						{
							val = item.Key;
							continue;
						}
					}
					Debuggers.Terminal?.Log($"Skipping partial match [{item.Key.word}] with match score {item.Value} due to better match existing with a higher priority");
				}
			}
			if (num < DawnConfig.TerminalKeywordSpecificity.Value)
			{
				DawnPlugin.Logger.LogMessage((object)$"GetBestMatchFromList has not found a word matching the required specificity! ({DawnConfig.TerminalKeywordSpecificity.Value})");
				return null;
			}
			DawnPlugin.Logger.LogMessage((object)$"GetBestMatchFromList has found match with highest priority of {val.word} ({val.GetKeywordPriority()})");
			return val;
		}

		public static bool DawnTryResolveKeyword(this Terminal terminal, string input, [NotNullWhen(true)] out TerminalKeyword? word)
		{
			string input2 = input;
			word = null;
			if (string.IsNullOrWhiteSpace(input2))
			{
				return false;
			}
			if (MatchInputKeyword(input2, out List<TerminalKeyword> words))
			{
				if (words.Count == 1)
				{
					word = words[0];
					return (Object)(object)word != (Object)null;
				}
				word = GetBestMatchFromList(input2, words);
				return (Object)(object)word != (Object)null;
			}
			if (!DawnConfig.TerminalKeywordResolution.Value)
			{
				return false;
			}
			List<TerminalKeyword> list;
			if ((Object)(object)terminal.GetLastVerb() != (Object)null && terminal.GetLastVerb().compatibleNouns != null && terminal.GetLastVerb().compatibleNouns.Length != 0)
			{
				list = terminal.GetLastVerb().compatibleNouns.Select((CompatibleNoun x) => x.noun).ToList();
				list = list.FindAll((TerminalKeyword x) => x.word.StringStartsWithInvariant(input2)).ToList();
			}
			else
			{
				list = terminal.terminalNodes.allKeywords.Where((TerminalKeyword x) => x.word.StringStartsWithInvariant(input2)).ToList();
			}
			if (list.Count == 1)
			{
				word = list[0];
				return (Object)(object)word != (Object)null;
			}
			word = GetBestMatchFromList(input2, list);
			return (Object)(object)word != (Object)null;
		}
	}
	public static class TransformExtensions
	{
		public static void KillAllChildren(this Transform transform)
		{
			for (int num = transform.childCount - 1; num >= 0; num--)
			{
				Object.Destroy((Object)(object)((Component)transform.GetChild(num)).gameObject);
			}
		}
	}
	[Serializable]
	public class HUDDisplayTip : INetworkSerializable
	{
		public enum AlertType
		{
			Hint,
			Warning
		}

		[SerializeField]
		private AlertType _alertType;

		[SerializeField]
		[TextArea(2, 5)]
		private string _header;

		[SerializeField]
		[TextArea(2, 5)]
		private string _body;

		public string Header => _header;

		public string Body => _body;

		public AlertType Type => _alertType;

		public HUDDisplayTip(string header, string body, AlertType type)
		{
			_header = header;
			_body = body;
			_alertType = type;
		}

		public HUDDisplayTip()
			: this(string.Empty, string.Empty, AlertType.Hint)
		{
		}

		public unsafe void NetworkSerialize<T>(BufferSerializer<T> serializer) where T : IReaderWriter
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			serializer.SerializeValue(ref _header, false);
			serializer.SerializeValue(ref _body, false);
			((BufferSerializer<AlertType>*)(&serializer))->SerializeValue<AlertType>(ref _alertType, default(ForEnums));
		}
	}
	public class PlayerControllerReference : INetworkSerializable, IEquatable<PlayerControllerReference>
	{
		private int _playerID;

		public bool IsLocalClient => StartOfRound.Instance.allPlayerScripts[_playerID].IsLocalPlayer();

		public bool IsAlive
		{
			get
			{
				if (!StartOfRound.Instance.allPlayerScripts[_playerID].isPlayerDead)
				{
					return StartOfRound.Instance.allPlayerScripts[_playerID].isPlayerControlled;
				}
				return false;
			}
		}

		public bool IsValid
		{
			get
			{
				if (_playerID != -1)
				{
					return StartOfRound.Instance.allPlayerScripts.Length > _playerID;
				}
				return false;
			}
		}

		public unsafe void NetworkSerialize<T>(BufferSerializer<T> serializer) where T : IReaderWriter
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			((BufferSerializer<int>*)(&serializer))->SerializeValue<int>(ref _playerID, default(ForPrimitives));
		}

		public static implicit operator PlayerControllerB(PlayerControllerReference reference)
		{
			if (reference == null)
			{
				throw new ArgumentNullException("reference is null.");
			}
			if (reference._playerID == -1)
			{
				throw new ArgumentOutOfRangeException("reference is invalid.");
			}
			return StartOfRound.Instance.allPlayerScripts[reference._playerID];
		}

		public static implicit operator PlayerControllerReference(PlayerControllerB player)
		{
			return new PlayerControllerReference
			{
				_playerID = Array.IndexOf(StartOfRound.Instance.allPlayerScripts, player)
			};
		}

		public static implicit operator bool(PlayerControllerReference reference)
		{
			return reference.IsValid;
		}

		public override bool Equals(object? obj)
		{
			if (obj == null)
			{
				return false;
			}
			if (this == obj)
			{
				return true;
			}
			if (obj.GetType() != GetType())
			{
				return false;
			}
			return Equals((PlayerControllerReference)obj);
		}

		public override int GetHashCode()
		{
			return _playerID;
		}

		public bool Equals(PlayerControllerReference? other)
		{
			if (other == null)
			{
				return false;
			}
			if (this == other)
			{
				return true;
			}
			return _playerID == other._playerID;
		}
	}
	public interface IProgress
	{
		float MaxProgress { get; }

		float CurrentProgress { get; }
	}
	public static class IProgressExtensions
	{
		public static float Percentage(this IProgress progress)
		{
			return progress.CurrentProgress / progress.MaxProgress;
		}

		public static float GetCurrentProgress(this IProgress progress)
		{
			return progress.CurrentProgress;
		}

		public static float GetMaxProgress(this IProgress progress)
		{
			return progress.MaxProgress;
		}
	}
	[AddComponentMenu("DawnLib/Audio/Ambient Noise Player")]
	public class AmbientNoisePlayer : MonoBehaviour
	{
		[Header("Audio")]
		[SerializeField]
		private AudioSource _ambientAudioSource;

		[SerializeField]
		private AudioClipsWithTime _idleAudioClips;

		[Header("Extras")]
		[SerializeField]
		private bool _playOnStart;

		[SerializeField]
		private UnityEvent _onAmbientSoundPlayed = new UnityEvent();

		private bool _canPlaySounds = true;

		private float _idleTimer;

		private Random random;

		private static int instances;

		public void Start()
		{
			random = new Random(StartOfRound.Instance.randomMapSeed + instances);
			instances++;
			_idleTimer = random.NextFloat(_idleAudioClips.minTime, _idleAudioClips.maxTime);
			if (_playOnStart)
			{
				PlayRandomAmbientSound();
			}
		}

		public void Update()
		{
			if (_canPlaySounds)
			{
				_idleTimer -= Time.deltaTime;
				if (!(_idleTimer > 0f))
				{
					PlayRandomAmbientSound();
				}
			}
		}

		private void PlayRandomAmbientSound()
		{
			if (_idleAudioClips.audioClips.Length != 0)
			{
				_idleTimer = random.NextFloat(_idleAudioClips.minTime, _idleAudioClips.maxTime);
				_ambientAudioSource.PlayOneShot(_idleAudioClips.audioClips[random.Next(_idleAudioClips.audioClips.Length)]);
				_onAmbientSoundPlayed.Invoke();
			}
		}

		public void SetPlayable(bool isPlayable)
		{
			_canPlaySounds = isPlayable;
		}

		public void ResetAmbientTimer()
		{
			_idleTimer = random.NextFloat(_idleAudioClips.minTime, _idleAudioClips.maxTime);
		}

		public void ForcePlayAmbientSound()
		{
			PlayRandomAmbientSound();
		}
	}
	[Serializable]
	public class AnimationEventData
	{
		[field: SerializeField]
		public string AnimationEventName { get; internal set; }

		[field: SerializeField]
		public float Time { get; internal set; }

		[field: Header("Optional | Parameters")]
		[field: SerializeField]
		public string StringParameter { get; internal set; } = string.Empty;


		[field: SerializeField]
		public int IntParameter { get; internal set; }

		[field: SerializeField]
		public float FloatParameter { get; internal set; }

		[field: SerializeField]
		public bool BoolParameter { get; internal set; }

		[field: SerializeField]
		public Object? ObjectParameter { get; internal set; }
	}
	[Serializable]
	public class MaterialsWithRenderer
	{
		public Material[] materials = Array.Empty<Material>();

		public Renderer renderer;
	}
	[Serializable]
	public class MaterialRendererVariantWithWeight : IWeighted
	{
		public MaterialsWithRenderer materialsWithRenderer = new MaterialsWithRenderer();

		[field: SerializeField]
		private int _weight { get; set; } = 1;


		public int GetWeight()
		{
			return _weight;
		}
	}
	[AddComponentMenu("DawnLib/Misc Utilities/Apply Renderer Variants")]
	public class ApplyRendererVariants : NetworkBehaviour
	{
		[SerializeField]
		private MaterialRendererVariantWithWeight[] _materialsWithRendererWithWeight = Array.Empty<MaterialRendererVariantWithWeight>();

		[SerializeField]
		private bool _applyOnSpawn = true;

		private NetworkVariable<int> _currentVariant = new NetworkVariable<int>(0, (NetworkVariableReadPermission)0, (NetworkVariableWritePermission)1);

		public override void OnNetworkSpawn()
		{
			((NetworkBehaviour)this).OnNetworkSpawn();
			if (((NetworkBehaviour)this).IsServer)
			{
				Random random = new Random();
				_currentVariant.Value = Array.IndexOf(_materialsWithRendererWithWeight, random.NextWeighted(_materialsWithRendererWithWeight));
			}
			if (_applyOnSpawn)
			{
				ApplyMaterialVariantsToRenderers();
			}
		}

		public void ApplyMaterialVariantsToRenderers()
		{
			_materialsWithRendererWithWeight[_currentVariant.Value].materialsWithRenderer.renderer.sharedMaterials = _materialsWithRendererWithWeight[_currentVariant.Value].materialsWithRenderer.materials;
		}

		protected override void __initializeVariables()
		{
			if (_currentVariant == null)
			{
				throw new Exception("ApplyRendererVariants._currentVariant cannot be null. All NetworkVariableBase instances must be initialized.");
			}
			((NetworkVariableBase)_currentVariant).Initialize((NetworkBehaviour)(object)this);
			((NetworkBehaviour)this).__nameNetworkVariable((NetworkVariableBase)(object)_currentVariant, "_currentVariant");
			base.NetworkVariableFields.Add((NetworkVariableBase)(object)_currentVariant);
			((NetworkBehaviour)this).__initializeVariables();
		}

		protected override void __initializeRpcs()
		{
			((NetworkBehaviour)this).__initializeRpcs();
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		protected internal override string __getTypeName()
		{
			return "ApplyRendererVariants";
		}
	}
	[Serializable]
	public class AudioClipsWithTime
	{
		public AudioClip[] audioClips;

		public float minTime;

		public float maxTime;
	}
	[Serializable]
	public class AudioSourceWithClips
	{
		[Tooltip("Near AudioSource that will play the clips.")]
		public AudioSource nearAudioSource;

		[Tooltip("List of close audio clips that can be played.")]
		public AudioClip[] nearClips;

		[Tooltip("Far AudioSource that will play the clips.")]
		public AudioSource farAudioSource;

		[Tooltip("List of far audio clips that can be played.")]
		public AudioClip[] farClips;
	}
	[AddComponentMenu("DawnLib/Misc Utilities/Auto Rotate")]
	public class AutoRotate : MonoBehaviour
	{
		[SerializeField]
		private float _rotationSpeedMax = 5f;

		[SerializeField]
		private float _rotationSpeedMin;

		private Vector3 _rotation = Vector3.zero;

		private static int instances;

		private void Start()
		{
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			Random random = new Random(StartOfRound.Instance.randomMapSeed + instances);
			instances++;
			float num = random.NextFloat(_rotationSpeedMin, _rotationSpeedMax);
			float num2 = random.NextFloat(_rotationSpeedMin, _rotationSpeedMax);
			float num3 = random.NextFloat(_rotationSpeedMin, _rotationSpeedMax);
			_rotation = new Vector3(num, num2, num3);
		}

		private void Update()
		{
			//IL_0007: 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)
			((Component)this).transform.Rotate(_rotation * Time.deltaTime);
		}
	}
	[DefaultExecutionOrder(-999)]
	[AddComponentMenu("DawnLib/Misc Utilities/Synced Chance")]
	public class ChanceScript : NetworkBehaviour
	{
		[CompilerGenerated]
		private sealed class <DelayRandomThing>d__4 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public ChanceScript <>4__this;

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

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

			[DebuggerHidden]
			public <DelayRandomThing>d__4(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_003e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0048: Expected O, but got Unknown
				int num = <>1__state;
				ChanceScript chanceScript = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitUntil((Func<bool>)(() => (Object)(object)NetworkSingleton<DawnNetworker>.Instance != (Object)null));
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					if (((NetworkBehaviour)chanceScript).IsServer)
					{
						int value = Random.Range(0, 100) + 1;
						chanceScript.result.Value = value;
					}
					if (chanceScript.result.Value > chanceScript._chance)
					{
						return false;
					}
					chanceScript._onChance.Invoke();
					return false;
				}
			}

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

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

		[SerializeField]
		private UnityEvent _onChance = new UnityEvent();

		[SerializeField]
		[Range(0f, 100f)]
		private int _chance = 50;

		private NetworkVariable<int> result = new NetworkVariable<int>(0, (NetworkVariableReadPermission)0, (NetworkVariableWritePermission)0);

		public override void OnNetworkSpawn()
		{
			((NetworkBehaviour)this).OnNetworkSpawn();
			if ((Object)(object)NetworkSingleton<DawnNetworker>.Instance == (Object)null)
			{
				DawnPlugin.Logger.LogWarning((object)"DawnLibNetworker.Instance is null! I really hope you're starting up the round right now");
				((MonoBehaviour)this).StartCoroutine(DelayRandomThing());
				return;
			}
			if (((NetworkBehaviour)this).IsServer)
			{
				int value = Random.Range(0, 100) + 1;
				result.Value = value;
			}
			if (result.Value <= _chance)
			{
				_onChance.Invoke();
			}
		}

		[IteratorStateMachine(typeof(<DelayRandomThing>d__4))]
		private IEnumerator DelayRandomThing()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <DelayRandomThing>d__4(0)
			{
				<>4__this = this
			};
		}

		protected override void __initializeVariables()
		{
			if (result == null)
			{
				throw new Exception("ChanceScript.result cannot be null. All NetworkVariableBase instances must be initialized.");
			}
			((NetworkVariableBase)result).Initialize((NetworkBehaviour)(object)this);
			((NetworkBehaviour)this).__nameNetworkVariable((NetworkVariableBase)(object)result, "result");
			base.NetworkVariableFields.Add((NetworkVariableBase)(object)result);
			((NetworkBehaviour)this).__initializeVariables();
		}

		protected override void __initializeRpcs()
		{
			((NetworkBehaviour)this).__initializeRpcs();
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		protected internal override string __getTypeName()
		{
			return "ChanceScript";
		}
	}
	[DisallowMultipleComponent]
	[AddComponentMenu("DawnLib/Networking/Client Network Transform")]
	public class ClientNetworkTransform : NetworkTransform
	{
		public override bool OnIsServerAuthoritative()
		{
			return false;
		}

		public override void OnOwnershipChanged(ulong previous, ulong current)
		{
			if (base.m_CachedNetworkManager.IsServer)
			{
				((NetworkTransform)this).InternalInitialization(true);
				DawnPlugin.Logger.LogDebug((object)$"[ClientNetworkTransform] Ownership changed from {previous} to {current}. Re-initialized NetworkTransform.");
			}
			((NetworkTransform)this).OnOwnershipChanged(previous, current);
		}

		protected override void __initializeVariables()
		{
			((NetworkTransform)this).__initializeVariables();
		}

		protected override void __initializeRpcs()
		{
			((NetworkTransform)this).__initializeRpcs();
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		protected internal override string __getTypeName()
		{
			return "ClientNetworkTransform";
		}
	}
	[AddComponentMenu("DawnLib/Moon Utils/Dust Clouds Override")]
	public class DawnDustCloudsOverride : MonoBehaviour
	{
		private LocalVolumetricFog _fog;

		private Vector3 _oldSize;

		[field: SerializeField]
		public Vector3 NewFogSize { get; private set; } = new Vector3(50f, 15f, 50f);


		public void Awake()
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			GameObject effectObject = LethalContent.Weathers[WeatherKeys.Rollinggroundfog].WeatherEffect.effectObject;
			_fog = effectObject.GetComponent<LocalVolumetricFog>();
			_oldSize = _fog.parameters.size;
			_fog.parameters.size = NewFogSize;
		}

		public void OnDestroy()
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			_fog.parameters.size = _oldSize;
		}
	}
	[AddComponentMenu("DawnLib/Moon Utils/Eclipsed Override")]
	public class DawnEclipsedOverride : MonoBehaviour
	{
		private AudioClip _oldEclipsedMusic;

		private AudioSource _eclipsedAudioSource;

		[field: SerializeField]
		public AudioClip? NewEclipsedMusic { get; private set; }

		private void Start()
		{
			GameObject effectObject = LethalContent.Weathers[WeatherKeys.Eclipsed].WeatherEffect.effectObject;
			_eclipsedAudioSource = effectObject.GetComponentInChildren<AudioSource>();
			_oldEclipsedMusic = _eclipsedAudioSource.clip;
			_eclipsedAudioSource.clip = NewEclipsedMusic;
		}

		private void OnDestroy()
		{
			_eclipsedAudioSource.clip = _oldEclipsedMusic;
		}
	}
	[AddComponentMenu("DawnLib/Moon Utils/Flooded Override")]
	public class DawnFloodedOverride : MonoBehaviour
	{
		private AudioSource _floodedAmbienceSource;

		private AudioClip _oldFloodedAmbience;

		private GameObject _oldFloodedPrefab;

		private GameObject _newFloodInstance;

		[field: SerializeField]
		public AudioClip? NewFloodedAmbience { get; private set; }

		[field: SerializeField]
		public GameObject? NewFloodedPrefab { get; private set; }

		public void Awake()
		{
			_oldFloodedPrefab = LethalContent.Weathers[WeatherKeys.Flooded].WeatherEffect.effectPermanentObject;
			if ((Object)(object)NewFloodedAmbience != (Object)null)
			{
				_floodedAmbienceSource = _oldFloodedPrefab.GetComponentInChildren<AudioSource>();
				_oldFloodedAmbience = _floodedAmbienceSource.clip;
				_floodedAmbienceSource.clip = NewFloodedAmbience;
			}
			if ((Object)(object)NewFloodedPrefab != (Object)null)
			{
				_newFloodInstance = Object.Instantiate<GameObject>(NewFloodedPrefab, _oldFloodedPrefab.transform);
				((Component)_oldFloodedPrefab.transform.GetChild(0)).gameObject.SetActive(false);
				((Component)_oldFloodedPrefab.transform.GetChild(1)).gameObject.SetActive(false);
			}
		}

		public void OnDestroy()
		{
			if ((Object)(object)NewFloodedAmbience != (Object)null)
			{
				_floodedAmbienceSource.clip = _oldFloodedAmbience;
			}
			if ((Object)(object)NewFloodedPrefab != (Object)null)
			{
				Object.Destroy((Object)(object)_newFloodInstance);
				((Component)_oldFloodedPrefab.transform.GetChild(0)).gameObject.SetActive(true);
				((Component)_oldFloodedPrefab.transform.GetChild(1)).gameObject.SetActive(true);
			}
		}
	}
	[AddComponentMenu("DawnLib/Moon Utils/Foggy Override")]
	public class DawnFoggyOverride : MonoBehaviour
	{
		private LocalVolumetricFog _fog;

		private Vector3 _oldSize;

		[field: SerializeField]
		public Vector3 NewFogSize { get; private set; } = new Vector3(50f, 15f, 50f);


		public void Awake()
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			GameObject effectPermanentObject = LethalContent.Weathers[WeatherKeys.Foggy].WeatherEffect.effectPermanentObject;
			_fog = effectPermanentObject.GetComponent<LocalVolumetricFog>();
			_oldSize = _fog.parameters.size;
			_fog.parameters.size = NewFogSize;
		}

		public void OnDestroy()
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			_fog.parameters.size = _oldSize;
		}
	}
	[Serializable]
	public class DawnLibObjectTypeWithRarity
	{
		public NamespacedKey<DawnMapObjectInfo> NamespacedMapObjectKey;

		public int Rarity;
	}
	public static class DawnLibUtilities
	{
		public static T? ChooseRandomWeightedType<T>(IEnumerable<(T objectType, float rarity)> rarityList)
		{
			List<(T, float)> list = rarityList.Where<(T, float)>(((T objectType, float rarity) x) => x.rarity > 0f).ToList();
			float num = 0f;
			List<(T, float)> list2 = new List<(T, float)>(list.Count);
			for (int i = 0; i < list.Count; i++)
			{
				num += list[i].Item2;
				list2.Add((list[i].Item1, num));
			}
			float num2 = Random.Range(0f, num);
			T val = default(T);
			foreach (var (val2, num3) in list2)
			{
				if (num2 < num3)
				{
					val = val2;
					break;
				}
			}
			if (val == null)
			{
				DawnPlugin.Logger.LogWarning((object)("Could not find a valid object to spawn of type " + typeof(T).Name + "!"));
				return default(T);
			}
			return val;
		}
	}
	[AddComponentMenu("DawnLib/Moon Utils/Rainy Override")]
	public class DawnRainyOverride : MonoBehaviour
	{
		private AudioClip? _oldRainSound;

		private AudioSource _rainAudioSource;

		private GameObject _rainyOverridePrefab;

		private GameObject _rainyParticlesPrefab;

		[field: SerializeField]
		public AudioClip? NewRainSound { get; private set; }

		[field: SerializeField]
		public GameObject? NewRainyPrefab { get; private set; }

		public void Awake()
		{
			GameObject effectObject = LethalContent.Weathers[WeatherKeys.Rainy].WeatherEffect.effectObject;
			if ((Object)(object)NewRainSound != (Object)null)
			{
				_rainAudioSource = effectObject.GetComponent<AudioSource>();
				_oldRainSound = _rainAudioSource.clip;
				_rainAudioSource.clip = NewRainSound;
			}
			if ((Object)(object)NewRainyPrefab != (Object)null)
			{
				_rainyParticlesPrefab = ((Component)effectObject.transform.Find("Particle System")).gameObject;
				_rainyParticlesPrefab.SetActive(false);
				_rainyOverridePrefab = Object.Instantiate<GameObject>(NewRainyPrefab, effectObject.transform);
			}
		}

		public void OnDestroy()
		{
			if ((Object)(object)NewRainSound != (Object)null)
			{
				_rainAudioSource.clip = _oldRainSound;
			}
			if ((Object)(object)NewRainyPrefab != (Object)null)
			{
				Object.Destroy((Object)(object)_rainyOverridePrefab);
				_rainyParticlesPrefab.SetActive(true);
			}
		}
	}
	[AddComponentMenu("DawnLib/Moon Utils/Stormy Override")]
	public class DawnStormyOverride : MonoBehaviour
	{
		private GameObject _stormyObject;

		private AudioSource _stormyAmbienceSource;

		private AudioClip _oldStormyAmbience;

		private GameObject _newStormyRainInstance;

		private ParticleSystem _oldExplosionEffectParticle;

		private ParticleSystem _oldStaticElectricityParticle;

		private AudioClip[] _oldLightningStrikeSFX;

		private AudioClip[] _oldDistantThunderSFX;

		private AudioClip _oldStaticElectricitySFX;

		[field: SerializeField]
		public AudioClip? NewStormyRainAmbience { get; private set; }

		[field: SerializeField]
		public ParticleSystem? NewStormyLightningStrikeExplosionPrefab { get; private set; }

		[field: SerializeField]
		public ParticleSystem? NewStormyStaticElectricityPrefab { get; private set; }

		[field: SerializeField]
		public AudioClip[] NewLightningStrikeSFX { get; private set; }

		[field: SerializeField]
		public AudioClip[] NewDistantThunderSFX { get; private set; }

		[field: SerializeField]
		public AudioClip NewStaticElectricitySFX { get; private set; }

		[field: SerializeField]
		public GameObject? NewStormyRainPrefab { get; private set; }

		public void Awake()
		{
			_stormyObject = LethalContent.Weathers[WeatherKeys.Flooded].WeatherEffect.effectPermanentObject;
			if ((Object)(object)NewStormyRainAmbience != (Object)null)
			{
				_stormyAmbienceSource = _stormyObject.GetComponentInChildren<AudioSource>();
				_oldStormyAmbience = _stormyAmbienceSource.clip;
				_stormyAmbienceSource.clip = NewStormyRainAmbience;
			}
			StormyWeather component = _stormyObject.GetComponent<StormyWeather>();
			if ((Object)(object)NewStormyLightningStrikeExplosionPrefab != (Object)null)
			{
				_oldExplosionEffectParticle = component.explosionEffectParticle;
				component.explosionEffectParticle = Object.Instantiate<ParticleSystem>(NewStormyLightningStrikeExplosionPrefab, _stormyObject.transform);
			}
			if ((Object)(object)NewStormyStaticElectricityPrefab != (Object)null)
			{
				_oldStaticElectricityParticle = component.staticElectricityParticle;
				component.staticElectricityParticle = Object.Instantiate<ParticleSystem>(NewStormyStaticElectricityPrefab, _stormyObject.transform);
			}
			if (NewLightningStrikeSFX.Length != 0)
			{
				_oldLightningStrikeSFX = component.strikeSFX;
				component.strikeSFX = NewLightningStrikeSFX;
			}
			if (NewDistantThunderSFX.Length != 0)
			{
				_oldDistantThunderSFX = component.distantThunderSFX;
				component.distantThunderSFX = NewDistantThunderSFX;
			}
			if ((Object)(object)NewStaticElectricitySFX != (Object)null)
			{
				_oldStaticElectricitySFX = component.staticElectricityAudio;
				component.staticElectricityAudio = NewStaticElectricitySFX;
			}
			if ((Object)(object)NewStormyRainPrefab != (Object)null)
			{
				GameObject gameObject = ((Component)LethalContent.Weathers[WeatherKeys.Flooded].WeatherEffect.effectObject.transform.Find("Particle System")).gameObject;
				_newStormyRainInstance = Object.Instantiate<GameObject>(NewStormyRainPrefab, gameObject.transform.parent);
				gameObject.SetActive(false);
			}
		}

		public void OnDestroy()
		{
			if ((Object)(object)NewStormyRainAmbience != (Object)null)
			{
				_stormyAmbienceSource.clip = _oldStormyAmbience;
			}
			StormyWeather component = _stormyObject.GetComponent<StormyWeather>();
			if ((Object)(object)NewStormyLightningStrikeExplosionPrefab != (Object)null)
			{
				Object.Destroy((Object)(object)component.explosionEffectParticle);
				component.explosionEffectParticle = _oldExplosionEffectParticle;
			}
			if ((Object)(object)NewStormyStaticElectricityPrefab != (Object)null)
			{
				Object.Destroy((Object)(object)component.staticElectricityParticle);
				component.staticElectricityParticle = _oldStaticElectricityParticle;
			}
			if (NewLightningStrikeSFX.Length != 0)
			{
				component.strikeSFX = _oldLightningStrikeSFX;
			}
			if (NewDistantThunderSFX.Length != 0)
			{
				component.distantThunderSFX = _oldDistantThunderSFX;
			}
			if ((Object)(object)NewStaticElectricitySFX != (Object)null)
			{
				component.staticElectricityAudio = _oldStaticElectricitySFX;
			}
			if ((Object)(object)NewStormyRainPrefab != (Object)null)
			{
				GameObject effectObject = LethalContent.Weathers[WeatherKeys.Flooded].WeatherEffect.effectObject;
				Object.Destroy((Object)(object)_newStormyRainInstance);
				effectObject.SetActive(true);
			}
		}
	}
	[AddComponentMenu("DawnLib/Triggers/Enemy Only Trigger")]
	public class EnemyOnlyTriggers : MonoBehaviour
	{
		public EnemyAI mainScript;

		public void OnTriggerStay(Collider other)
		{
			EnemyAICollisionDetect val = default(EnemyAICollisionDetect);
			if (((Component)other).TryGetComponent<EnemyAICollisionDetect>(ref val) && !((Object)(object)val.mainScript == (Object)(object)mainScript))
			{
				mainScript.OnCollideWithEnemy(other, val.mainScript);
			}
		}
	}
	[RequireComponent(typeof(EnemyAI))]
	[AddComponentMenu("DawnLib/Extra Events/Extra Enemy Events")]
	public class ExtraEnemyEvents : MonoBehaviour
	{
		internal static Dictionary<EnemyAI, ExtraEnemyEvents> eventListeners = new Dictionary<EnemyAI, ExtraEnemyEvents>();

		[SerializeField]
		internal UnityEvent onKilled;

		[SerializeField]
		internal UnityEvent onKilledByPlayer = new UnityEvent();

		private EnemyAI enemyAI;

		private void OnEnable()
		{
			enemyAI = ((Component)this).GetComponent<EnemyAI>();
			eventListeners[enemyAI] = this;
		}

		private void OnDisable()
		{
			eventListeners.Remove(enemyAI);
		}
	}
	[RequireComponent(typeof(GrabbableObject))]
	[AddComponentMenu("DawnLib/Extra Events/Extra Item Events")]
	public class ExtraItemEvents : MonoBehaviour
	{
		internal static Dictionary<GrabbableObject, ExtraItemEvents> eventListeners = new Dictionary<GrabbableObject, ExtraItemEvents>();

		[SerializeField]
		internal UnityEvent onCollectInShip;

		private void OnEnable()
		{
			eventListeners[((Component)this).GetComponent<GrabbableObject>()] = this;
		}

		private void OnDisable()
		{
			eventListeners.Remove(((Component)this).GetComponent<GrabbableObject>());
		}
	}
	[RequireComponent(typeof(ScanNodeProperties))]
	[AddComponentMenu("DawnLib/Extra Events/Extra Scan Events")]
	public class ExtraScanEvents : MonoBehaviour
	{
		internal static readonly NamespacedKey _dataKey = NamespacedKey.From("dawn_lib", "already_scanned");

		[SerializeField]
		private UnityEvent _onScan;

		[Header("First scan")]
		[SerializeField]
		[Tooltip("Optional")]
		private NamespacedKey _saveId;

		[SerializeField]
		private UnityEvent _onFirstScan;

		internal void OnScan()
		{
			_onScan.Invoke();
			if (!string.IsNullOrWhiteSpace(_saveId.Namespace) && !string.IsNullOrWhiteSpace(_saveId.Key))
			{
				HashSet<NamespacedKey> orCreateDefault = DawnLib.GetCurrentSave().GetOrCreateDefault<HashSet<NamespacedKey>>(_dataKey);
				if (!orCreateDefault.Contains(_saveId))
				{
					_onFirstScan.Invoke();
					orCreateDefault.Add(_saveId);
					DawnLib.GetCurrentSave().Set(_dataKey, orCreateDefault);
				}
			}
		}
	}
	[AddComponentMenu("DawnLib/Misc Utilities/Force Scan Color On Item")]
	public class ForceScanColorOnItem : MonoBehaviour
	{
		public GrabbableObject grabbableObject;

		public Color borderColor = Color.green;

		public Color textColor = Color.green;

		[SerializeField]
		private ScanNodeProperties? scanNodeProperties;

		public void Start()
		{
			FindGrabbableObjectsScanObject();
		}

		public void FindGrabbableObjectsScanObject()
		{
			if (!((Object)(object)grabbableObject == (Object)null) && !((Object)(object)scanNodeProperties != (Object)null))
			{
				scanNodeProperties = ((Component)grabbableObject).GetComponentInChildren<ScanNodeProperties>();
			}
		}

		public void LateUpdate()
		{
			if ((Object)(object)scanNodeProperties == (Object)null)
			{
				return;
			}
			if (GoodItemScanCompat.Enabled && GoodItemScanCompat.TryGetRectTransform(scanNodeProperties, out RectTransform rectTransform))
			{
				HandleChangingColor(rectTransform);
			}
			if (!HUDManager.Instance.scanNodes.ContainsValue(scanNodeProperties))
			{
				return;
			}
			foreach (var (rectTransformOfImportance, val3) in HUDManager.Instance.scanNodes)
			{
				if ((Object)(object)val3 == (Object)(object)scanNodeProperties)
				{
					HandleChangingColor(rectTransformOfImportance);
					break;
				}
			}
		}

		private void HandleChangingColor(RectTransform rectTransformOfImportance)
		{
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			ScanNodeAdditionalData scanNodeAdditionalData = ScanNodeAdditionalData.CreateOrGet(rectTransformOfImportance);
			foreach (Image item in scanNodeAdditionalData.ImagesAttached)
			{
				((Graphic)item).color = new Color(borderColor.r, borderColor.g, borderColor.b, ((Graphic)item).color.a);
			}
			foreach (TextMeshProUGUI item2 in scanNodeAdditionalData.TextsAttached)
			{
				((Graphic)item2).color = new Color(textColor.r, textColor.g, textColor.b, ((Graphic)item2).color.a);
			}
		}
	}
	[DisallowMultipleComponent]
	[RequireComponent(typeof(AudioSource))]
	[AddComponentMenu("DawnLib/Audio/Network Audio Source")]
	public class NetworkAudioSource : NetworkBehaviour
	{
		private class PlayPacket : INetworkSerializable
		{
			public bool HasPoolClipID;

			public int ClipID;

			public bool HasPitch;

			public float Pitch;

			public bool HasVolume;

			public float Volume;

			public bool IsOneShot;

			public ulong CallerID;

			public unsafe void NetworkSerialize<T>(BufferSerializer<T> serializer) where T : IReaderWriter
			{
				//IL_000a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0010: Unknown result type (might be due to invalid IL or missing references)
				//IL_0020: Unknown result type (might be due to invalid IL or missing references)
				//IL_0026: Unknown result type (might be due to invalid IL or missing references)
				//IL_0036: Unknown result type (might be due to invalid IL or missing references)
				//IL_003c: Unknown result type (might be due to invalid IL or missing references)
				//IL_006a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0070: Unknown result type (might be due to invalid IL or missing references)
				//IL_0054: Unknown result type (might be due to invalid IL or missing references)
				//IL_005a: Unknown result type (might be due to invalid IL or missing references)
				//IL_009e: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
				//IL_0088: Unknown result type (might be due to invalid IL or missing references)
				//IL_008e: Unknown result type (might be due to invalid IL or missing references)
				//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
				((BufferSerializer<ulong>*)(&serializer))->SerializeValue<ulong>(ref CallerID, default(ForPrimitives));
				((BufferSerializer<bool>*)(&serializer))->SerializeValue<bool>(ref IsOneShot, default(ForPrimitives));
				((BufferSerializer<bool>*)(&serializer))->SerializeValue<bool>(ref HasPoolClipID, default(ForPrimitives));
				if (HasPoolClipID)
				{
					((BufferSerializer<int>*)(&serializer))->SerializeValue<int>(ref ClipID, default(ForPrimitives));
				}
				((BufferSerializer<bool>*)(&serializer))->SerializeValue<bool>(ref HasPitch, default(ForPrimitives));
				if (HasPitch)
				{
					((BufferSerializer<float>*)(&serializer))->SerializeValue<float>(ref Pitch, default(ForPrimitives));
				}
				((BufferSerializer<bool>*)(&serializer))->SerializeValue<bool>(ref HasVolume, default(ForPrimitives));
				if (HasVolume)
				{
					((BufferSerializer<float>*)(&serializer))->SerializeValue<float>(ref Volume, default(ForPrimitives));
				}
			}
		}

		[SerializeField]
		private bool _syncClipFromPool;

		[SerializeField]
		private bool _syncPitch;

		[SerializeField]
		private bool _syncVolume;

		[SerializeField]
		private bool _requiresOwnership = true;

		[SerializeField]
		private AudioClip[] _poolToSync;

		private AudioSource _source;

		private void Awake()
		{
			_source = ((Component)this).GetComponent<AudioSource>();
		}

		private void CreateNetworkEvent(AudioClip clip, bool isOneShot)
		{
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			PlayPacket playPacket = new PlayPacket
			{
				CallerID = ((NetworkBehaviour)this).NetworkManager.LocalClientId,
				IsOneShot = isOneShot
			};
			if (_syncClipFromPool)
			{
				playPacket.HasPoolClipID = true;
				playPacket.ClipID = Array.IndexOf(_poolToSync, clip);
			}
			else if (isOneShot)
			{
				DawnPlugin.Logger.LogError((object)("NetworkAudioSource failure on " + ((Object)((Component)this).gameObject).name + ". PlayOneShot requires SyncClipFromPool = true."));
				return;
			}
			if (_syncPitch)
			{
				playPacket.HasPitch = true;
				playPacket.Pitch = _source.pitch;
			}
			if (_syncVolume)
			{
				playPacket.HasVolume = true;
				playPacket.Volume = _source.volume;
			}
			SendPlayPacketServerRPC(playPacket);
			ActOnPlayPacket(playPacket);
		}

		public void Play()
		{
			CreateNetworkEvent(_source.clip, isOneShot: false);
		}

		public void PlayOneShot(AudioClip clip)
		{
			CreateNetworkEvent(clip, isOneShot: true);
		}

		[ServerRpc(RequireOwnership = false)]
		private void SendPlayPacketServerRPC(PlayPacket packet, ServerRpcParams serverRpcParams = default(ServerRpcParams))
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
			{
				FastBufferWriter val = ((NetworkBehaviour)this).__beginSendServerRpc(2594827363u, serverRpcParams, (RpcDelivery)0);
				bool flag = packet != null;
				((FastBufferWriter)(ref val)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val)).WriteValueSafe<PlayPacket>(ref packet, default(ForNetworkSerializable));
				}
				((NetworkBehaviour)this).__endSendServerRpc(ref val, 2594827363u, serverRpcParams, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				base.__rpc_exec_stage = (__RpcExecStage)0;
				ReceivePlayPacketClientRPC(packet, serverRpcParams.Receive.SenderClientId == ((NetworkBehaviour)this).OwnerClientId);
			}
		}

		[ClientRpc]
		private void ReceivePlayPacketClientRPC(PlayPacket packet, bool isFromOwner)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager == null || !networkManager.IsListening)
			{
				return;
			}
			if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
			{
				ClientRpcParams val = default(ClientRpcParams);
				FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(3949821193u, val, (RpcDelivery)0);
				bool flag = packet != null;
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref flag, default(ForPrimitives));
				if (flag)
				{
					((FastBufferWriter)(ref val2)).WriteValueSafe<PlayPacket>(ref packet, default(ForNetworkSerializable));
				}
				((FastBufferWriter)(ref val2)).WriteValueSafe<bool>(ref isFromOwner, default(ForPrimitives));
				((NetworkBehaviour)this).__endSendClientRpc(ref val2, 3949821193u, val, (RpcDelivery)0);
			}
			if ((int)base.__rpc_exec_stage != 1 || (!networkManager.IsClient && !networkManager.IsHost))
			{
				return;
			}
			base.__rpc_exec_stage = (__RpcExecStage)0;
			if (packet.CallerID != ((NetworkBehaviour)this).NetworkManager.LocalClientId)
			{
				if (isFromOwner && _requiresOwnership)
				{
					DawnPlugin.Logger.LogWarning((object)"Received Play Packet from non-owner. Dropping");
				}
				else
				{
					ActOnPlayPacket(packet);
				}
			}
		}

		private void ActOnPlayPacket(PlayPacket packet)
		{
			if (packet.HasPitch)
			{
				_source.pitch = packet.Pitch;
			}
			if (packet.HasVolume)
			{
				_source.volume = packet.Volume;
			}
			AudioClip val = null;
			if (packet.HasPoolClipID)
			{
				val = _poolToSync[packet.ClipID];
			}
			if (packet.IsOneShot)
			{
				_source.PlayOneShot(val);
				return;
			}
			_source.clip = val;
			_source.Play();
		}

		protected override void __initializeVariables()
		{
			((NetworkBehaviour)this).__initializeVariables();
		}

		protected override void __initializeRpcs()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Expected O, but got Unknown
			((NetworkBehaviour)this).__registerRpc(2594827363u, new RpcReceiveHandler(__rpc_handler_2594827363), "SendPlayPacketServerRPC");
			((NetworkBehaviour)this).__registerRpc(3949821193u, new RpcReceiveHandler(__rpc_handler_3949821193), "ReceivePlayPacketClientRPC");
			((NetworkBehaviour)this).__initializeRpcs();
		}

		private static void __rpc_handler_2594827363(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: 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_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				bool flag = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
				PlayPacket packet = null;
				if (flag)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe<PlayPacket>(ref packet, default(ForNetworkSerializable));
				}
				ServerRpcParams server = rpcParams.Server;
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((NetworkAudioSource)(object)target).SendPlayPacketServerRPC(packet, server);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_3949821193(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: 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_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				bool flag = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref flag, default(ForPrimitives));
				PlayPacket packet = null;
				if (flag)
				{
					((FastBufferReader)(ref reader)).ReadValueSafe<PlayPacket>(ref packet, default(ForNetworkSerializable));
				}
				bool isFromOwner = default(bool);
				((FastBufferReader)(ref reader)).ReadValueSafe<bool>(ref isFromOwner, default(ForPrimitives));
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((NetworkAudioSource)(object)target).ReceivePlayPacketClientRPC(packet, isFromOwner);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		protected internal override string __getTypeName()
		{
			return "NetworkAudioSource";
		}
	}
	[DisallowMultipleComponent]
	[AddComponentMenu("DawnLib/Networking/Owner Network Animator")]
	public class OwnerNetworkAnimator : NetworkAnimator
	{
		public override bool OnIsServerAuthoritative()
		{
			return false;
		}

		protected override void __initializeVariables()
		{
			((NetworkAnimator)this).__initializeVariables();
		}

		protected override void __initializeRpcs()
		{
			((NetworkAnimator)this).__initializeRpcs();
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		protected internal override string __getTypeName()
		{
			return "OwnerNetworkAnimator";
		}
	}
	[AddComponentMenu("DawnLib/Triggers/Player Only Trigger")]
	public class PlayerOnlyTriggers : MonoBehaviour
	{
		public EnemyAI mainScript;

		public void OnTriggerStay(Collider other)
		{
			PlayerControllerB val = default(PlayerControllerB);
			if (((Component)other).TryGetComponent<PlayerControllerB>(ref val))
			{
				mainScript.OnCollideWithPlayer(other);
			}
		}
	}
	public class ScanNodeAdditionalData
	{
		private static readonly Dictionary<RectTransform, ScanNodeAdditionalData> _additionalData = new Dictionary<RectTransform, ScanNodeAdditionalData>();

		private RectTransform _rectTransform;

		private List<Image> _imagesAttached = new List<Image>();

		private List<TextMeshProUGUI> _textsAttached = new List<TextMeshProUGUI>();

		public IReadOnlyList<Image> ImagesAttached => _imagesAttached.AsReadOnly();

		public IReadOnlyList<TextMeshProUGUI> TextsAttached => _textsAttached.AsReadOnly();

		private ScanNodeAdditionalData(RectTransform rectTransform)
		{
			_rectTransform = rectTransform;
			_additionalData[rectTransform] = this;
			_imagesAttached = ((Component)_rectTransform).GetComponentsInChildren<Image>().ToList();
			Transform child = ((Transform)_rectTransform).GetChild(1);
			_textsAttached = ((Component)child).GetComponentsInChildren<TextMeshProUGUI>().ToList();
		}

		private void OnDestroy()
		{
			_additionalData.Remove(_rectTransform);
		}

		public bool TryGetScanNode([NotNullWhen(true)] out ScanNodeProperties? scanNodeProperties)
		{
			scanNodeProperties = null;
			if (GoodItemScanCompat.Enabled && GoodItemScanCompat.TryGetScanNode(_rectTransform, out scanNodeProperties))
			{
				return true;
			}
			if (HUDManager.Instance.scanNodes.TryGetValue(_rectTransform, out scanNodeProperties))
			{
				return true;
			}
			return false;
		}

		public static ScanNodeAdditionalData CreateOrGet(RectTransform rectTransform)
		{
			if (_additionalData.TryGetValue(rectTransform, out ScanNodeAdditionalData value))
			{
				return value;
			}
			return new ScanNodeAdditionalData(rectTransform);
		}
	}
	[AddComponentMenu("DawnLib/Misc Utilities/Spawn Synced Map Object")]
	public class SpawnSyncedDawnLibObject : MonoBehaviour
	{
		[Range(0f, 100f)]
		public float chanceOfSpawningAny = 100f;

		public bool automaticallyAlignWithTerrain;

		public List<DawnLibObjectTypeWithRarity> objectTypesWithRarity = new List<DawnLibObjectTypeWithRarity>();

		public void Start()
		{
			//IL_0176: Unknown result type (might be due to invalid IL or missing references)
			//IL_0181: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			//IL_012d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0153: Unknown result type (might be due to invalid IL or missing references)
			//IL_0165: Unknown result type (might be due to invalid IL or missing references)
			if (!NetworkManager.Singleton.IsServer || (float)Random.Range(0, 100) >= chanceOfSpawningAny)
			{
				return;
			}
			List<(GameObject, float)> list = new List<(GameObject, float)>();
			foreach (DawnLibObjectTypeWithRarity item in objectTypesWithRarity)
			{
				if (LethalContent.MapObjects.TryGetValue(item.NamespacedMapObjectKey, out DawnMapObjectInfo value))
				{
					list.Add((value.GetMapObjectPrefab(), item.Rarity));
				}
			}
			if (list.Count <= 0)
			{
				DawnPlugin.Logger.LogWarning((object)("No prefabs found for spawning in game object: " + ((Object)((Component)this).gameObject).name));
				return;
			}
			GameObject val = DawnLibUtilities.ChooseRandomWeightedType(list);
			if ((Object)(object)val == (Object)null)
			{
				DawnPlugin.Logger.LogError((object)("Did you really set something to spawn at a weight of 0? Couldn't find prefab for spawning: " + string.Join(", ", objectTypesWithRarity.Select((DawnLibObjectTypeWithRarity objectType) => objectType.NamespacedMapObjectKey))));
				return;
			}
			RaycastHit val2 = default(RaycastHit);
			if (automaticallyAlignWithTerrain && Physics.Raycast(((Component)this).transform.position + Vector3.up * 2f, Vector3.down, ref val2, 100f, StartOfRound.Instance.collidersAndRoomMaskAndDefault, (QueryTriggerInteraction)1))
			{
				((Component)this).transform.position = ((RaycastHit)(ref val2)).point;
				((Component)this).transform.up = ((RaycastHit)(ref val2)).normal;
			}
			GameObject val3 = Object.Instantiate<GameObject>(val, ((Component)this).transform.position, ((Component)this).transform.rotation, ((Component)this).transform);
			val3.GetComponent<NetworkObject>().Spawn(true);
		}
	}
	[DefaultExecutionOrder(-999)]
	[AddComponentMenu("DawnLib/Audio/Synced Weighted Outcomes")]
	public class WeightedOutcomeScript : NetworkBehaviour
	{
		[Serializable]
		public class Outcome
		{
			[Min(0f)]
			public float weight = 1f;

			[Tooltip("Invoked on all clients when this outcome is selected.")]
			public UnityEvent onSelected = new UnityEvent();

			[Tooltip("Invoked on all clients when this outcome is NOT selected (only if Disable Others is true).")]
			public UnityEvent onNotSelected = new UnityEvent();
		}

		[Header("Outcomes")]
		[SerializeField]
		private Outcome[] _outcomes = Array.Empty<Outcome>();

		[Header("Selection")]
		[Tooltip("Pick between Min and Max outcomes (inclusive).")]
		[SerializeField]
		private int _minSelect = 1;

		[SerializeField]
		private int _maxSelect = 1;

		[Tooltip("If false, an outcome can only be picked once per roll.")]
		[SerializeField]
		private bool _allowDuplicates;

		[Tooltip("If true, disable non-selected targets and invoke onNotSelected for them.")]
		[SerializeField]
		private bool _disableOthers = true;

		[Header("Roll Timing")]
		[Tooltip("If true, server rolls on OnNetworkSpawn().")]
		[SerializeField]
		private bool _rollOnSpawn = true;

		private NetworkList<int> _chosen;

		private void Awake()
		{
			_chosen = new NetworkList<int>();
		}

		public override void OnNetworkSpawn()
		{
			((NetworkBehaviour)this).OnNetworkSpawn();
			_chosen.OnListChanged += delegate
			{
				ApplySelection();
			};
			if (((NetworkBehaviour)this).IsServer && _rollOnSpawn)
			{
				RollServer();
			}
			else
			{
				ApplySelection();
			}
		}

		public override void OnNetworkDespawn()
		{
			if (_chosen != null)
			{
				_chosen.OnListChanged -= delegate
				{
					ApplySelection();
				};
			}
			((NetworkBehaviour)this).OnNetworkDespawn();
		}

		public void Roll()
		{
			if (((NetworkBehaviour)this).IsServer)
			{
				RollServer();
			}
			else
			{
				RequestRollServerRpc();
			}
		}

		[ServerRpc(RequireOwnership = false)]
		private void RequestRollServerRpc()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val = default(ServerRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(2939188308u, val, (RpcDelivery)0);
					((NetworkBehaviour)this).__endSendServerRpc(ref val2, 2939188308u, val, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					RollServer();
				}
			}
		}

		private void RollServer()
		{
			if (_outcomes == null || _outcomes.Length == 0)
			{
				_chosen.Clear();
				return;
			}
			int num = Mathf.Clamp(_minSelect, 0, _outcomes.Length);
			int num2 = Mathf.Clamp(_maxSelect, num, _outcomes.Length);
			int num3 = Random.Range(num, num2 + 1);
			List<int> list = new List<int>(_outcomes.Length);
			for (int i = 0; i < _outcomes.Length; i++)
			{
				if (_outcomes[i].weight > 0f)
				{
					list.Add(i);
				}
			}
			_chosen.Clear();
			if (list.Count == 0 || num3 == 0)
			{
				return;
			}
			for (int j = 0; j < num3; j++)
			{
				int num4 = PickWeightedIndex(list);
				_chosen.Add(num4);
				if (!_allowDuplicates)
				{
					list.Remove(num4);
				}
				if (list.Count == 0)
				{
					break;
				}
			}
			ApplySelection();
		}

		private int PickWeightedIndex(List<int> indices)
		{
			float num = 0f;
			for (int i = 0; i < indices.Count; i++)
			{
				num += _outcomes[indices[i]].weight;
			}
			float num2 = Random.Range(0f, num);
			float num3 = 0f;
			for (int j = 0; j < indices.Count; j++)
			{
				int num4 = indices[j];
				num3 += _outcomes[num4].weight;
				if (num2 <= num3)
				{
					return num4;
				}
			}
			return indices[indices.Count - 1];
		}

		private void ApplySelection()
		{
			if (_outcomes == null)
			{
				return;
			}
			HashSet<int> hashSet = new HashSet<int>();
			for (int i = 0; i < _chosen.Count; i++)
			{
				hashSet.Add(_chosen[i]);
			}
			for (int j = 0; j < _outcomes.Length; j++)
			{
				if (hashSet.Contains(j))
				{
					UnityEvent onSelected = _outcomes[j].onSelected;
					if (onSelected != null)
					{
						onSelected.Invoke();
					}
				}
				else if (_disableOthers)
				{
					UnityEvent onNotSelected = _outcomes[j].onNotSelected;
					if (onNotSelected != null)
					{
						onNotSelected.Invoke();
					}
				}
			}
		}

		protected override void __initializeVariables()
		{
			if (_chosen == null)
			{
				throw new Exception("WeightedOutcomeScript._chosen cannot be null. All NetworkVariableBase instances must be initialized.");
			}
			((NetworkVariableBase)_chosen).Initialize((NetworkBehaviour)(object)this);
			((NetworkBehaviour)this).__nameNetworkVariable((NetworkVariableBase)(object)_chosen, "_chosen");
			base.NetworkVariableFields.Add((NetworkVariableBase)(object)_chosen);
			((NetworkBehaviour)this).__initializeVariables();
		}

		protected override void __initializeRpcs()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			((NetworkBehaviour)this).__registerRpc(2939188308u, new RpcReceiveHandler(__rpc_handler_2939188308), "RequestRollServerRpc");
			((NetworkBehaviour)this).__initializeRpcs();
		}

		private static void __rpc_handler_2939188308(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((WeightedOutcomeScript)(object)target).RequestRollServerRpc();
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		protected internal override string __getTypeName()
		{
			return "WeightedOutcomeScript";
		}
	}
	public static class MoreLayerMasks
	{
		public static int CollidersAndRoomAndDefaultAndInteractableAndRailingAndEnemiesAndTerrainAndHazardAndVehicleMask { get; private set; }

		public static int CollidersAndRoomAndInteractableAndRailingAndEnemiesAndTerrainAndHazardAndVehicleMask { get; private set; }

		public static int RoomAndPlayerAndAndEnemiesAndTerrainAndHazardAndVehicleAndPropsAndDefaultMask { get; private set; }

		public static int CollidersAndRoomAndInteractableAndRailingAndTerrainAndHazardAndVehicleMask { get; private set; }

		public static int CollidersAndRoomAndPlayersAndEnemiesAndTerrainAndVehicleAndDefaultMask { get; private set; }

		public static int CollidersAndRoomAndRailingAndTerrainAndHazardAndVehicleAndDefaultMask { get; private set; }

		public static int CollidersAndRoomAndPlayersAndEnemiesAndTerrainAndVehicleMask { get; private set; }

		public static int CollidersAndRoomAndRailingAndInteractableMask { get; private set; }

		public static int CollidersAndRoomAndPlayersAndInteractableMask { get; private set; }

		public static int PlayersAndInteractableAndEnemiesAndPropsHazardMask { get; private set; }

		public static int CollidersAndRoomMaskAndDefaultAndEnemies { get; private set; }

		public static int PlayersAndEnemiesAndHazardMask { get; private set; }

		public static int DefaultRoomAndNavigationSurfaceMask { get; private set; }

		public static int PlayersAndRagdollMask { get; private set; }

		public static int PropsAndHazardMask { get; private set; }

		public static int TerrainAndFoliageMask { get; private set; }

		public static int PlayersAndEnemiesMask { get; private set; }

		public static int DefaultMask { get; private set; }

		public static int PropsMask { get; private set; }

		public static int HazardMask { get; private set; }

		public static int EnemiesMask { get; private set; }

		public static int InteractableMask { get; private set; }

		public static int RailingMask { get; private set; }

		public static int TerrainMask { get; private set; }

		public static int VehicleMask { get; private set; }

		public static int PlayerMask { get; private set; }

		public static int CollidersMask { get; private set; }

		public static int RoomMask { get; private set; }

		public static int NavigationSurfaceMask { get; private set; }

		public static int FoliageMask { get; private set; }

		public static int PlayerRagdollMask { get; private set; }

		public static void Init()
		{
			DefaultMask = LayerMask.GetMask(new string[1] { "Default" });
			PropsMask = LayerMask.GetMask(new string[1] { "Props" });
			HazardMask = LayerMask.GetMask(new string[1] { "MapHazards" });
			EnemiesMask = LayerMask.GetMask(new string[1] { "Enemies" });
			InteractableMask = LayerMask.GetMask(new string[1] { "InteractableObject" });
			RailingMask = LayerMask.GetMask(new string[1] { "Railing" });
			TerrainMask = LayerMask.GetMask(new string[1] { "Terrain" });
			VehicleMask = LayerMask.GetMask(new string[1] { "Vehicle" });
			PlayerMask = LayerMask.GetMask(new string[1] { "Player" });
			CollidersMask = LayerMask.GetMask(new string[1] { "Colliders" });
			RoomMask = LayerMask.GetMask(new string[1] { "Room" });
			NavigationSurfaceMask = LayerMask.GetMask(new string[1] { "NavigationSurface" });
			FoliageMask = LayerMask.GetMask(new string[1] { "Foliage" });
			PlayerRagdollMask = LayerMask.GetMask(new string[1] { "PlayerRagdoll" });
			PlayersAndRagdollMask = PlayerMask | PlayerRagdollMask;
			PropsAndHazardMask = PropsMask | HazardMask;
			TerrainAndFoliageMask = TerrainMask | FoliageMask;
			PlayersAndEnemiesMask = PlayerMask | EnemiesMask;
			PlayersAndEnemiesAndHazardMask = PlayersAndEnemiesMask | HazardMask;
			DefaultRoomAndNavigationSurfaceMask = DefaultMask | RoomMask | NavigationSurfaceMask;
			CollidersAndRoomMaskAndDefaultAndEnemies = DefaultMask | CollidersMask | RoomMask | EnemiesMask;
			CollidersAndRoomAndRailingAndInteractableMask = CollidersMask | RoomMask | InteractableMask | RailingMask;
			CollidersAndRoomAndPlayersAndInteractableMask = CollidersMask | RoomMask | PlayerMask | InteractableMask;
			PlayersAndInteractableAndEnemiesAndPropsHazardMask = PlayersAndEnemiesAndHazardMask | InteractableMask | PropsMask;
			CollidersAndRoomAndPlayersAndEnemiesAndTerrainAndVehicleMask = CollidersMask | RoomMask | PlayerMask | EnemiesMask | TerrainMask | VehicleMask;
			CollidersAndRoomAndRailingAndTerrainAndHazardAndVehicleAndDefaultMask = CollidersMask | RoomMask | HazardMask | RailingMask | TerrainMask | VehicleMask | DefaultMask;
			CollidersAndRoomAndPlayersAndEnemiesAndTerrainAndVehicleAndDefaultMask = CollidersAndRoomAndPlayersAndEnemiesAndTerrainAndVehicleMask | DefaultMask;
			CollidersAndRoomAndInteractableAndRailingAndTerrainAndHazardAndVehicleMask = CollidersAndRoomAndRailingAndInteractableMask | HazardMask | TerrainMask | VehicleMask;
			CollidersAndRoomAndInteractableAndRailingAndEnemiesAndTerrainAndHazardAndVehicleMask = CollidersAndRoomAndInteractableAndRailingAndTerrainAndHazardAndVehicleMask | EnemiesMask;
			RoomAndPlayerAndAndEnemiesAndTerrainAndHazardAndVehicleAndPropsAndDefaultMask = RoomMask | PlayerMask | EnemiesMask | TerrainMask | HazardMask | VehicleMask | PropsMask | DefaultMask;
			CollidersAndRoomAndDefaultAndInteractableAndRailingAndEnemiesAndTerrainAndHazardAndVehicleMask = CollidersAndRoomAndInteractableAndRailingAndEnemiesAndTerrainAndHazardAndVehicleMask | DefaultMask;
		}
	}
	public abstract class NetworkSingleton<T> : NetworkBehaviour where T : NetworkSingleton<T>
	{
		private static T? _instance;

		public static T? Instance
		{
			get
			{
				_ = (Object)(object)_instance == (Object)null;
				return _instance;
			}
		}

		public override void OnNetworkDespawn()
		{
			((NetworkBehaviour)this).OnNetworkDespawn();
			if ((Object)(object)Instance == (Object)(object)(T)this)
			{
				_instance = null;
			}
		}

		public override void OnNetworkSpawn()
		{
			((NetworkBehaviour)this).OnNetworkSpawn();
			_instance = (T)this;
		}

		protected override void __initializeVariables()
		{
			((NetworkBehaviour)this).__initializeVariables();
		}

		protected override void __initializeRpcs()
		{
			((NetworkBehaviour)this).__initializeRpcs();
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		protected internal override string? __getTypeName()
		{
			return "NetworkSingleton`1";
		}
	}
	public struct GenericPath<T>
	{
		public T Generic;

		public float PathLength;

		public GenericPath(T generic, float pathLength)
		{
			Generic = generic;
			PathLength = pathLength;
		}
	}
	[RequireComponent(typeof(NavMeshAgent))]
	[AddComponentMenu("DawnLib/Smart Agent Navigator")]
	public class SmartAgentNavigator : NetworkBehaviour
	{
		public enum AgentState
		{
			NotSet,
			Inside,
			Outside
		}

		public enum GoToDestinationResult
		{
			Success,
			InProgress,
			Failure
		}

		[CompilerGenerated]
		private sealed class <CheckPathsCoroutine>d__35<T> : IEnumerator<object>, IEnumerator, IDisposable where T : notnull
		{
			private int <>1__state;

			private object <>2__current;

			public SmartAgentNavigator <>4__this;

			public IEnumerable<(T, Vector3)> points;

			public Action<List<GenericPath<T>>> action;

			private List<GenericPath<T>> <TList>5__2;

			private List<T> <pointsTList>5__3;

			private int <listSize>5__4;

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

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

			[DebuggerHidden]
			public <CheckPathsCoroutine>d__35(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<TList>5__2 = null;
				<pointsTList>5__3 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0035: Unknown result type (might be due to invalid IL or missing references)
				//IL_003f: Expected O, but got Unknown
				//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00bd: 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_0150: Expected O, but got Unknown
				//IL_01fa: Unknown result type (might be due to invalid IL or missing references)
				//IL_01ff: Unknown result type (might be due to invalid IL or missing references)
				int num = <>1__state;
				SmartAgentNavigator CS$<>8__locals0 = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
				{
					<>1__state = -1;
					<TList>5__2 = new List<GenericPath<T>>();
					if (CS$<>8__locals0.checkPathsTask == null)
					{
						CS$<>8__locals0.checkPathsTask = new SmartPathTask();
					}
					List<Vector3> list = points.Select(((T, Vector3) x) => x.Item2).ToList();
					<pointsTList>5__3 = points.Select(((T, Vector3) x) => x.Item1).ToList();
					CS$<>8__locals0.checkPathsTask.StartPathTask(CS$<>8__locals0.agent, ((Component)CS$<>8__locals0).transform.position, list, CS$<>8__locals0.GetAllowedPathLinks());
					<listSize>5__4 = list.Count;
					if (<listSize>5__4 == 0)
					{
						action(<TList>5__2);
						CS$<>8__locals0.checkPathsRoutine = null;
						DawnPlugin.Logger.LogError((object)(((Object)((Component)CS$<>8__locals0).gameObject).name + " has no points to check paths for, report this along with what was happening."));
						return false;
					}
					Debuggers.Pathfinding?.Log($"Checking paths for {<listSize>5__4} objects");
					<>2__current = (object)new WaitUntil((Func<bool>)(() => CS$<>8__locals0.checkPathsTask.IsComplete));
					<>1__state = 1;
					return true;
				}
				case 1:
				{
					<>1__state = -1;
					for (int i = 0; i < <listSize>5__4; i++)
					{
						if (!CS$<>8__locals0.checkPathsTask.IsResultReady(i))
						{
							DawnPlugin.Logger.LogError((object)$"Result for task index: {i} on {((Object)((Component)CS$<>8__locals0).gameObject).name} is not ready");
							continue;
						}
						Debuggers.Pathfinding?.Log($"Checking result for task index: {i}, is result ready: {CS$<>8__locals0.checkPathsTask.IsResultReady(i)}, result: {CS$<>8__locals0.checkPathsTask.GetResult(i)}");
						SmartPathDestination? result = CS$<>8__locals0.checkPathsTask.GetResult(i);
						if (result.HasValue)
						{
							SmartPathDestination valueOrDefault = result.GetValueOrDefault();
							<TList>5__2.Add(new GenericPath<T>(<pointsTList>5__3[i], CS$<>8__locals0.checkPathsTask.GetPathLength(i)));
						}
					}
					action(<TList>5__2);
					CS$<>8__locals0.checkPathsRoutine = null;
					return false;
				}
				}
			}

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

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

		[CompilerGenerated]
		private sealed class <ClearProximityNodes>d__52 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public List<Vector3> positionsToSearch;

			public Vector3 positionToTravel;

			public float radius;

			private int <i>5__2;

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

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

			[DebuggerHidden]
			public <ClearProximityNodes>d__52(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_003f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0045: Unknown result type (might be due to invalid IL or missing references)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
				{
					<>1__state = -1;
					int count = positionsToSearch.Count;
					if (count == 0)
					{
						return false;
					}
					<i>5__2 = count - 1;
					break;
				}
				case 1:
					<>1__state = -1;
					<i>5__2--;
					break;
				}
				if (<i>5__2 >= 0)
				{
					if (Vector3.Distance(positionsToSearch[<i>5__2], positionToTravel) <= radius)
					{
						positionsToSearch.RemoveAt(<i>5__2);
					}
					<>2__current = null;
					<>1__state = 1;
					return true;
				}
				return false;
			}

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

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

		[CompilerGenerated]
		private sealed class <GetSetOfAcceptableNodesForRoaming>d__51 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public SmartAgentNavigator <>4__this;

			public float radius;

			private int <listSize>5__2;

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

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

			[DebuggerHidden]
			public <GetSetOfAcceptableNodesForRoaming>d__51(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_002d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0045: Unknown result type (might be due to invalid IL or missing references)
				//IL_0286: Unknown result type (might be due to invalid IL or missing references)
				//IL_0292: Unknown result type (might be due to invalid IL or missing references)
				//IL_026a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0274: Expected O, but got Unknown
				//IL_0375: Unknown result type (might be due to invalid IL or missing references)
				//IL_037a: Unknown result type (might be due to invalid IL or missing references)
				//IL_023a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0247: Unknown result type (might be due to invalid IL or missing references)
				//IL_024d: Unknown result type (might be due to invalid IL or missing references)
				//IL_024e: Unknown result type (might be due to invalid IL or missing references)
				//IL_039f: Unknown result type (might be due to invalid IL or missing references)
				//IL_030d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0317: Expected O, but got Unknown
				int num = <>1__state;
				SmartAgentNavigator CS$<>8__locals0 = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					CS$<>8__locals0._roamingPointsVectorList.Clear();
					if (((Enum)CS$<>8__locals0._allowedLinks).HasFlag((Enum)(object)(SmartPathfindingLinkFlags)8) || ((Enum)CS$<>8__locals0._allowedLinks).HasFlag((Enum)(object)(SmartPathfindingLinkFlags)4))
					{
						if (RoundManager.Instance.insideAINodes != null)
						{
							CS$<>8__locals0._roamingPointsVectorList.AddRange(from x in RoundManager.Instance.insideAINodes
								where (Object)(object)x != (Object)null
								select x.transform.position);
						}
						if (RoundManager.Instance.outsideAINodes != null)
						{
							CS$<>8__locals0._roamingPointsVectorList.AddRange(from x in RoundManager.Instance.outsideAINodes
								where (Object)(object)x != (Object)null
								select x.transform.position);
						}
					}
					else if (CS$<>8__locals0.IsAgentOutside())
					{
						if (RoundManager.Instance.outsideAINodes != null)
						{
							CS$<>8__locals0._roamingPointsVectorList.AddRange(from x in RoundManager.Instance.outsideAINodes
								where (Object)(object)x != (Object)null
								select x.transform.position);
						}
					}
					else if (RoundManager.Instance.insideAINodes != null)
					{
						CS$<>8__locals0._roamingPointsVectorList.AddRange(from x in RoundManager.Instance.insideAINodes
							where (Object)(object)x != (Object)null
							select x.transform.position);
					}
					if (CS$<>8__locals0._roamingPointsVectorList.Count == 0)
					{
						for (int j = 0; j < 20; j++)
						{
							CS$<>8__locals0._roamingPointsVectorList.Add(RoundManager.Instance.GetRandomNavMeshPositionInRadius(((Component)CS$<>8__locals0).transform.position, radius, default(NavMeshHit)));
						}
					}
					if (CS$<>8__locals0.roamingTask == null)
					{
						CS$<>8__locals0.roamingTask = new SmartPathTask();
					}
					CS$<>8__locals0.roamingTask.StartPathTask(CS$<>8__locals0.agent, ((Component)CS$<>8__locals0).transform.position, CS$<>8__locals0._roamingPointsVectorList, CS$<>8__locals0.GetAllowedPathLinks());
					<listSize>5__2 = CS$<>8__locals0._roamingPointsVectorList.Count;
					if (<listSize>5__2 == 0)
					{
						DawnPlugin.Logger.LogError((object)("Roaming points list is empty for " + ((Object)((Component)CS$<>8__locals0).gameObject).name + ", this means that the moon has basically no nodes, and no navmesh around where this entity spawned, no idea how else this could happen, report this with more logs and a detail of what was happening"));
						return false;
					}
					Debuggers.Pathfinding?.Log($"Checking paths for {<listSize>5__2} objects");
					<>2__current = (object)new WaitUntil((Func<bool>)(() => CS$<>8__locals0.roamingTask.IsComplete));
					<>1__state = 1;
					return true;
				case 1:
				{
					<>1__state = -1;
					for (int i = 0; i < <listSize>5__2; i++)
					{
						if (!CS$<>8__locals0.roamingTask.IsResultReady(i))
						{
							DawnPlugin.Logger.LogError((object)$"Roaming task {i} is not ready");
							continue;
						}
						SmartPathDestination? result = CS$<>8__locals0.roamingTask.GetResult(i);
						if (result.HasValue)
						{
							SmartPathDestination valueOrDefault = result.GetValueOrDefault();
							if (!(CS$<>8__locals0.roamingTask.GetPathLength(i) > radius))
							{
								CS$<>8__locals0._positionsToSearch.Add(CS$<>8__locals0._roamingPointsVectorList[i]);
							}
						}
					}
					CS$<>8__locals0._positionsToSearch.Shuffle();
					return false;
				}
				}
			}

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

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

		[CompilerGenerated]
		private sealed class <SearchAlgorithm>d__50 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public SmartAgentNavigator <>4__this;

			public float radius;

			private Vector3 <positionToTravel>5__2;

			private bool <reachedDestination>5__3;

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

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

			[DebuggerHidden]
			public <SearchAlgorithm>d__50(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0041: Unknown result type (might be due to invalid IL or missing references)
				//IL_004b: Expected O, but got Unknown
				//IL_007c: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
				//IL_00da: Unknown result type (might be due to invalid IL or missing references)
				//IL_01c8: Unknown result type (might be due to invalid IL or missing references)
				//IL_01ce: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
				//IL_0122: Unknown result type (might be due to invalid IL or missing references)
				//IL_0174: Unknown result type (might be due to invalid IL or missing references)
				//IL_018a: Unknown result type (might be due to invalid IL or missing references)
				//IL_019b: Unknown result type (might be due to invalid IL or missing references)
				//IL_01a5: Expected O, but got Unknown
				int num = <>1__state;
				SmartAgentNavigator smartAgentNavigator = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForSeconds(Random.Range(0f, 3f));
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					Debuggers.Pathfinding?.Log($"Starting search routine for {((Object)((Component)smartAgentNavigator).gameObject).name} at {((Component)smartAgentNavigator).transform.position} with radius {radius}");
					smartAgentNavigator._positionsToSearch.Clear();
					<>2__current = ((MonoBehaviour)smartAgentNavigator).StartCoroutine(smartAgentNavigator.GetSetOfAcceptableNodesForRoaming(radius));
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					goto IL_00ce;
				case 3:
					<>1__state = -1;
					<reachedDestination>5__3 = false;
					goto IL_01f2;
				case 4:
					{
						<>1__state = -1;
						if (!((Behaviour)smartAgentNavigator.agent).enabled || Vector3.Distance(((Component)smartAgentNavigator).transform.position, <positionToTravel>5__2) <= 3f + smartAgentNavigator.agent.stoppingDistance)
						{
							<reachedDestination>5__3 = true;
						}
						goto IL_01f2;
					}
					IL_00ce:
					<positionToTravel>5__2 = smartAgentNavigator._positionsToSearch.FirstOrDefault();
					if (smartAgentNavigator._positionsToSearch.Count == 0 || <positionToTravel>5__2 == Vector3.zero)
					{
						smartAgentNavigator.StartSearchRoutine(radius);
						return false;
					}
					smartAgentNavigator._positionsToSearch.RemoveAt(0);
					<>2__current = ((MonoBehaviour)smartAgentNavigator).StartCoroutine(smartAgentNavigator.ClearProximityNodes(smartAgentNavigator._positionsToSearch, <positionToTravel>5__2, smartAgentNavigator._nodeRemovalPrecision));
					<>1__state = 3;
					return true;
					IL_01f2:
					if (!<reachedDestination>5__3)
					{
						Debuggers.Pathfinding?.Log($"{((Object)((Component)smartAgentNavigator).gameObject).name} Search: {<positionToTravel>5__2}");
						smartAgentNavigator.GoToDestination(<positionToTravel>5__2);
						<>2__current = (object)new WaitForSeconds(1f);
						<>1__state = 4;
						return true;
					}
					goto IL_00ce;
				}
			}

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

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

		[Header("Events")]
		public UnityEvent<bool> OnUseEntranceTeleport = new UnityEvent<bool>();

		public UnityEvent<bool> OnEnableOrDisableAgent = new UnityEvent<bool>();

		[Header("Extra Settings")]
		[SerializeField]
		public bool CanTryToFlyToDestination = true;

		[HideInInspector]
		public EntranceTeleport? lastUsedEntranceTeleport;

		internal Vector3 pointToGo = Vector3.zero;

		internal Vector3 pointToStart = Vector3.zero;

		private bool cantMove;

		private SmartPathTask? pathingTask;

		private SmartPathTask? checkPathsTask;

		private SmartPathTask? roamingTask;

		private AgentState _agentState;

		[HideInInspector]
		public NavMeshAgent agent;

		[HideInInspector]
		public Coroutine? checkPathsRoutine;

		[Header("Search Algorithm")]
		[SerializeField]
		private float _nodeRemovalPrecision = 5f;

		[SerializeField]
		private SmartPathfindingLinkFlags _allowedLinks = (SmartPathfindingLinkFlags)15;

		private Coroutine? _searchRoutine;

		private readonly List<Vector3> _positionsToSearch = new List<Vector3>();

		private readonly List<Vector3> _roamingPointsVectorList = new List<Vector3>();

		public void Awake()
		{
			agent = ((Component)this).gameObject.GetComponent<NavMeshAgent>();
			SmartPathfinding.RegisterSmartAgent(agent);
		}

		public void Update()
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			if (pointToGo != Vector3.zero && pointToStart != Vector3.zero)
			{
				HandleDisabledAgentPathing();
			}
		}

		public bool IsAgentOutside()
		{
			if (_agentState == AgentState.NotSet)
			{
				DawnPlugin.Logger.LogError((object)(((Object)this).name + " is not initialized yet! Please call `SetAllValues` first."));
				return false;
			}
			return _agentState == AgentState.Outside;
		}

		public void SetAllValues(bool isOutside)
		{
			_agentState = ((!isOutside) ? AgentState.Inside : AgentState.Outside);
		}

		public void DisableMovement(bool disableMovement)
		{
			cantMove = disableMovement;
		}

		private SmartPathfindingLinkFlags GetAllowedPathLinks()
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return _allowedLinks;
		}

		private void UseTeleport(EntranceTeleport teleport)
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			if (teleport.FindExitPoint() && !((Object)(object)teleport.exitScript == (Object)null) && !teleport.exitPointDoesntExist)
			{
				agent.Warp(teleport.exitScript.entrancePoint.position);
				SetSmartAgentOutsideServerRpc(new NetworkBehaviourReference((NetworkBehaviour)(object)teleport));
			}
		}

		public bool DoPathingToDestination(Vector3 destination)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			if (_searchRoutine != null)
			{
				StopSearchRoutine();
			}
			if (cantMove)
			{
				return false;
			}
			if (pointToGo != Vector3.zero && pointToStart != Vector3.zero)
			{
				return false;
			}
			GoToDestinationResult goToDestinationResult = GoToDestination(destination);
			if (goToDestinationResult == GoToDestinationResult.Failure && DetermineIfNeedToDisableAgent(destination))
			{
				return false;
			}
			if (goToDestinationResult != 0)
			{
				return goToDestinationResult == GoToDestinationResult.InProgress;
			}
			return true;
		}

		public bool TryDoPathingToDestination(Vector3 destination, out GoToDestinationResult result)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			result = GoToDestinationResult.InProgress;
			if (_searchRoutine != null)
			{
				StopSearchRoutine();
			}
			if (cantMove)
			{
				return false;
			}
			if (pointToGo != Vector3.zero && pointToStart != Vector3.zero)
			{
				return false;
			}
			result = GoToDestination(destination);
			if (result == GoToDestinationResult.Failure && DetermineIfNeedToDisableAgent(destination))
			{
				return false;
			}
			if (result != 0)
			{
				return result == GoToDestinationResult.InProgress;
			}
			return true;
		}

		private GoToDestinationResult GoToDestination(Vector3 targetPosition)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Expected O, but got Unknown
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			GoToDestinationResult result = GoToDestinationResult.InProgress;
			if (pathingTask == null)
			{
				pathingTask = new SmartPathTask();
				pathingTask.StartPathTask(agent, ((Component)this).transform.position, targetPosition, GetAllowedPathLinks());
			}
			if (!pathingTask.IsResultReady(0))
			{
				return result;
			}
			SmartPathDestination? result2 = pathingTask.GetResult(0);
			if (result2.HasValue)
			{
				SmartPathDestination destination = result2.GetValueOrDefault();
				result = ((!GoToSmartPathDestination(in destination)) ? GoToDestinationResult.Failure : GoToDestinationResult.Success);
			}
			else
			{
				result = GoToDestinationResult.Failure;
			}
			pathingTask.StartPathTask(agent, ((Component)this).transform.position, targetPosition, GetAllowedPathLinks());
			return result;
		}

		public void DisposeOfTasks()
		{
			SmartPathTask? obj = pathingTask;
			if (obj != null)
			{
				obj.Dispose();
			}
			SmartPathTask? obj2 = checkPathsTask;
			if (obj2 != null)
			{
				obj2.Dispose();
			}
			SmartPathTask? obj3 = roamingTask;
			if (obj3 != null)
			{
				obj3.Dispose();
			}
		}

		private bool GoToSmartPathDestination(in SmartPathDestination destination)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Expected I4, but got Unknown
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			SmartDestinationType type = ((SmartPathDestination)(ref destination)).Type;
			switch ((int)type)
			{
			case 0:
				HandleDirectDestination(destination);
				break;
			case 1:
				HandleInternalTeleportDestination(destination);
				break;
			case 2:
				HandleEntranceTeleportDestination(destination);
				break;
			case 3:
				HandleElevatorDestination(destination);
				break;
			default:
				return false;
			}
			return true;
		}

		private void HandleDirectDestination(SmartPathDestination destination)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			agent.SetDestination(((SmartPathDestination)(ref destination)).Position);
		}

		private void HandleInternalTeleportDestination(SmartPathDestination destination)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			agent.SetDestination(((SmartPathDestination)(ref destination)).Position);
			if (!(Vector3.Distance(((Component)this).transform.position, ((SmartPathDestination)(ref destination)).Position) >= 1f + agent.stoppingDistance))
			{
				agent.Warp(((SmartPathDestination)(ref destination)).InternalTeleport.Destination.position);
			}
		}

		private void HandleElevatorDestination(SmartPathDestination destination)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			agent.SetDestination(((SmartPathDestination)(ref destination)).Position);
			if (!(Vector3.Distance(((Component)this).transform.position, ((SmartPathDestination)(ref destination)).Position) >= 1f + agent.stoppingDistance))
			{
				((SmartPathDestination)(ref destination)).ElevatorFloor.CallElevator();
			}
		}

		private void HandleEntranceTeleportDestination(SmartPathDestination destination)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			agent.SetDestination(((SmartPathDestination)(ref destination)).Position);
			if (!(Vector3.Distance(((Component)this).transform.position, ((SmartPathDestination)(ref destination)).Position) >= 1f + agent.stoppingDistance))
			{
				UseTeleport(((SmartPathDestination)(ref destination)).EntranceTeleport);
			}
		}

		public bool CheckPathsOngoing()
		{
			return checkPathsRoutine != null;
		}

		public void CheckPaths<T>(IEnumerable<(T, Vector3)> points, Action<List<GenericPath<T>>> action)
		{
			if (checkPathsRoutine != null)
			{
				((MonoBehaviour)this).StopCoroutine(checkPathsRoutine);
			}
			checkPathsRoutine = ((MonoBehaviour)this).StartCoroutine(CheckPathsCoroutine(points, action));
		}

		[IteratorStateMachine(typeof(<CheckPathsCoroutine>d__35<>))]
		private IEnumerator CheckPathsCoroutine<T>(IEnumerable<(T, Vector3)> points, Action<List<GenericPath<T>>> action)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <CheckPathsCoroutine>d__35<T>(0)
			{
				<>4__this = this,
				points = points,
				action = action
			};
		}

		public void StopAgent()
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			if (((Behaviour)agent).enabled && agent.isOnNavMesh)
			{
				agent.ResetPath();
			}
			agent.velocity = Vector3.zero;
		}

		private void HandleDisabledAgentPathing()
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: 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_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Expected O, but got Unknown
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = pointToGo;
			float num = Vector3.Distance(((Component)this).transform.position, val);
			if (num <= 1f)
			{
				pointToStart = Vector3.zero;
				pointToGo = Vector3.zero;
				OnEnableOrDisableAgent.Invoke(true);
				((Behaviour)agent).enabled = true;
				agent.Warp(val);
				if (pathingTask != null)
				{
					pathingTask.StartPathTask(agent, ((Component)this).transform.position, val, GetAllowedPathLinks());
					return;
				}
				pathingTask = new SmartPathTask();
				pathingTask.StartPathTask(agent, ((Component)this).transform.position, val, GetAllowedPathLinks());
			}
			else
			{
				Vector3 val2 = Vector3.MoveTowards(((Component)this).transform.position, val, Time.deltaTime * 10f);
				((Component)this).transform.SetPositionAndRotation(val2, Quaternion.LookRotation(val - ((Component)this).transform.position));
			}
		}

		private bool DetermineIfNeedToDisableAgent(Vector3 destination)
		{
			//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_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			if (!CanTryToFlyToDestination)
			{
				return false;
			}
			float num = Vector3.Distance(((Component)this).transform.position, destination);
			if (num <= agent.stoppingDistance + 5f)
			{
				return false;
			}
			NavMeshHit val = default(NavMeshHit);
			if (!NavMesh.SamplePosition(destination, ref val, 3f, agent.areaMask))
			{
				return false;
			}
			Vector3 val2 = FindClosestValidPoint();
			agent.SetDestination(val2);
			if (Vector3.Distance(((Component)agent).transform.position, val2) <= agent.stoppingDistance)
			{
				pointToGo = ((NavMeshHit)(ref val)).position;
				pointToStart = ((Component)this).transform.position;
				OnEnableOrDisableAgent.Invoke(false);
				((Behaviour)agent).enabled = false;
				Debuggers.Pathfinding?.Log($"Pathing to initial destination {destination} failed, going to fallback position {((NavMeshHit)(ref val)).position} instead.");
				return true;
			}
			return false;
		}

		public float CanPathToPoint(Vector3 startPos, Vector3 endPos)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Expected O, but got Unknown
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			NavMeshPath val = new NavMeshPath();
			if (!NavMesh.CalculatePath(startPos, endPos, -1, val) || (int)val.status != 0)
			{
				return -1f;
			}
			float num = 0f;
			if (val.corners.Length > 1)
			{
				for (int i = 1; i < val.corners.Length; i++)
				{
					num += Vector3.Distance(val.corners[i - 1], val.corners[i]);
				}
			}
			return num;
		}

		[ServerRpc(RequireOwnership = false)]
		public void SetSmartAgentOutsideServerRpc(NetworkBehaviourReference entranceTeleportReference)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					ServerRpcParams val = default(ServerRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendServerRpc(2318879275u, val, (RpcDelivery)0);
					((FastBufferWriter)(ref val2)).WriteValueSafe<NetworkBehaviourReference>(ref entranceTeleportReference, default(ForNetworkSerializable));
					((NetworkBehaviour)this).__endSendServerRpc(ref val2, 2318879275u, val, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					SetSmartAgentOutsideClientRpc(entranceTeleportReference);
				}
			}
		}

		[ClientRpc]
		public void SetSmartAgentOutsideClientRpc(NetworkBehaviourReference entranceTeleportReference)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Invalid comparison between Unknown and I4
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Invalid comparison between Unknown and I4
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Expected O, but got Unknown
			NetworkManager networkManager = ((NetworkBehaviour)this).NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				if ((int)base.__rpc_exec_stage != 1 && (networkManager.IsServer || networkManager.IsHost))
				{
					ClientRpcParams val = default(ClientRpcParams);
					FastBufferWriter val2 = ((NetworkBehaviour)this).__beginSendClientRpc(271361692u, val, (RpcDelivery)0);
					((FastBufferWriter)(ref val2)).WriteValueSafe<NetworkBehaviourReference>(ref entranceTeleportReference, default(ForNetworkSerializable));
					((NetworkBehaviour)this).__endSendClientRpc(ref val2, 271361692u, val, (RpcDelivery)0);
				}
				if ((int)base.__rpc_exec_stage == 1 && (networkManager.IsClient || networkManager.IsHost))
				{
					base.__rpc_exec_stage = (__RpcExecStage)0;
					lastUsedEntranceTeleport = (EntranceTeleport)NetworkBehaviourReference.op_Implicit(entranceTeleportReference);
					_agentState = (lastUsedEntranceTeleport.isEntranceToBuilding ? AgentState.Inside : AgentState.Outside);
					OnUseEntranceTeleport.Invoke(!lastUsedEntranceTeleport.isEntranceToBuilding);
				}
			}
		}

		private Vector3 FindClosestValidPoint()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			return agent.pathEndPosition;
		}

		public void AdjustSpeedBasedOnDistance(float minDistance, float maxDistance, float minSpeed, float maxSpeed, float multiplierBoost)
		{
			float num = Mathf.Clamp(agent.remainingDistance, minDistance, maxDistance);
			float num2 = (num - minDistance) / (maxDistance - minDistance);
			agent.speed = Mathf.Lerp(minSpeed, maxSpeed, num2) * multiplierBoost;
		}

		public bool CurrentPathIsValid()
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Invalid comparison between Unknown and I4
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Invalid comparison between Unknown and I4
			if ((int)agent.path.status == 1 || (int)agent.path.status == 2)
			{
				return false;
			}
			return true;
		}

		public void StartSearchRoutine(float radius)
		{
			if (((Behaviour)agent).enabled)
			{
				StopSearchRoutine();
				_searchRoutine = ((MonoBehaviour)this).StartCoroutine(SearchAlgorithm(radius));
			}
		}

		public void StopSearchRoutine()
		{
			if (_searchRoutine != null)
			{
				((MonoBehaviour)this).StopCoroutine(_searchRoutine);
			}
			StopAgent();
			_searchRoutine = null;
		}

		[IteratorStateMachine(typeof(<SearchAlgorithm>d__50))]
		private IEnumerator SearchAlgorithm(float radius)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <SearchAlgorithm>d__50(0)
			{
				<>4__this = this,
				radius = radius
			};
		}

		[IteratorStateMachine(typeof(<GetSetOfAcceptableNodesForRoaming>d__51))]
		private IEnumerator GetSetOfAcceptableNodesForRoaming(float radius)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <GetSetOfAcceptableNodesForRoaming>d__51(0)
			{
				<>4__this = this,
				radius = radius
			};
		}

		[IteratorStateMachine(typeof(<ClearProximityNodes>d__52))]
		private IEnumerator ClearProximityNodes(List<Vector3> positionsToSearch, Vector3 positionToTravel, float radius)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <ClearProximityNodes>d__52(0)
			{
				positionsToSearch = positionsToSearch,
				positionToTravel = positionToTravel,
				radius = radius
			};
		}

		protected override void __initializeVariables()
		{
			((NetworkBehaviour)this).__initializeVariables();
		}

		protected override void __initializeRpcs()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Expected O, but got Unknown
			((NetworkBehaviour)this).__registerRpc(2318879275u, new RpcReceiveHandler(__rpc_handler_2318879275), "SetSmartAgentOutsideServerRpc");
			((NetworkBehaviour)this).__registerRpc(271361692u, new RpcReceiveHandler(__rpc_handler_271361692), "SetSmartAgentOutsideClientRpc");
			((NetworkBehaviour)this).__initializeRpcs();
		}

		private static void __rpc_handler_2318879275(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: 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_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				NetworkBehaviourReference smartAgentOutsideServerRpc = default(NetworkBehaviourReference);
				((FastBufferReader)(ref reader)).ReadValueSafe<NetworkBehaviourReference>(ref smartAgentOutsideServerRpc, default(ForNetworkSerializable));
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((SmartAgentNavigator)(object)target).SetSmartAgentOutsideServerRpc(smartAgentOutsideServerRpc);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		private static void __rpc_handler_271361692(NetworkBehaviour target, FastBufferReader reader, __RpcParams rpcParams)
		{
			//IL_002f: 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_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			NetworkManager networkManager = target.NetworkManager;
			if (networkManager != null && networkManager.IsListening)
			{
				NetworkBehaviourReference smartAgentOutsideClientRpc = default(NetworkBehaviourReference);
				((FastBufferReader)(ref reader)).ReadValueSafe<NetworkBehaviourReference>(ref smartAgentOutsideClientRpc, default(ForNetworkSerializable));
				target.__rpc_exec_stage = (__RpcExecStage)1;
				((SmartAgentNavigator)(object)target).SetSmartAgentOutsideClientRpc(smartAgentOutsideClientRpc);
				target.__rpc_exec_stage = (__RpcExecStage)0;
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		protected internal override string __getTypeName()
		{
			return "SmartAgentNavigator";
		}
	}
	public class TMPDropDownFixer : MonoBehaviour
	{
		private float normalizedScrollPosition = 1f;

		private ScrollRect? scrollRect;

		internal void OnOpenDropdown(TMP_Dropdown dropdown)
		{
			scrollRect = dropdown.m_Dropdown.GetComponent<ScrollRect>();
			scrollRect.SetNormalizedPosition(normalizedScrollPosition, 1);
		}

		internal void OnCloseDropdown()
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)scrollRect == (Object)null)
			{
				DawnPlugin.Logger.LogError((object)"Somehow closed dropdown without opening it???");
				return;
			}
			normalizedScrollPosition = scrollRect.normalizedPosition.y;
			scrollRect = null;
		}
	}
	public static class ReflectionUtils
	{
		private static readonly Assembly VanillaAssembly = Assembly.GetAssembly(typeof(PlayerControllerB));

		public static Type GetVanillaType(string fullName)
		{
			return VanillaAssembly.GetType(fullName, throwOnError: true);
		}
	}
	public abstract class Singleton<T> : MonoBehaviour where T : Singleton<T>
	{
		private static T? _instance;

		public static T? Instance
		{
			get
			{
				_ = (Object)(object)_instance == (Object)null;
				return _instance;
			}
		}

		protected virtual void OnDestroy()
		{
			if ((Object)(object)Instance == (Object)(object)(T)this)
			{
				_instance = null;
			}
		}

		public void Awake()
		{
			_instance = (T)this;
		}
	}
	public class ThunderstoreManifest
	{
		public string author_name { get; set; }

		public string name { get; set; }

		public string version_number { get; set; }

		public string description { get; set; }

		public string website_url { get; set; }

		public List<string> dependencies { get; set; }
	}
	[AddComponentMenu("DawnLib/UI/Marquee")]
	public class MarqueeUI : MonoBehaviour
	{
		[CompilerGenerated]
		private sealed class <DoAnimation>d__7 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public MarqueeUI <>4__this;

			private float <t>5__2;

			private Vector3 <step>5__3;

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

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

			[DebuggerHidden]
			public <DoAnimation>d__7(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0038: Unknown result type (might be due to invalid IL or missing references)
				//IL_0042: Expected O, but got Unknown
				//IL_005e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0069: Unknown result type (might be due to invalid IL or missing references)
				//IL_006e: Unknown result type (might be due to invalid IL or missing references)
				//IL_007c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0081: Unknown result type (might be due to invalid IL or missing references)
				//IL_008a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0095: Unknown result type (might be due to invalid IL or missing references)
				//IL_009a: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
				//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
				//IL_0105: Unknown result type (might be due to invalid IL or missing references)
				//IL_010f: Expected O, but got Unknown
				//IL_013a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0140: Unknown result type (might be due to invalid IL or missing references)
				//IL_014a: Unknown result type (might be due to invalid IL or missing references)
				//IL_014f: Unknown result type (might be due to invalid IL or missing references)
				int num = <>1__state;
				MarqueeUI marqueeUI = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForSeconds(marqueeUI._stoppedTime);
					<>1__state = 1;
					return true;
				case 1:
				{
					<>1__state = -1;
					<t>5__2 = 0f;
					Vector3 left = Vector3.left;
					Rect rect = marqueeUI._transform.rect;
					float width = ((Rect)(ref rect)).width;
					rect = marqueeUI._parent.rect;
					<step>5__3 = left * (width - ((Rect)(ref rect)).width) / marqueeUI._movingTime;
					goto IL_00f0;
				}
				case 2:
					<>1__state = -1;
					goto IL_00f0;
				case 3:
					<>1__state = -1;
					break;
				case 4:
					{
						<>1__state = -1;
						break;
					}
					IL_00f0:
					if (<t>5__2 < marqueeUI._movingTime)
					{
						<t>5__2 += Time.deltaTime;
						RectTransform transform = marqueeUI._transform;
						((Transform)transform).localPosition = ((Transform)transform).localPosition + <step>5__3 * Time.deltaTime;
						<>2__current = null;
						<>1__state = 2;
						return true;
					}
					<>2__current = (object)new WaitForSeconds(marqueeUI._stoppedTime);
					<>1__state = 3;
					return true;
				}
				if (<t>5__2 > 0f)
				{
					<t>5__2 -= Time.deltaTime;
					RectTransform transform2 = marqueeUI._transform;
					((Transform)transform2).localPosition = ((Transform)transform2).localPosition - <step>5__3 * Time.deltaTime;
					<>2__current = null;
					<>1__state = 4;
					return true;
				}
				marqueeUI._currentAnim = null;
				return false;
			}

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

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

		private RectTransform _transform;

		private RectTransform _parent;

		[SerializeField]
		private float _stoppedTime = 1f;

		[SerializeField]
		private float _movingTime = 2f;

		private Coroutine? _currentAnim;

		private void Awake()
		{
			_transform = ((Component)this).GetComponent<RectTransform>();
			_parent = ((Component)((Component)this).transform.parent).GetComponent<RectTransform>();
		}

		private void Update()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			Rect rect = _parent.rect;
			float width = ((Rect)(ref rect)).width;
			rect = _transform.rect;
			if (width < ((Rect)(ref rect)).width)
			{
				if (_currentAnim == null)
				{
					_currentAnim = ((MonoBehaviour)this).StartCoroutine(DoAnimation());
				}
			}
			else if (_currentAnim != null)
			{
				((MonoBehaviour)this).StopCoroutine(_currentAnim);
				_currentAnim = null;
				((Transform)_transform).localPosition = Vector3.zero;
			}
		}

		[IteratorStateMachine(typeof(<DoAnimation>d__7))]
		private IEnumerator DoAnimation()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <DoAnimation>d__7(0)
			{
				<>4__this = this
			};
		}
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	internal sealed class IgnoresAccessChecksToAttribute : Attribute
	{
		public IgnoresAccessChecksToAttribute(string assemblyName)
		{
		}
	}
}
namespace __GEN
{
	internal class NetworkVariableSerializationHelper
	{
		[RuntimeInitializeOnLoadMethod]
		internal static void InitializeSerialization()
		{
			NetworkVariableSerializationTypes.InitializeSerializer_UnmanagedINetworkSerializable<NetworkTransformState>();
			NetworkVariableSerializationTypes.InitializeEqualityChecker_UnmanagedValueEquals<NetworkTransformState>();
		}
	}
}
namespace com.github.teamxiaolan.dawnlib.NetcodePatcher
{
	[AttributeUsage(AttributeTargets.Module)]
	internal class NetcodePatchedAssemblyAttribute : Attribute
	{
	}
}