using System;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.IO.Compression;
using System.Linq;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.Serialization;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using Data;
using ExpandWorldData;
using ExpandWorldData.Dungeon;
using HarmonyLib;
using JetBrains.Annotations;
using Microsoft.CodeAnalysis;
using ServerSync;
using Service;
using SoftReferenceableAssets;
using TMPro;
using UnityEngine;
using YamlDotNet.Serialization;
using YamlDotNet.Serialization.NamingConventions;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: AssemblyCompany("ExpandWorldData")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+a31d4055e77a751901d5913340852395ad62079f")]
[assembly: AssemblyProduct("ExpandWorldData")]
[assembly: AssemblyTitle("ExpandWorldData")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
[CompilerGenerated]
internal delegate TResult <>f__AnonymousDelegate0<T1, T2, T3, T4, T5, TResult>(T1 arg1, T2 arg2, T3 arg3, out T4 arg4, T5 arg5 = false);
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[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]
	[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]
	[Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace Data
{
	public class Calculator
	{
		public static Vector3 EvaluateVector3(string expression)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			Vector3 zero = Vector3.zero;
			string[] array = Parse.Split(expression);
			zero.x = EvaluateFloat(array[0]).GetValueOrDefault();
			if (array.Length > 1)
			{
				zero.z = EvaluateFloat(array[1]).GetValueOrDefault();
			}
			if (array.Length > 2)
			{
				zero.y = EvaluateFloat(array[2]).GetValueOrDefault();
			}
			return zero;
		}

		public static Vector3 EvaluateVector3(string[] s, int index)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			Vector3 zero = Vector3.zero;
			if (s.Length > index)
			{
				zero.x = EvaluateFloat(s[index]).GetValueOrDefault();
			}
			if (s.Length > index + 1)
			{
				zero.z = EvaluateFloat(s[index + 1]).GetValueOrDefault();
			}
			if (s.Length > index + 2)
			{
				zero.y = EvaluateFloat(s[index + 2]).GetValueOrDefault();
			}
			return zero;
		}

		public static Quaternion EvaluateQuaternion(string expression)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: 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)
			Vector3 zero = Vector3.zero;
			string[] array = Parse.Split(expression);
			zero.y = EvaluateFloat(array[0]).GetValueOrDefault();
			if (array.Length > 1)
			{
				zero.x = EvaluateFloat(array[1]).GetValueOrDefault();
			}
			if (array.Length > 2)
			{
				zero.z = EvaluateFloat(array[2]).GetValueOrDefault();
			}
			return Quaternion.Euler(zero);
		}

		public static Quaternion EvaluateQuaternion(string[] s, int index)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: 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)
			Vector3 zero = Vector3.zero;
			if (s.Length > index)
			{
				zero.y = EvaluateFloat(s[index]).GetValueOrDefault();
			}
			if (s.Length > index + 1)
			{
				zero.x = EvaluateFloat(s[index + 1]).GetValueOrDefault();
			}
			if (s.Length > index + 2)
			{
				zero.z = EvaluateFloat(s[index + 2]).GetValueOrDefault();
			}
			return Quaternion.Euler(zero);
		}

		public static int? EvaluateInt(string expression)
		{
			try
			{
				return (int?)EvaluateLong(expression);
			}
			catch
			{
				return null;
			}
		}

		public static float? EvaluateFloat(string expression)
		{
			try
			{
				return (float)EvaluateDouble(expression);
			}
			catch
			{
				return null;
			}
		}

		private static double EvaluateDouble(string expression)
		{
			string[] array = expression.Split(new char[1] { '+' });
			if (array.Length > 1)
			{
				double num = 0.0;
				string[] array2 = array;
				foreach (string expression2 in array2)
				{
					num += EvaluateDouble(expression2);
				}
				return num;
			}
			string[] array3 = expression.Split(new char[1] { '-' });
			if (array3.Where((string s) => s != "").Count() > 1)
			{
				double? num2 = null;
				for (int num3 = 0; num3 < array3.Length; num3++)
				{
					if (!(array3[num3] == "") || num3 + 1 >= array3.Length)
					{
						num2 = (num2.HasValue ? (num2 - EvaluateDouble(array3[num3])) : new double?(EvaluateDouble(array3[num3])));
					}
					else
					{
						array3[num3 + 1] = "-" + array3[num3 + 1];
					}
				}
				return num2.GetValueOrDefault();
			}
			string[] array4 = expression.Split(new char[1] { '*' });
			if (array4.Length > 1)
			{
				double num4 = 1.0;
				string[] array2 = array4;
				foreach (string expression3 in array2)
				{
					num4 *= EvaluateDouble(expression3);
				}
				return num4;
			}
			string[] array5 = expression.Split(new char[1] { '/' });
			if (array5.Length > 1)
			{
				double num5 = EvaluateDouble(array5[0]);
				for (int num6 = 1; num6 < array5.Length; num6++)
				{
					num5 /= EvaluateDouble(array5[num6]);
				}
				return num5;
			}
			try
			{
				return double.Parse(expression.Trim(), NumberFormatInfo.InvariantInfo);
			}
			catch
			{
				throw new InvalidOperationException("Failed to parse expression: " + expression);
			}
		}

		public static long? EvaluateLong(string expression)
		{
			try
			{
				return EvalLong(expression);
			}
			catch
			{
				return null;
			}
		}

		private static long EvalLong(string expression)
		{
			string[] array = expression.Split(new char[1] { '+' });
			if (array.Length > 1)
			{
				long num = 0L;
				string[] array2 = array;
				foreach (string expression2 in array2)
				{
					num += EvalLong(expression2);
				}
				return num;
			}
			string[] array3 = expression.Split(new char[1] { '-' });
			if (array3.Where((string s) => s != "").Count() > 1)
			{
				long? num2 = null;
				for (int num3 = 0; num3 < array3.Length; num3++)
				{
					if (!(array3[num3] == "") || num3 + 1 >= array3.Length)
					{
						num2 = (num2.HasValue ? (num2 - EvalLong(array3[num3])) : new long?(EvalLong(array3[num3])));
					}
					else
					{
						array3[num3 + 1] = "-" + array3[num3 + 1];
					}
				}
				return num2.GetValueOrDefault();
			}
			string[] array4 = expression.Split(new char[1] { '*' });
			if (array4.Length > 1)
			{
				long num4 = 1L;
				string[] array2 = array4;
				foreach (string expression3 in array2)
				{
					num4 *= EvalLong(expression3);
				}
				return num4;
			}
			string[] array5 = expression.Split(new char[1] { '/' });
			if (array5.Length > 1)
			{
				long num5 = EvalLong(array5[0]);
				for (int num6 = 1; num6 < array5.Length; num6++)
				{
					num5 /= EvalLong(array5[num6]);
				}
				return num5;
			}
			try
			{
				return long.Parse(expression.Trim());
			}
			catch
			{
				throw new InvalidOperationException("Failed to parse expression: " + expression);
			}
		}
	}
	public class DataData
	{
		[DefaultValue(null)]
		public string? name;

		[DefaultValue(null)]
		public string? position;

		[DefaultValue(null)]
		public string? rotation;

		[DefaultValue(null)]
		public string? connection;

		[DefaultValue(null)]
		public string[]? bools;

		[DefaultValue(null)]
		public string[]? ints;

		[DefaultValue(null)]
		public string[]? hashes;

		[DefaultValue(null)]
		public string[]? floats;

		[DefaultValue(null)]
		public string[]? strings;

		[DefaultValue(null)]
		public string[]? longs;

		[DefaultValue(null)]
		public string[]? vecs;

		[DefaultValue(null)]
		public string[]? quats;

		[DefaultValue(null)]
		public string[]? bytes;

		[DefaultValue(null)]
		public ItemData[]? items;

		[DefaultValue(null)]
		public string? containerSize;

		[DefaultValue(null)]
		public string? itemAmount;

		[DefaultValue(null)]
		public string? valueGroup;

		[DefaultValue(null)]
		public string? value;

		[DefaultValue(null)]
		public string[]? values;

		[DefaultValue(null)]
		public string? persistent;

		[DefaultValue(null)]
		public string? distant;

		[DefaultValue(null)]
		public string? priority;
	}
	public class ItemData
	{
		public string pos = "";

		[DefaultValue(1f)]
		public float chance = 1f;

		[DefaultValue("")]
		public string prefab = "";

		public string? stack;

		public string? quality;

		public string? variant;

		public string? durability;

		public string? crafterID;

		public string? crafterName;

		public string? worldLevel;

		public string? equipped;

		public string? pickedUp;

		public Dictionary<string, string>? customData;
	}
	public class DataEntry
	{
		public Dictionary<int, IStringValue>? Strings;

		public Dictionary<int, IFloatValue>? Floats;

		public Dictionary<int, IIntValue>? Ints;

		public Dictionary<int, IBoolValue>? Bools;

		public Dictionary<int, IHashValue>? Hashes;

		public Dictionary<int, ILongValue>? Longs;

		public Dictionary<int, IVector3Value>? Vecs;

		public Dictionary<int, IQuaternionValue>? Quats;

		public Dictionary<int, byte[]>? ByteArrays;

		public List<ItemValue>? Items;

		public Vector2i? ContainerSize;

		public IIntValue? ItemAmount;

		public ConnectionType? ConnectionType;

		public int ConnectionHash;

		public IZdoIdValue? OriginalId;

		public IZdoIdValue? TargetConnectionId;

		public IBoolValue? Persistent;

		public IBoolValue? Distant;

		public ObjectType? Priority;

		public IVector3Value? Position;

		public IQuaternionValue? Rotation;

		public DataEntry()
		{
		}

		public DataEntry(string base64)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Expected O, but got Unknown
			Load(new ZPackage(base64));
		}

		public DataEntry(DataData data)
		{
			Load(data);
		}

		private Vector2i GetContainerSize()
		{
			//IL_001a: 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)
			return (Vector2i)(((??)ContainerSize) ?? new Vector2i(4, 2));
		}

		public void Load(DataEntry data)
		{
			if (data.Floats != null)
			{
				if (Floats == null)
				{
					Floats = new Dictionary<int, IFloatValue>();
				}
				foreach (KeyValuePair<int, IFloatValue> @float in data.Floats)
				{
					Floats[@float.Key] = @float.Value;
				}
			}
			if (data.Vecs != null)
			{
				if (Vecs == null)
				{
					Vecs = new Dictionary<int, IVector3Value>();
				}
				foreach (KeyValuePair<int, IVector3Value> vec in data.Vecs)
				{
					Vecs[vec.Key] = vec.Value;
				}
			}
			if (data.Quats != null)
			{
				if (Quats == null)
				{
					Quats = new Dictionary<int, IQuaternionValue>();
				}
				foreach (KeyValuePair<int, IQuaternionValue> quat in data.Quats)
				{
					Quats[quat.Key] = quat.Value;
				}
			}
			if (data.Ints != null)
			{
				if (Ints == null)
				{
					Ints = new Dictionary<int, IIntValue>();
				}
				foreach (KeyValuePair<int, IIntValue> @int in data.Ints)
				{
					Ints[@int.Key] = @int.Value;
				}
			}
			if (data.Strings != null)
			{
				if (Strings == null)
				{
					Strings = new Dictionary<int, IStringValue>();
				}
				foreach (KeyValuePair<int, IStringValue> @string in data.Strings)
				{
					Strings[@string.Key] = @string.Value;
				}
			}
			if (data.ByteArrays != null)
			{
				if (ByteArrays == null)
				{
					ByteArrays = new Dictionary<int, byte[]>();
				}
				foreach (KeyValuePair<int, byte[]> byteArray in data.ByteArrays)
				{
					ByteArrays[byteArray.Key] = byteArray.Value;
				}
			}
			if (data.Longs != null)
			{
				if (Longs == null)
				{
					Longs = new Dictionary<int, ILongValue>();
				}
				foreach (KeyValuePair<int, ILongValue> @long in data.Longs)
				{
					Longs[@long.Key] = @long.Value;
				}
			}
			if (data.Bools != null)
			{
				if (Bools == null)
				{
					Bools = new Dictionary<int, IBoolValue>();
				}
				foreach (KeyValuePair<int, IBoolValue> @bool in data.Bools)
				{
					Bools[@bool.Key] = @bool.Value;
				}
			}
			if (data.Hashes != null)
			{
				if (Hashes == null)
				{
					Hashes = new Dictionary<int, IHashValue>();
				}
				foreach (KeyValuePair<int, IHashValue> hash in data.Hashes)
				{
					Hashes[hash.Key] = hash.Value;
				}
			}
			if (data.Items != null)
			{
				if (Items == null)
				{
					Items = new List<ItemValue>();
				}
				foreach (ItemValue item in data.Items)
				{
					Items.Add(item);
				}
			}
			if (data.ContainerSize.HasValue)
			{
				ContainerSize = data.ContainerSize;
			}
			if (data.ItemAmount != null)
			{
				ItemAmount = data.ItemAmount;
			}
			ConnectionType = data.ConnectionType;
			ConnectionHash = data.ConnectionHash;
			OriginalId = data.OriginalId;
			TargetConnectionId = data.TargetConnectionId;
			if (data.Persistent != null)
			{
				Persistent = data.Persistent;
			}
			if (data.Distant != null)
			{
				Distant = data.Distant;
			}
			if (data.Priority.HasValue)
			{
				Priority = data.Priority;
			}
			if (data.Position != null)
			{
				Position = data.Position;
			}
			if (data.Rotation != null)
			{
				Rotation = data.Rotation;
			}
		}

		public DataEntry Reset(DataData data)
		{
			Floats = null;
			Vecs = null;
			Quats = null;
			Ints = null;
			Strings = null;
			ByteArrays = null;
			Longs = null;
			Bools = null;
			Hashes = null;
			Items = null;
			ContainerSize = null;
			ItemAmount = null;
			ConnectionType = null;
			ConnectionHash = 0;
			OriginalId = null;
			TargetConnectionId = null;
			Position = null;
			Rotation = null;
			Distant = null;
			Persistent = null;
			Priority = null;
			Load(data);
			return this;
		}

		public void Load(DataData data)
		{
			//IL_0a29: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b6e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0be5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0bb3: Unknown result type (might be due to invalid IL or missing references)
			HashSet<string> hashSet = new HashSet<string>();
			if (data.floats != null)
			{
				if (Floats == null)
				{
					Floats = new Dictionary<int, IFloatValue>();
				}
				string[] floats = data.floats;
				foreach (string text in floats)
				{
					KeyValuePair<string, string> keyValuePair = Parse.Kvp(text);
					if (keyValuePair.Key == "")
					{
						throw new InvalidOperationException("Failed to parse float " + text + ".");
					}
					if (keyValuePair.Key.Contains("."))
					{
						hashSet.Add(keyValuePair.Key.Split(new char[1] { '.' })[0]);
					}
					int key = Hash(keyValuePair.Key);
					if (Floats.ContainsKey(key))
					{
						Log.Warning("Data " + data.name + ": Duplicate float key " + keyValuePair.Key + ".");
					}
					Floats[key] = DataValue.Float(keyValuePair.Value);
				}
			}
			if (data.ints != null)
			{
				if (Ints == null)
				{
					Ints = new Dictionary<int, IIntValue>();
				}
				string[] floats = data.ints;
				foreach (string text2 in floats)
				{
					KeyValuePair<string, string> keyValuePair2 = Parse.Kvp(text2);
					if (keyValuePair2.Key == "")
					{
						throw new InvalidOperationException("Failed to parse int " + text2 + ".");
					}
					if (keyValuePair2.Key.Contains("."))
					{
						hashSet.Add(keyValuePair2.Key.Split(new char[1] { '.' })[0]);
					}
					int key2 = Hash(keyValuePair2.Key);
					if (Ints.ContainsKey(key2))
					{
						Log.Warning("Data " + data.name + ": Duplicate int key " + keyValuePair2.Key + ".");
					}
					Ints[key2] = DataValue.Int(keyValuePair2.Value);
				}
			}
			if (data.bools != null)
			{
				if (Bools == null)
				{
					Bools = new Dictionary<int, IBoolValue>();
				}
				string[] floats = data.bools;
				foreach (string text3 in floats)
				{
					KeyValuePair<string, string> keyValuePair3 = Parse.Kvp(text3);
					if (keyValuePair3.Key == "")
					{
						throw new InvalidOperationException("Failed to parse bool " + text3 + ".");
					}
					if (keyValuePair3.Key.Contains("."))
					{
						hashSet.Add(keyValuePair3.Key.Split(new char[1] { '.' })[0]);
					}
					int key3 = Hash(keyValuePair3.Key);
					if (Bools.ContainsKey(key3))
					{
						Log.Warning("Data " + data.name + ": Duplicate bool key " + keyValuePair3.Key + ".");
					}
					Bools[key3] = DataValue.Bool(keyValuePair3.Value);
				}
			}
			if (data.hashes != null)
			{
				if (Hashes == null)
				{
					Hashes = new Dictionary<int, IHashValue>();
				}
				string[] floats = data.hashes;
				foreach (string text4 in floats)
				{
					KeyValuePair<string, string> keyValuePair4 = Parse.Kvp(text4);
					if (keyValuePair4.Key == "")
					{
						throw new InvalidOperationException("Failed to parse hash " + text4 + ".");
					}
					if (keyValuePair4.Key.Contains("."))
					{
						hashSet.Add(keyValuePair4.Key.Split(new char[1] { '.' })[0]);
					}
					int key4 = Hash(keyValuePair4.Key);
					if (Hashes.ContainsKey(key4))
					{
						Log.Warning("Data " + data.name + ": Duplicate hash key " + keyValuePair4.Key + ".");
					}
					Hashes[key4] = DataValue.Hash(keyValuePair4.Value);
				}
			}
			if (data.longs != null)
			{
				if (Longs == null)
				{
					Longs = new Dictionary<int, ILongValue>();
				}
				string[] floats = data.longs;
				foreach (string text5 in floats)
				{
					KeyValuePair<string, string> keyValuePair5 = Parse.Kvp(text5);
					if (keyValuePair5.Key == "")
					{
						throw new InvalidOperationException("Failed to parse long " + text5 + ".");
					}
					if (keyValuePair5.Key.Contains("."))
					{
						hashSet.Add(keyValuePair5.Key.Split(new char[1] { '.' })[0]);
					}
					int key5 = Hash(keyValuePair5.Key);
					if (Longs.ContainsKey(key5))
					{
						Log.Warning("Data " + data.name + ": Duplicate long key " + keyValuePair5.Key + ".");
					}
					Longs[key5] = DataValue.Long(keyValuePair5.Value);
				}
			}
			if (data.strings != null)
			{
				if (Strings == null)
				{
					Strings = new Dictionary<int, IStringValue>();
				}
				string[] floats = data.strings;
				foreach (string text6 in floats)
				{
					KeyValuePair<string, string> keyValuePair6 = Parse.Kvp(text6);
					if (keyValuePair6.Key == "")
					{
						throw new InvalidOperationException("Failed to parse string " + text6 + ".");
					}
					if (keyValuePair6.Key.Contains("."))
					{
						hashSet.Add(keyValuePair6.Key.Split(new char[1] { '.' })[0]);
					}
					int key6 = Hash(keyValuePair6.Key);
					if (Strings.ContainsKey(key6))
					{
						Log.Warning("Data " + data.name + ": Duplicate string key " + keyValuePair6.Key + ".");
					}
					Strings[key6] = DataValue.String(keyValuePair6.Value);
				}
			}
			if (data.vecs != null)
			{
				if (Vecs == null)
				{
					Vecs = new Dictionary<int, IVector3Value>();
				}
				string[] floats = data.vecs;
				foreach (string text7 in floats)
				{
					KeyValuePair<string, string> keyValuePair7 = Parse.Kvp(text7);
					if (keyValuePair7.Key == "")
					{
						throw new InvalidOperationException("Failed to parse vector " + text7 + ".");
					}
					if (keyValuePair7.Key.Contains("."))
					{
						hashSet.Add(keyValuePair7.Key.Split(new char[1] { '.' })[0]);
					}
					int key7 = Hash(keyValuePair7.Key);
					if (Vecs.ContainsKey(key7))
					{
						Log.Warning("Data " + data.name + ": Duplicate vector key " + keyValuePair7.Key + ".");
					}
					Vecs[key7] = DataValue.Vector3(keyValuePair7.Value);
				}
			}
			if (data.quats != null)
			{
				if (Quats == null)
				{
					Quats = new Dictionary<int, IQuaternionValue>();
				}
				string[] floats = data.quats;
				foreach (string text8 in floats)
				{
					KeyValuePair<string, string> keyValuePair8 = Parse.Kvp(text8);
					if (keyValuePair8.Key == "")
					{
						throw new InvalidOperationException("Failed to parse quaternion " + text8 + ".");
					}
					if (keyValuePair8.Key.Contains("."))
					{
						hashSet.Add(keyValuePair8.Key.Split(new char[1] { '.' })[0]);
					}
					int key8 = Hash(keyValuePair8.Key);
					if (Quats.ContainsKey(key8))
					{
						Log.Warning("Data " + data.name + ": Duplicate quaternion key " + keyValuePair8.Key + ".");
					}
					Quats[key8] = DataValue.Quaternion(keyValuePair8.Value);
				}
			}
			if (data.bytes != null)
			{
				if (ByteArrays == null)
				{
					ByteArrays = new Dictionary<int, byte[]>();
				}
				string[] floats = data.bytes;
				foreach (string text9 in floats)
				{
					KeyValuePair<string, string> keyValuePair9 = Parse.Kvp(text9);
					if (keyValuePair9.Key == "")
					{
						throw new InvalidOperationException("Failed to parse byte array " + text9 + ".");
					}
					if (keyValuePair9.Key.Contains("."))
					{
						hashSet.Add(keyValuePair9.Key.Split(new char[1] { '.' })[0]);
					}
					int key9 = Hash(keyValuePair9.Key);
					if (ByteArrays.ContainsKey(key9))
					{
						Log.Warning("Data " + data.name + ": Duplicate byte array key " + keyValuePair9.Key + ".");
					}
					ByteArrays[key9] = Convert.FromBase64String(keyValuePair9.Value);
				}
			}
			if (data.items != null)
			{
				List<ItemValue> list = new List<ItemValue>();
				list.AddRange(data.items.Select((ItemData item) => new ItemValue(item)));
				Items = list;
			}
			if (!string.IsNullOrWhiteSpace(data.containerSize))
			{
				ContainerSize = Parse.Vector2Int(data.containerSize);
			}
			if (!string.IsNullOrWhiteSpace(data.itemAmount))
			{
				ItemAmount = DataValue.Int(data.itemAmount);
			}
			if (hashSet.Count > 0)
			{
				if (Ints == null)
				{
					Ints = new Dictionary<int, IIntValue>();
				}
				Ints[StringExtensionMethods.GetStableHashCode("HasFields")] = DataValue.Simple(1);
				foreach (string item in hashSet)
				{
					Ints[StringExtensionMethods.GetStableHashCode("HasFields" + item)] = DataValue.Simple(1);
				}
			}
			if (!string.IsNullOrWhiteSpace(data.position))
			{
				Position = DataValue.Vector3(data.position);
			}
			if (!string.IsNullOrWhiteSpace(data.rotation))
			{
				Rotation = DataValue.Quaternion(data.rotation);
			}
			if (data.persistent != null)
			{
				Persistent = DataValue.Bool(data.persistent);
			}
			if (data.distant != null)
			{
				Distant = DataValue.Bool(data.distant);
			}
			if (data.priority != null)
			{
				Priority = (Enum.TryParse<ObjectType>(data.priority, ignoreCase: true, out ObjectType result) ? new ObjectType?(result) : ((ObjectType?)null));
			}
			if (string.IsNullOrWhiteSpace(data.connection))
			{
				return;
			}
			string[] array = Parse.SplitWithEmpty(data.connection);
			if (array.Length == 1)
			{
				string[] floats = array;
				List<string> list2 = new List<string>(floats.Length);
				list2.AddRange(floats);
				ConnectionType = ToByteEnum<ConnectionType>(list2);
				return;
			}
			List<string> list3 = array.Take(array.Length - 1).ToList();
			string text10 = array[^1];
			ConnectionType = ToByteEnum<ConnectionType>(list3);
			if (text10.Contains(":") || text10.Contains("<"))
			{
				TargetConnectionId = DataValue.ZdoId(text10);
				OriginalId = TargetConnectionId;
				return;
			}
			ConnectionHash = Parse.Int(text10);
			if (ConnectionHash == 0)
			{
				ConnectionHash = StringExtensionMethods.GetStableHashCode(text10);
			}
		}

		public void Load(ZPackage pkg)
		{
			//IL_0086: 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)
			pkg.SetPos(0);
			int num = pkg.ReadInt();
			if ((num & 1) != 0)
			{
				if (Floats == null)
				{
					Floats = new Dictionary<int, IFloatValue>();
				}
				byte b = pkg.ReadByte();
				for (int i = 0; i < b; i++)
				{
					Floats[pkg.ReadInt()] = new SimpleFloatValue(pkg.ReadSingle());
				}
			}
			if ((num & 2) != 0)
			{
				if (Vecs == null)
				{
					Vecs = new Dictionary<int, IVector3Value>();
				}
				byte b2 = pkg.ReadByte();
				for (int j = 0; j < b2; j++)
				{
					Vecs[pkg.ReadInt()] = new SimpleVector3Value(pkg.ReadVector3());
				}
			}
			if ((num & 4) != 0)
			{
				if (Quats == null)
				{
					Quats = new Dictionary<int, IQuaternionValue>();
				}
				byte b3 = pkg.ReadByte();
				for (int k = 0; k < b3; k++)
				{
					Quats[pkg.ReadInt()] = new SimpleQuaternionValue(pkg.ReadQuaternion());
				}
			}
			if ((num & 8) != 0)
			{
				if (Ints == null)
				{
					Ints = new Dictionary<int, IIntValue>();
				}
				byte b4 = pkg.ReadByte();
				for (int l = 0; l < b4; l++)
				{
					Ints[pkg.ReadInt()] = new SimpleIntValue(pkg.ReadInt());
				}
			}
			if ((num & 0x40) != 0)
			{
				if (Longs == null)
				{
					Longs = new Dictionary<int, ILongValue>();
				}
				byte b5 = pkg.ReadByte();
				for (int m = 0; m < b5; m++)
				{
					Longs[pkg.ReadInt()] = new SimpleLongValue(pkg.ReadLong());
				}
			}
			if ((num & 0x10) != 0)
			{
				if (Strings == null)
				{
					Strings = new Dictionary<int, IStringValue>();
				}
				byte b6 = pkg.ReadByte();
				for (int n = 0; n < b6; n++)
				{
					Strings[pkg.ReadInt()] = new SimpleStringValue(pkg.ReadString());
				}
			}
			if ((num & 0x80) != 0)
			{
				if (ByteArrays == null)
				{
					ByteArrays = new Dictionary<int, byte[]>();
				}
				byte b7 = pkg.ReadByte();
				for (int num2 = 0; num2 < b7; num2++)
				{
					ByteArrays[pkg.ReadInt()] = pkg.ReadByteArray();
				}
			}
			if ((num & 0x100) != 0)
			{
				ConnectionType = (ConnectionType)pkg.ReadByte();
				ConnectionHash = pkg.ReadInt();
			}
			if ((num & 0x200) != 0)
			{
				Persistent = new SimpleBoolValue(pkg.ReadBool());
			}
			if ((num & 0x400) != 0)
			{
				Distant = new SimpleBoolValue(pkg.ReadBool());
			}
			if ((num & 0x800) != 0)
			{
				Priority = (ObjectType)pkg.ReadByte();
			}
		}

		public bool Match(Parameters pars, ZDO zdo)
		{
			//IL_01dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_024c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0285: Unknown result type (might be due to invalid IL or missing references)
			//IL_028a: Unknown result type (might be due to invalid IL or missing references)
			//IL_028f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0299: Unknown result type (might be due to invalid IL or missing references)
			//IL_029b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0266: 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_02c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d9: 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)
			if (Strings != null && Strings.Any<KeyValuePair<int, IStringValue>>((KeyValuePair<int, IStringValue> pair) => pair.Value.Match(pars, zdo.GetString(pair.Key, "")) == false))
			{
				return false;
			}
			if (Floats != null && Floats.Any<KeyValuePair<int, IFloatValue>>((KeyValuePair<int, IFloatValue> pair) => pair.Value.Match(pars, zdo.GetFloat(pair.Key, 0f)) == false))
			{
				return false;
			}
			if (Ints != null && Ints.Any<KeyValuePair<int, IIntValue>>((KeyValuePair<int, IIntValue> pair) => pair.Value.Match(pars, zdo.GetInt(pair.Key, 0)) == false))
			{
				return false;
			}
			if (Longs != null && Longs.Any<KeyValuePair<int, ILongValue>>((KeyValuePair<int, ILongValue> pair) => pair.Value.Match(pars, zdo.GetLong(pair.Key, 0L)) == false))
			{
				return false;
			}
			if (Bools != null && Bools.Any<KeyValuePair<int, IBoolValue>>((KeyValuePair<int, IBoolValue> pair) => pair.Value.Match(pars, zdo.GetBool(pair.Key, false)) == false))
			{
				return false;
			}
			if (Hashes != null && Hashes.Any<KeyValuePair<int, IHashValue>>((KeyValuePair<int, IHashValue> pair) => pair.Value.Match(pars, zdo.GetInt(pair.Key, 0)) == false))
			{
				return false;
			}
			if (Vecs != null && Vecs.Any<KeyValuePair<int, IVector3Value>>((KeyValuePair<int, IVector3Value> pair) => pair.Value.Match(pars, zdo.GetVec3(pair.Key, Vector3.zero)) == false))
			{
				return false;
			}
			if (Quats != null && Quats.Any<KeyValuePair<int, IQuaternionValue>>((KeyValuePair<int, IQuaternionValue> pair) => pair.Value.Match(pars, zdo.GetQuaternion(pair.Key, Quaternion.identity)) == false))
			{
				return false;
			}
			if (ByteArrays != null && ByteArrays.Any<KeyValuePair<int, byte[]>>((KeyValuePair<int, byte[]> pair) => !pair.Value.SequenceEqual(zdo.GetByteArray(pair.Key, (byte[])null))))
			{
				return false;
			}
			if (Persistent != null && Persistent.Match(pars, zdo.Persistent) == false)
			{
				return false;
			}
			if (Distant != null && Distant.Match(pars, zdo.Distant) == false)
			{
				return false;
			}
			if (Priority.HasValue && Priority.Value != zdo.Type)
			{
				return false;
			}
			if (Items != null)
			{
				return ItemValue.Match(pars, Items, zdo, ItemAmount);
			}
			if (ItemAmount != null)
			{
				return ItemValue.Match(pars, zdo, ItemAmount);
			}
			if (ConnectionType.HasValue)
			{
				if ((int)ConnectionType.Value == 0)
				{
					ZDOConnection connection = zdo.GetConnection();
					if (connection != null && connection.m_target != ZDOID.None)
					{
						return false;
					}
				}
				else
				{
					ZDOID connectionZDOID = zdo.GetConnectionZDOID(ConnectionType.Value);
					if (TargetConnectionId == null)
					{
						if (connectionZDOID == ZDOID.None)
						{
							return false;
						}
					}
					else
					{
						ZDOID? val = TargetConnectionId.Get(pars);
						if (val.HasValue)
						{
							ZDOID val2 = connectionZDOID;
							ZDOID? val3 = val;
							if (!val3.HasValue || val2 != val3.GetValueOrDefault())
							{
								return false;
							}
						}
					}
				}
			}
			return true;
		}

		public bool Unmatch(Parameters pars, ZDO zdo)
		{
			//IL_01c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cd: 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_026e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0273: Unknown result type (might be due to invalid IL or missing references)
			//IL_0278: Unknown result type (might be due to invalid IL or missing references)
			//IL_0281: Unknown result type (might be due to invalid IL or missing references)
			//IL_0282: 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_0254: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c3: Unknown result type (might be due to invalid IL or missing references)
			if (Strings != null && Strings.Any<KeyValuePair<int, IStringValue>>((KeyValuePair<int, IStringValue> pair) => pair.Value.Match(pars, zdo.GetString(pair.Key, "")) == true))
			{
				return false;
			}
			if (Floats != null && Floats.Any<KeyValuePair<int, IFloatValue>>((KeyValuePair<int, IFloatValue> pair) => pair.Value.Match(pars, zdo.GetFloat(pair.Key, 0f)) == true))
			{
				return false;
			}
			if (Ints != null && Ints.Any<KeyValuePair<int, IIntValue>>((KeyValuePair<int, IIntValue> pair) => pair.Value.Match(pars, zdo.GetInt(pair.Key, 0)) == true))
			{
				return false;
			}
			if (Longs != null && Longs.Any<KeyValuePair<int, ILongValue>>((KeyValuePair<int, ILongValue> pair) => pair.Value.Match(pars, zdo.GetLong(pair.Key, 0L)) == true))
			{
				return false;
			}
			if (Bools != null && Bools.Any<KeyValuePair<int, IBoolValue>>((KeyValuePair<int, IBoolValue> pair) => pair.Value.Match(pars, zdo.GetBool(pair.Key, false)) == true))
			{
				return false;
			}
			if (Hashes != null && Hashes.Any<KeyValuePair<int, IHashValue>>((KeyValuePair<int, IHashValue> pair) => pair.Value.Match(pars, zdo.GetInt(pair.Key, 0)) == true))
			{
				return false;
			}
			if (Vecs != null && Vecs.Any<KeyValuePair<int, IVector3Value>>((KeyValuePair<int, IVector3Value> pair) => pair.Value.Match(pars, zdo.GetVec3(pair.Key, Vector3.zero)) == true))
			{
				return false;
			}
			if (Quats != null && Quats.Any<KeyValuePair<int, IQuaternionValue>>((KeyValuePair<int, IQuaternionValue> pair) => pair.Value.Match(pars, zdo.GetQuaternion(pair.Key, Quaternion.identity)) == true))
			{
				return false;
			}
			if (ByteArrays != null && ByteArrays.Any<KeyValuePair<int, byte[]>>((KeyValuePair<int, byte[]> pair) => pair.Value.SequenceEqual(zdo.GetByteArray(pair.Key, (byte[])null))))
			{
				return false;
			}
			if (Persistent != null && Persistent.Match(pars, zdo.Persistent) == true)
			{
				return false;
			}
			if (Distant != null && Distant.Match(pars, zdo.Distant) == true)
			{
				return false;
			}
			if (Priority.HasValue && Priority.Value == zdo.Type)
			{
				return false;
			}
			if (Items != null)
			{
				return !ItemValue.Match(pars, Items, zdo, ItemAmount);
			}
			if (ItemAmount != null)
			{
				return !ItemValue.Match(pars, zdo, ItemAmount);
			}
			if (ConnectionType.HasValue)
			{
				if ((int)ConnectionType.Value == 0)
				{
					ZDOConnection connection = zdo.GetConnection();
					if (connection == null || connection.m_target == ZDOID.None)
					{
						return false;
					}
				}
				else
				{
					ZDOID connectionZDOID = zdo.GetConnectionZDOID(ConnectionType.Value);
					if (TargetConnectionId == null)
					{
						if (connectionZDOID != ZDOID.None)
						{
							return false;
						}
					}
					else
					{
						ZDOID? val = TargetConnectionId.Get(pars);
						if (val.HasValue)
						{
							ZDOID val2 = connectionZDOID;
							ZDOID? val3 = val;
							if (val3.HasValue && val2 == val3.GetValueOrDefault())
							{
								return false;
							}
						}
					}
				}
			}
			return true;
		}

		public static string PrintVectorXZY(Vector3 vector)
		{
			return vector.x.ToString("0.##", CultureInfo.InvariantCulture) + " " + vector.z.ToString("0.##", CultureInfo.InvariantCulture) + " " + vector.y.ToString("0.##", CultureInfo.InvariantCulture);
		}

		public static string PrintAngleYXZ(Quaternion quaternion)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			return PrintVectorYXZ(((Quaternion)(ref quaternion)).eulerAngles);
		}

		private static string PrintVectorYXZ(Vector3 vector)
		{
			return vector.y.ToString("0.##", CultureInfo.InvariantCulture) + " " + vector.x.ToString("0.##", CultureInfo.InvariantCulture) + " " + vector.z.ToString("0.##", CultureInfo.InvariantCulture);
		}

		private static T ToByteEnum<T>(List<string> list) where T : struct, Enum
		{
			byte b = 0;
			foreach (string item in list)
			{
				string text = item.Trim();
				if (Enum.TryParse<T>(text, ignoreCase: true, out var result))
				{
					b += (byte)(object)result;
				}
				else
				{
					Log.Warning("Failed to parse value " + text + " as T.");
				}
			}
			return (T)(object)b;
		}

		public void RollItems(Parameters pars)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			List<ItemValue>? items = Items;
			if (items != null && items.Count > 0)
			{
				string value = ItemValue.LoadItems(pars, Items, GetContainerSize(), (ItemAmount?.Get(pars)).GetValueOrDefault());
				if (Strings == null)
				{
					Strings = new Dictionary<int, IStringValue>();
				}
				Strings[ZDOVars.s_items] = DataValue.Simple(value);
			}
		}

		public void AddItems(Parameters parameters, ZDO zdo)
		{
			//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_001e: 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_0032: 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: Expected O, but got Unknown
			if (Items == null || Items.Count == 0)
			{
				return;
			}
			Vector2i containerSize = GetContainerSize();
			Inventory val = ItemValue.CreateInventory(zdo, containerSize.x, containerSize.y);
			foreach (ItemValue item in GenerateItems(parameters, containerSize))
			{
				item.AddTo(parameters, val);
			}
			ZPackage val2 = new ZPackage();
			val.Save(val2);
			zdo.Set(ZDOVars.s_items, val2.GetBase64());
		}

		public void RemoveItems(Parameters parameters, ZDO zdo)
		{
			//IL_0041: 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_0080: Expected O, but got Unknown
			if (Items == null || Items.Count == 0)
			{
				return;
			}
			Inventory val = ItemValue.CreateInventory(zdo);
			if (val.m_inventory.Count == 0)
			{
				return;
			}
			foreach (ItemValue item in GenerateItems(parameters, new Vector2i(10000, 10000)))
			{
				item.RemoveFrom(parameters, val);
			}
			ZPackage val2 = new ZPackage();
			val.Save(val2);
			zdo.Set(ZDOVars.s_items, val2.GetBase64());
		}

		public List<ItemValue> GenerateItems(Parameters pars, Vector2i size)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			if (Items == null)
			{
				throw new ArgumentNullException("Items");
			}
			return ItemValue.Generate(pars, Items, size, (ItemAmount?.Get(pars)).GetValueOrDefault());
		}

		public static int Hash(string key)
		{
			if (Parse.TryInt(key, out var result))
			{
				return result;
			}
			if (key.StartsWith("$", StringComparison.InvariantCultureIgnoreCase))
			{
				int hash = ZSyncAnimation.GetHash(key.Substring(1));
				if (key == "$anim_speed")
				{
					return hash;
				}
				return 438569 + hash;
			}
			return StringExtensionMethods.GetStableHashCode(key);
		}

		public void Write(Parameters pars, ZDO zdo)
		{
			//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_002a: 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_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: 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_0176: Unknown result type (might be due to invalid IL or missing references)
			//IL_0185: 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_0200: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_028a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0363: Unknown result type (might be due to invalid IL or missing references)
			//IL_0314: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_039e: Unknown result type (might be due to invalid IL or missing references)
			//IL_046d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0423: Unknown result type (might be due to invalid IL or missing references)
			//IL_053f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0490: Unknown result type (might be due to invalid IL or missing references)
			//IL_057a: Unknown result type (might be due to invalid IL or missing references)
			//IL_057f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0587: Unknown result type (might be due to invalid IL or missing references)
			//IL_058c: Unknown result type (might be due to invalid IL or missing references)
			//IL_05b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_05bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_05c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_05c6: Unknown result type (might be due to invalid IL or missing references)
			ZDOID uid = zdo.m_uid;
			RollItems(pars);
			Dictionary<int, IFloatValue>? floats = Floats;
			if (floats != null && floats.Count > 0)
			{
				ZDOHelper.Init<float>(ZDOExtraData.s_floats, uid);
				foreach (KeyValuePair<int, IFloatValue> @float in Floats)
				{
					float? num = @float.Value.Get(pars);
					if (num.HasValue)
					{
						ZDOExtraData.s_floats[uid].SetValue(@float.Key, num.Value);
					}
				}
			}
			Dictionary<int, IVector3Value>? vecs = Vecs;
			if (vecs != null && vecs.Count > 0)
			{
				ZDOHelper.Init<Vector3>(ZDOExtraData.s_vec3, uid);
				foreach (KeyValuePair<int, IVector3Value> vec in Vecs)
				{
					Vector3? val = vec.Value.Get(pars);
					if (val.HasValue)
					{
						ZDOExtraData.s_vec3[uid].SetValue(vec.Key, val.Value);
					}
				}
			}
			Dictionary<int, IQuaternionValue>? quats = Quats;
			if (quats != null && quats.Count > 0)
			{
				ZDOHelper.Init<Quaternion>(ZDOExtraData.s_quats, uid);
				foreach (KeyValuePair<int, IQuaternionValue> quat in Quats)
				{
					Quaternion? val2 = quat.Value.Get(pars);
					if (val2.HasValue)
					{
						ZDOExtraData.s_quats[uid].SetValue(quat.Key, val2.Value);
					}
				}
			}
			Dictionary<int, IIntValue>? ints = Ints;
			if (ints != null && ints.Count > 0)
			{
				ZDOHelper.Init<int>(ZDOExtraData.s_ints, uid);
				foreach (KeyValuePair<int, IIntValue> @int in Ints)
				{
					int? num2 = @int.Value.Get(pars);
					if (num2.HasValue)
					{
						ZDOExtraData.s_ints[uid].SetValue(@int.Key, num2.Value);
					}
				}
			}
			Dictionary<int, IHashValue>? hashes = Hashes;
			if (hashes != null && hashes.Count > 0)
			{
				ZDOHelper.Init<int>(ZDOExtraData.s_ints, uid);
				foreach (KeyValuePair<int, IHashValue> hash in Hashes)
				{
					int? num3 = hash.Value.Get(pars);
					if (num3.HasValue)
					{
						ZDOExtraData.s_ints[uid].SetValue(hash.Key, num3.Value);
					}
				}
			}
			Dictionary<int, IBoolValue>? bools = Bools;
			if (bools != null && bools.Count > 0)
			{
				ZDOHelper.Init<int>(ZDOExtraData.s_ints, uid);
				foreach (KeyValuePair<int, IBoolValue> @bool in Bools)
				{
					int? num4 = @bool.Value.GetInt(pars);
					if (num4.HasValue)
					{
						ZDOExtraData.s_ints[uid].SetValue(@bool.Key, num4.Value);
					}
				}
			}
			Dictionary<int, ILongValue>? longs = Longs;
			if (longs != null && longs.Count > 0)
			{
				ZDOHelper.Init<long>(ZDOExtraData.s_longs, uid);
				foreach (KeyValuePair<int, ILongValue> @long in Longs)
				{
					long? num5 = @long.Value.Get(pars);
					if (num5.HasValue)
					{
						ZDOExtraData.s_longs[uid].SetValue(@long.Key, num5.Value);
					}
				}
			}
			Dictionary<int, IStringValue>? strings = Strings;
			if (strings != null && strings.Count > 0)
			{
				ZDOHelper.Init<string>(ZDOExtraData.s_strings, uid);
				foreach (KeyValuePair<int, IStringValue> @string in Strings)
				{
					string text = @string.Value.Get(pars);
					if (text != null)
					{
						ZDOExtraData.s_strings[uid].SetValue(@string.Key, text);
					}
				}
			}
			Dictionary<int, byte[]>? byteArrays = ByteArrays;
			if (byteArrays != null && byteArrays.Count > 0)
			{
				ZDOHelper.Init<byte[]>(ZDOExtraData.s_byteArrays, uid);
				foreach (KeyValuePair<int, byte[]> byteArray in ByteArrays)
				{
					ZDOExtraData.s_byteArrays[uid].SetValue(byteArray.Key, byteArray.Value);
				}
			}
			if (Persistent != null)
			{
				zdo.Persistent = Persistent.GetBool(pars) ?? zdo.Persistent;
			}
			if (Distant != null)
			{
				zdo.Distant = Distant.GetBool(pars) ?? zdo.Distant;
			}
			if (Priority.HasValue)
			{
				zdo.Type = Priority.Value;
			}
			HandleConnection(zdo, pars);
			HandleHashConnection(zdo);
			if (Position != null)
			{
				Vector3? val3 = Position.Get(pars);
				if (val3.HasValue)
				{
					zdo.m_position = val3.Value;
					zdo.SetSector(ZoneSystem.GetZone(val3.Value));
				}
			}
			if (Rotation != null)
			{
				Quaternion? val4 = Rotation.Get(pars);
				if (val4.HasValue)
				{
					Quaternion value = val4.Value;
					zdo.m_rotation = ((Quaternion)(ref value)).eulerAngles;
				}
			}
		}

		private void HandleConnection(ZDO ownZdo, Parameters pars)
		{
			//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_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: 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_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: 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_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: 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_008f: Unknown result type (might be due to invalid IL or missing references)
			if (OriginalId == null || !ConnectionType.HasValue)
			{
				return;
			}
			ZDOID uid = ownZdo.m_uid;
			if (TargetConnectionId != null)
			{
				ZDOID? val = TargetConnectionId.Get(pars);
				if (!val.HasValue)
				{
					return;
				}
				ZDO zDO = ZDOMan.instance.GetZDO(val.Value);
				if (zDO != null)
				{
					ownZdo.SetConnection(ConnectionType.Value, val.Value);
					if (ConnectionType == (ConnectionType?)1)
					{
						zDO.SetConnection((ConnectionType)1, uid);
					}
				}
				return;
			}
			ZDOID? originalId = OriginalId.Get(pars);
			if (!originalId.HasValue)
			{
				return;
			}
			KeyValuePair<ZDOID, ZDOConnection> keyValuePair = ZDOExtraData.s_connections.FirstOrDefault((KeyValuePair<ZDOID, ZDOConnection> kvp) => kvp.Value.m_target == originalId.Value);
			if (keyValuePair.Value != null)
			{
				ZDO zDO2 = ZDOMan.instance.GetZDO(keyValuePair.Key);
				if (zDO2 != null)
				{
					zDO2.SetConnection(keyValuePair.Value.m_type, uid);
				}
			}
		}

		private void HandleHashConnection(ZDO ownZdo)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: 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_003d: 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_0045: 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_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: 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_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//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_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: 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_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0133: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			//IL_013c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0186: Unknown result type (might be due to invalid IL or missing references)
			//IL_018c: 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_0199: Unknown result type (might be due to invalid IL or missing references)
			//IL_019e: Unknown result type (might be due to invalid IL or missing references)
			//IL_015a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0157: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ee: 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_0160: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f7: 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_0200: Unknown result type (might be due to invalid IL or missing references)
			//IL_0211: Unknown result type (might be due to invalid IL or missing references)
			//IL_0219: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c2: Unknown result type (might be due to invalid IL or missing references)
			if (ConnectionHash == 0 || !ConnectionType.HasValue || ConnectionType == (ConnectionType?)0)
			{
				return;
			}
			ZDOID uid = ownZdo.m_uid;
			ZDOExtraData.SetConnectionData(uid, ConnectionType.Value, ConnectionHash);
			ConnectionType? val = (ConnectionType?)((??)ConnectionType ^ 0x10);
			bool flag = (??)((??)ConnectionType & 0x10) == (??)0;
			ZDOID val2 = ((IEnumerable<ZDOID>)ZDOExtraData.GetAllConnectionZDOIDs(val.Value)).FirstOrDefault((Func<ZDOID, bool>)((ZDOID z) => ZDOExtraData.GetConnectionHashData(z, ConnectionType.Value)?.m_hash == ConnectionHash));
			if (val2 == ZDOID.None)
			{
				return;
			}
			ZDO zDO = ZDOMan.instance.GetZDO(val2);
			if (zDO != null)
			{
				if (((??)ConnectionType & 3) > 0)
				{
					ZDO val3 = (ZDO)(flag ? ((object)ownZdo) : ((object)zDO));
					ZDOID val4 = (flag ? val2 : uid);
					val3.SetConnection((ConnectionType)3, val4);
				}
				if (((??)ConnectionType & 2) > 0)
				{
					ZDO val5 = (ZDO)(flag ? ((object)ownZdo) : ((object)zDO));
					ZDOID val6 = (flag ? val2 : uid);
					val5.SetConnection((ConnectionType)2, val6);
				}
				if (((??)ConnectionType & 1) > 0)
				{
					zDO.SetConnection((ConnectionType)1, uid);
					ownZdo.SetConnection((ConnectionType)1, val2);
				}
			}
		}
	}
	public class DataHelper
	{
		public static ZDO? Init(GameObject obj, Vector3 pos, Quaternion rot, Vector3? scale, DataEntry? data)
		{
			//IL_002d: 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_0066: 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_0092: 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)
			if (data == null && !scale.HasValue)
			{
				return null;
			}
			ZNetView val = default(ZNetView);
			if (!obj.TryGetComponent<ZNetView>(ref val))
			{
				return null;
			}
			string prefabName = Utils.GetPrefabName(obj);
			int stableHashCode = StringExtensionMethods.GetStableHashCode(prefabName);
			ZNetView.m_initZDO = ZDOMan.instance.CreateNewZDO(pos, stableHashCode);
			ObjectParameters pars = new ObjectParameters(prefabName, "", ZNetView.m_initZDO);
			data?.Write(pars, ZNetView.m_initZDO);
			ZNetView.m_initZDO.m_rotation = ((Quaternion)(ref rot)).eulerAngles;
			ZNetView.m_initZDO.Type = (ObjectType)(((??)data?.Priority) ?? val.m_type);
			ZNetView.m_initZDO.Distant = data?.Distant?.GetBool(pars) ?? val.m_distant;
			ZNetView.m_initZDO.Persistent = data?.Persistent?.GetBool(pars) ?? val.m_persistent;
			ZNetView.m_initZDO.m_prefab = stableHashCode;
			if (val.m_syncInitialScale && scale.HasValue)
			{
				ZNetView.m_initZDO.Set(ZDOVars.s_scaleHash, scale.Value);
			}
			ZNetView.m_initZDO.DataRevision = 0u;
			ZNetView.m_initZDO.IncreaseDataRevision();
			return ZNetView.m_initZDO;
		}

		public static void CleanUp()
		{
			ZNetView.m_initZDO = null;
		}

		public static DataEntry? Merge(DataEntry? first, DataEntry? second)
		{
			if (first == null)
			{
				return second;
			}
			if (second == null)
			{
				return first;
			}
			DataEntry dataEntry = new DataEntry();
			dataEntry.Load(first);
			dataEntry.Load(second);
			return dataEntry;
		}

		public static DataEntry? Merge(params DataEntry?[] datas)
		{
			DataEntry[] array = datas.Where((DataEntry d) => d != null).ToArray();
			if (array.Length == 0)
			{
				return null;
			}
			if (array.Length == 1)
			{
				return array[0];
			}
			DataEntry dataEntry = new DataEntry();
			DataEntry[] array2 = array;
			foreach (DataEntry data in array2)
			{
				dataEntry.Load(data);
			}
			return dataEntry;
		}

		public static bool Exists(int hash)
		{
			return DataLoading.Data.ContainsKey(hash);
		}

		public static bool Match(int hash, ZDO zdo, Parameters pars)
		{
			if (DataLoading.Data.TryGetValue(hash, out DataEntry value))
			{
				return value.Match(pars, zdo);
			}
			return false;
		}

		public static DataEntry? Get(string name, string fileName)
		{
			if (!(name == ""))
			{
				return DataLoading.Get(name, fileName);
			}
			return null;
		}

		public static List<string>? GetValuesFromGroup(string group)
		{
			int stableHashCode = StringExtensionMethods.GetStableHashCode(group.ToLowerInvariant());
			if (DataLoading.ValueGroups.TryGetValue(stableHashCode, out List<string> value))
			{
				return value;
			}
			return null;
		}

		public static List<string> ResolvePrefabs(string values)
		{
			HashSet<string> hashSet = new HashSet<string>();
			ResolvePrefabsSub(hashSet, values);
			HashSet<string> hashSet2 = hashSet;
			List<string> list = new List<string>(hashSet2.Count);
			list.AddRange(hashSet2);
			return list;
		}

		private static void ResolvePrefabsSub(HashSet<string> prefabs, string value)
		{
			if (value == "all" || DataLoading.IsComponentGroup(value))
			{
				prefabs.Add(value.ToLowerInvariant());
				return;
			}
			if (ZNetScene.instance.m_namedPrefabs.ContainsKey(StringExtensionMethods.GetStableHashCode(value)))
			{
				prefabs.Add(value);
				return;
			}
			List<string> valuesFromGroup = GetValuesFromGroup(value);
			if (valuesFromGroup != null)
			{
				foreach (string item in valuesFromGroup)
				{
					ResolvePrefabsSub(prefabs, item);
				}
				return;
			}
			Log.Warning("Failed to resolve prefab: " + value);
		}

		public static string GetGlobalKey(string key)
		{
			string lower = key.ToLowerInvariant();
			return ZoneSystem.instance.m_globalKeysValues.FirstOrDefault((KeyValuePair<string, string> kvp) => kvp.Key.ToLowerInvariant() == lower).Value ?? "0";
		}
	}
	public class DataLoading
	{
		private static readonly string GamePath = Path.GetFullPath(Path.Combine("BepInEx", "config", "data"));

		private static readonly string ProfilePath = Path.GetFullPath(Path.Combine(Paths.ConfigPath, "data"));

		public static Dictionary<int, DataEntry> Data = new Dictionary<int, DataEntry>();

		public static readonly Dictionary<int, List<string>> ValueGroups = new Dictionary<int, List<string>>();

		private static readonly Dictionary<int, List<string>> DefaultValueGroups = new Dictionary<int, List<string>>();

		private static readonly Dictionary<string, List<string>> DefaultPrefabComponents = new Dictionary<string, List<string>>();

		private static readonly int WearNTearHash = StringExtensionMethods.GetStableHashCode("wearntear");

		private static readonly int HumanoidHash = StringExtensionMethods.GetStableHashCode("humanoid");

		private static readonly int CreatureHash = StringExtensionMethods.GetStableHashCode("creature");

		private static readonly int StructureHash = StringExtensionMethods.GetStableHashCode("structure");

		public static string Pattern = "expand_data*.yaml";

		public static DataEntry? Get(string name, string fileName)
		{
			int stableHashCode = StringExtensionMethods.GetStableHashCode(name);
			if (!Data.ContainsKey(stableHashCode))
			{
				try
				{
					Data[stableHashCode] = new DataEntry(name);
				}
				catch
				{
					if (name.Contains("=") || name.Length > 32)
					{
						Log.Warning(fileName + ": Can't load data value: " + name);
					}
					else
					{
						Log.Warning(fileName + ": Can't find data entry: " + name);
					}
					return null;
				}
			}
			return Data[stableHashCode];
		}

		public static DataEntry? Get(int hash)
		{
			if (!Data.ContainsKey(hash))
			{
				return null;
			}
			return Data[hash];
		}

		public static void LoadEntries()
		{
			Dictionary<int, DataEntry> data = Data;
			Data = new Dictionary<int, DataEntry>();
			ValueGroups.Clear();
			List<DataData> list = Yaml.Read<DataData>(Directory.GetFiles(GamePath, "*.yaml", SearchOption.AllDirectories).Concat(Directory.GetFiles(ProfilePath, "*.yaml", SearchOption.AllDirectories)).Concat(Directory.GetFiles(Yaml.BaseDirectory, Pattern, SearchOption.AllDirectories))
				.Select(Path.GetFullPath)
				.Distinct()
				.ToList());
			foreach (DataData item in list)
			{
				LoadValues(item);
			}
			if (ValueGroups.Count > 0)
			{
				Log.Info($"Loaded {ValueGroups.Count} value groups.");
			}
			LoadDefaultValueGroups();
			foreach (KeyValuePair<int, List<string>> valueGroup in ValueGroups)
			{
				ResolveValues(valueGroup.Value);
			}
			foreach (KeyValuePair<int, List<string>> defaultValueGroup in DefaultValueGroups)
			{
				if (!ValueGroups.ContainsKey(defaultValueGroup.Key))
				{
					ValueGroups[defaultValueGroup.Key] = defaultValueGroup.Value;
				}
			}
			foreach (DataData item2 in list)
			{
				LoadEntry(item2, data);
			}
			PrefabHelper.ClearCache();
			Log.Info($"Loaded {Data.Count} data entries.");
		}

		private static void LoadValues(DataData data)
		{
			if (data.value != null)
			{
				KeyValuePair<string, string> keyValuePair = Parse.Kvp(data.value);
				int stableHashCode = StringExtensionMethods.GetStableHashCode(keyValuePair.Key.ToLowerInvariant());
				if (ValueGroups.ContainsKey(stableHashCode))
				{
					Log.Warning("Duplicate value group entry: " + keyValuePair.Key);
				}
				if (!ValueGroups.ContainsKey(stableHashCode))
				{
					ValueGroups[stableHashCode] = new List<string>();
				}
				ValueGroups[stableHashCode].Add(keyValuePair.Value);
			}
			if (data.valueGroup != null && data.values != null)
			{
				int stableHashCode2 = StringExtensionMethods.GetStableHashCode(data.valueGroup.ToLowerInvariant());
				if (ValueGroups.ContainsKey(stableHashCode2))
				{
					Log.Warning("Duplicate value group entry: " + data.valueGroup);
				}
				if (!ValueGroups.ContainsKey(stableHashCode2))
				{
					ValueGroups[stableHashCode2] = new List<string>();
				}
				string[] values = data.values;
				foreach (string item in values)
				{
					ValueGroups[stableHashCode2].Add(item);
				}
			}
		}

		private static void LoadEntry(DataData data, Dictionary<int, DataEntry> oldData)
		{
			if (data.name != null)
			{
				int stableHashCode = StringExtensionMethods.GetStableHashCode(data.name);
				if (Data.ContainsKey(stableHashCode))
				{
					Log.Warning("Duplicate data entry: " + data.name);
				}
				Data[stableHashCode] = (oldData.TryGetValue(stableHashCode, out DataEntry value) ? value.Reset(data) : new DataEntry(data));
			}
		}

		public static bool IsComponentGroup(string group)
		{
			return DefaultValueGroups.ContainsKey(StringExtensionMethods.GetStableHashCode(group.ToLowerInvariant()));
		}

		public static List<string> GetDefaultComponents(string prefabName)
		{
			if (DefaultPrefabComponents.TryGetValue(prefabName, out List<string> value))
			{
				return value;
			}
			return new List<string>();
		}

		private static void LoadDefaultValueGroups()
		{
			if (DefaultValueGroups.Count != 0)
			{
				return;
			}
			foreach (GameObject value in ZNetScene.instance.m_namedPrefabs.Values)
			{
				if (!Object.op_Implicit((Object)(object)value))
				{
					continue;
				}
				string name = ((Object)value).name;
				if (!DefaultPrefabComponents.ContainsKey(name))
				{
					DefaultPrefabComponents[name] = new List<string>();
				}
				value.GetComponentsInChildren<MonoBehaviour>(ZNetView.m_tempComponents);
				foreach (MonoBehaviour tempComponent in ZNetView.m_tempComponents)
				{
					string text = ((object)tempComponent).GetType().Name.ToLowerInvariant();
					int stableHashCode = StringExtensionMethods.GetStableHashCode(text);
					if (!DefaultValueGroups.ContainsKey(stableHashCode))
					{
						DefaultValueGroups[stableHashCode] = new List<string>();
					}
					DefaultValueGroups[stableHashCode].Add(((Object)value).name);
					DefaultPrefabComponents[name].Add(text);
					if (text == "humanoid")
					{
						DefaultPrefabComponents[name].Add("character");
					}
					if (text == "wearntear")
					{
						DefaultPrefabComponents[name].Add("structure");
					}
				}
			}
			DefaultValueGroups[CreatureHash] = DefaultValueGroups[HumanoidHash];
			DefaultValueGroups[StructureHash] = DefaultValueGroups[WearNTearHash];
		}

		private static void ResolveValues(List<string> values)
		{
			for (int i = 0; i < values.Count; i++)
			{
				string text = values[i];
				if (text.StartsWith("<", StringComparison.OrdinalIgnoreCase) && text.EndsWith(">", StringComparison.OrdinalIgnoreCase))
				{
					string text2 = text.Substring(1, text.Length - 2);
					List<string> value2;
					if (ValueGroups.TryGetValue(StringExtensionMethods.GetStableHashCode(text2.ToLowerInvariant()), out List<string> value))
					{
						values.RemoveAt(i);
						values.InsertRange(i, value);
						i--;
					}
					else if (DefaultValueGroups.TryGetValue(StringExtensionMethods.GetStableHashCode(text2.ToLowerInvariant()), out value2))
					{
						values.RemoveAt(i);
						values.InsertRange(i, value2);
						i += value2.Count - 1;
					}
				}
			}
		}

		public static void SetupWatcher()
		{
			if (!Directory.Exists(GamePath))
			{
				Directory.CreateDirectory(GamePath);
			}
			if (!Directory.Exists(ProfilePath))
			{
				Directory.CreateDirectory(ProfilePath);
			}
			if (!Directory.Exists(Yaml.BaseDirectory))
			{
				Directory.CreateDirectory(Yaml.BaseDirectory);
			}
			Yaml.SetupWatcher(GamePath, "*", LoadEntries);
			if (GamePath != ProfilePath)
			{
				Yaml.SetupWatcher(ProfilePath, "*", LoadEntries);
			}
			Yaml.SetupWatcher(Pattern, LoadEntries);
		}
	}
	public class DataValue
	{
		public static IZdoIdValue ZdoId(string values)
		{
			//IL_000a: 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_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			string[] array = SplitWithValues(values);
			ZDOID val = Parse.ZdoId(array[0]);
			if (array.Length == 1 && val != ZDOID.None)
			{
				return new SimpleZdoIdValue(val);
			}
			return new ZdoIdValue(array);
		}

		public static IIntValue Simple(int value)
		{
			return new SimpleIntValue(value);
		}

		public static IStringValue Simple(string value)
		{
			return new SimpleStringValue(value);
		}

		public static IFloatValue Simple(float value)
		{
			return new SimpleFloatValue(value);
		}

		public static ILongValue Simple(long value)
		{
			return new SimpleLongValue(value);
		}

		public static IVector3Value Simple(Vector3 value)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return new SimpleVector3Value(value);
		}

		public static IQuaternionValue Simple(Quaternion value)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return new SimpleQuaternionValue(value);
		}

		public static IIntValue Int(string values)
		{
			string[] array = SplitWithValues(values);
			if (array.Length == 1 && int.TryParse(array[0], out var result))
			{
				return new SimpleIntValue(result);
			}
			return new IntValue(array);
		}

		public static IFloatValue Float(string values)
		{
			string[] array = SplitWithValues(values);
			if (array.Length == 1 && Parse.TryFloat(array[0], out var result))
			{
				return new SimpleFloatValue(result);
			}
			return new FloatValue(array);
		}

		public static ILongValue Long(string values)
		{
			string[] array = SplitWithValues(values);
			if (array.Length == 1 && long.TryParse(array[0], out var result))
			{
				return new SimpleLongValue(result);
			}
			return new LongValue(array);
		}

		public static IStringValue String(string values)
		{
			string[] array = SplitWithValues(values);
			if (array.Length == 1 && !HasParameters(array[0]))
			{
				return new SimpleStringValue(array[0]);
			}
			return new StringValue(array);
		}

		public static IBoolValue Bool(string values)
		{
			string[] array = SplitWithValues(values);
			if (array.Length == 1 && bool.TryParse(array[0], out var result))
			{
				return new SimpleBoolValue(result);
			}
			return new BoolValue(array);
		}

		public static IHashValue Hash(string values)
		{
			string[] array = SplitWithValues(values);
			if (array.Length == 1 && !HasParameters(array[0]))
			{
				return new SimpleHashValue(array[0]);
			}
			return new HashValue(array);
		}

		public static IPrefabValue Prefab(string values)
		{
			if (HasParameters(values))
			{
				return new PrefabValue(SplitWithValues(values));
			}
			List<int> prefabs = PrefabHelper.GetPrefabs(values);
			if (prefabs.Count == 0)
			{
				return new SimplePrefabValue(null);
			}
			if (prefabs.Count == 1)
			{
				return new SimplePrefabValue(prefabs[0]);
			}
			return new SimplePrefabsValue(prefabs);
		}

		public static IVector3Value Vector3(string values)
		{
			//IL_008a: 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)
			string[] array = SplitWithValues(values);
			if (HasParameters(values) || array.Length > 3)
			{
				List<string> list = new List<string>();
				for (int i = 0; i < array.Length; i += 3)
				{
					string[] value = ((i + 3 < array.Length) ? array.Skip(i).Take(3).ToArray() : array.Skip(i).ToArray());
					list.Add(string.Join(",", value));
				}
				return new Vector3Value(list.ToArray());
			}
			Vector3? val = Parse.VectorXZYNull(array);
			return new SimpleVector3Value(val.HasValue ? val.Value : Vector3.zero);
		}

		public static IQuaternionValue Quaternion(string values)
		{
			//IL_008a: 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)
			string[] array = SplitWithValues(values);
			if (HasParameters(values) || array.Length > 3)
			{
				List<string> list = new List<string>();
				for (int i = 0; i < array.Length; i += 3)
				{
					string[] value = ((i + 3 < array.Length) ? array.Skip(i).Take(3).ToArray() : array.Skip(i).ToArray());
					list.Add(string.Join(",", value));
				}
				return new QuaternionValue(list.ToArray());
			}
			Quaternion? val = Parse.AngleYXZNull(array);
			return new SimpleQuaternionValue(val.HasValue ? val.Value : Quaternion.identity);
		}

		private static bool HasParameters(string value)
		{
			if (value.Contains("<"))
			{
				return value.Contains(">");
			}
			return false;
		}

		private static string[] SplitWithValues(string str)
		{
			List<string> list = new List<string>();
			string[] array = Parse.SplitWithEmpty(str);
			foreach (string text in array)
			{
				if (!text.Contains("<") || !text.Contains(">"))
				{
					list.Add(text);
					continue;
				}
				string[] array2 = text.Split('<', '>');
				List<string> list2 = new List<string>();
				List<int> list3 = new List<int>();
				for (int j = 1; j < array2.Length; j += 2)
				{
					int stableHashCode = StringExtensionMethods.GetStableHashCode(array2[j].ToLowerInvariant());
					if (DataLoading.ValueGroups.ContainsKey(stableHashCode))
					{
						list2.Add("<" + array2[j] + ">");
						list3.Add(stableHashCode);
					}
				}
				if (list2.Count == 0)
				{
					list.Add(text);
				}
				else
				{
					SubstitueValues(list, text, list2, list3, 0);
				}
			}
			return list.ToArray();
		}

		private static void SubstitueValues(List<string> result, string format, List<string> parameters, List<int> hashes, int index)
		{
			foreach (string item in DataLoading.ValueGroups[hashes[index]])
			{
				string text = format.Replace(parameters[index], item);
				if (index == parameters.Count - 1)
				{
					result.Add(text);
				}
				else
				{
					SubstitueValues(result, text, parameters, hashes, index + 1);
				}
			}
		}
	}
	public class AnyValue(string[] values)
	{
		protected readonly string[] Values = values;

		private string? RollValue()
		{
			if (values.Length == 1)
			{
				return values[0];
			}
			return values[Random.Range(0, values.Length)];
		}

		protected string? GetValue(Parameters pars)
		{
			string text = RollValue();
			if (text == null || text == "<none>")
			{
				return null;
			}
			return pars.Replace(text);
		}

		protected string? GetValue()
		{
			string text = RollValue();
			if (text != null && !(text == "<none>"))
			{
				return text;
			}
			return null;
		}

		protected List<string> GetAllValues(Parameters pars)
		{
			return (from v in values.Select(pars.Replace)
				where v != null && v != "<none"
				select v).ToList();
		}
	}
	public class ItemValue
	{
		public IPrefabValue Prefab = DataValue.Prefab(data.prefab);

		public float Chance = data.chance;

		public IIntValue? Stack = ((data.stack == null) ? null : DataValue.Int(data.stack));

		public IFloatValue? Durability = ((data.durability == null) ? null : DataValue.Float(data.durability));

		public string Position = data.pos;

		private Vector2i RolledPosition = Parse.Vector2Int(data.pos);

		public IBoolValue? Equipped = ((data.equipped == null) ? null : DataValue.Bool(data.equipped));

		public IIntValue? Quality = ((data.quality == null) ? null : DataValue.Int(data.quality));

		public IIntValue? Variant = ((data.variant == null) ? null : DataValue.Int(data.variant));

		public ILongValue? CrafterID = ((data.crafterID == null) ? null : DataValue.Long(data.crafterID));

		public IStringValue? CrafterName = ((data.crafterName == null) ? null : DataValue.String(data.crafterName));

		public Dictionary<string, IStringValue>? CustomData = data.customData?.ToDictionary((KeyValuePair<string, string> kvp) => kvp.Key, (KeyValuePair<string, string> kvp) => DataValue.String(kvp.Value));

		public IIntValue? WorldLevel = ((data.worldLevel == null) ? null : DataValue.Int(data.worldLevel));

		public IBoolValue? PickedUp = ((data.pickedUp == null) ? null : DataValue.Bool(data.pickedUp));

		private int RolledPrefab;

		private int RolledStack;

		public ItemValue(ItemData data)
		{
		}//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)


		public static bool Match(Parameters pars, List<ItemValue> data, ZDO zdo, IIntValue? amount)
		{
			Inventory inv = CreateInventory(zdo);
			int num = data.Where((ItemValue item) => item.Match(pars, inv)).Count();
			if (amount == null)
			{
				if (num == data.Count)
				{
					return inv.m_inventory.Count == 0;
				}
				return false;
			}
			return amount.Match(pars, num) == true;
		}

		public static bool Match(Parameters pars, ZDO zdo, IIntValue amount)
		{
			Inventory val = CreateInventory(zdo);
			return amount.Match(pars, val.m_inventory.Count) == true;
		}

		public static Inventory CreateInventory(ZDO zdo, int width = 100000, int height = 10000)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Expected O, but got Unknown
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Expected O, but got Unknown
			Inventory val = new Inventory("", (Sprite)null, width, height);
			string text = zdo.GetString(ZDOVars.s_items, "");
			if (text != "")
			{
				ZPackage val2 = new ZPackage(text);
				val.Load(val2);
			}
			return val;
		}

		public static string LoadItems(Parameters pars, List<ItemValue> items, Vector2i size, int amount)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Expected O, but got Unknown
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			ZPackage val = new ZPackage();
			val.Write(106);
			items = Generate(pars, items, size, amount);
			val.Write(items.Count);
			foreach (ItemValue item in items)
			{
				item.Write(pars, val);
			}
			return val.GetBase64();
		}

		public static List<ItemValue> Generate(Parameters pars, List<ItemValue> data, Vector2i size, int amount)
		{
			//IL_0076: 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_009f: Unknown result type (might be due to invalid IL or missing references)
			List<ItemValue> list = data.Where((ItemValue item) => item.Position != "").ToList();
			List<ItemValue> items = data.Where((ItemValue item) => item.Position == "").ToList();
			Dictionary<Vector2i, ItemValue> dictionary = new Dictionary<Vector2i, ItemValue>();
			foreach (ItemValue item in list)
			{
				if (item.Roll(pars))
				{
					dictionary[item.RolledPosition] = item;
				}
			}
			if (amount == 0)
			{
				GenerateEach(pars, dictionary, size, items);
			}
			else
			{
				GenerateAmount(pars, dictionary, size, items, amount);
			}
			Dictionary<Vector2i, ItemValue>.ValueCollection values = dictionary.Values;
			List<ItemValue> list2 = new List<ItemValue>(values.Count);
			list2.AddRange(values);
			return list2;
		}

		private static void GenerateEach(Parameters pars, Dictionary<Vector2i, ItemValue> inventory, Vector2i size, List<ItemValue> items)
		{
			//IL_001b: 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_003d: Unknown result type (might be due to invalid IL or missing references)
			foreach (ItemValue item in items)
			{
				if (item.Roll(pars))
				{
					Vector2i? val = FindNextFreeSlot(inventory, size);
					if (!val.HasValue)
					{
						break;
					}
					item.RolledPosition = val.Value;
					inventory[val.Value] = item;
				}
			}
		}

		private static void GenerateAmount(Parameters pars, Dictionary<Vector2i, ItemValue> inventory, Vector2i size, List<ItemValue> items, int amount)
		{
			//IL_002b: 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_005c: Unknown result type (might be due to invalid IL or missing references)
			float num = items.Sum((ItemValue item) => item.Chance);
			for (int num2 = 0; num2 < amount; num2++)
			{
				if (items.Count <= 0)
				{
					break;
				}
				Vector2i? val = FindNextFreeSlot(inventory, size);
				if (val.HasValue)
				{
					ItemValue itemValue = RollItem(items, num);
					itemValue.RolledPosition = val.Value;
					if (itemValue.RollPrefab(pars))
					{
						inventory[val.Value] = itemValue;
					}
					num -= itemValue.Chance;
					items.Remove(itemValue);
					continue;
				}
				break;
			}
		}

		private static ItemValue RollItem(List<ItemValue> items, float maxWeight)
		{
			float num = Random.Range(0f, maxWeight);
			foreach (ItemValue item in items)
			{
				if (num < item.Chance)
				{
					return item;
				}
				num -= item.Chance;
			}
			return items.Last();
		}

		private static Vector2i? FindNextFreeSlot(Dictionary<Vector2i, ItemValue> inventory, Vector2i size)
		{
			//IL_0000: 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_0020: 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)
			int x = size.x;
			int y = size.y;
			Vector2i val = default(Vector2i);
			for (int i = 0; i < y; i++)
			{
				for (int j = 0; j < x; j++)
				{
					((Vector2i)(ref val))..ctor(j, i);
					if (!inventory.ContainsKey(val))
					{
						return val;
					}
				}
			}
			return null;
		}

		public bool RollPrefab(Parameters pars)
		{
			RolledPrefab = Prefab.Get(pars).GetValueOrDefault();
			RolledStack = Stack?.Get(pars) ?? 1;
			if (RolledPrefab != 0)
			{
				return RolledStack != 0;
			}
			return false;
		}

		public bool RollChance()
		{
			if (!(Chance >= 1f))
			{
				return Random.value <= Chance;
			}
			return true;
		}

		public bool Roll(Parameters pars)
		{
			if (RollChance())
			{
				return RollPrefab(pars);
			}
			return false;
		}

		public void Write(Parameters pars, ZPackage pkg)
		{
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			GameObject itemPrefab = ObjectDB.instance.GetItemPrefab(RolledPrefab);
			pkg.Write(((itemPrefab != null) ? ((Object)itemPrefab).name : null) ?? "");
			int num = Quality?.Get(pars) ?? 1;
			float? num2 = Durability?.Get(pars);
			if (!num2.HasValue)
			{
				ItemDrop val = default(ItemDrop);
				num2 = ((!((Object)(object)itemPrefab != (Object)null) || !itemPrefab.TryGetComponent<ItemDrop>(ref val)) ? new float?(100f) : new float?(val.m_itemData.GetMaxDurability(num)));
			}
			pkg.Write(RolledStack);
			pkg.Write(num2.Value);
			pkg.Write(RolledPosition);
			pkg.Write(Equipped?.GetBool(pars) == true);
			pkg.Write(num);
			pkg.Write((Variant?.Get(pars)).GetValueOrDefault());
			pkg.Write((CrafterID?.Get(pars)).GetValueOrDefault());
			pkg.Write(CrafterName?.Get(pars) ?? "");
			pkg.Write(CustomData?.Count ?? 0);
			if (CustomData != null)
			{
				foreach (KeyValuePair<string, IStringValue> customDatum in CustomData)
				{
					pkg.Write(customDatum.Key);
					pkg.Write(customDatum.Value.Get(pars));
				}
			}
			pkg.Write((WorldLevel?.Get(pars)).GetValueOrDefault());
			pkg.Write(PickedUp?.GetBool(pars) == true);
		}

		public void AddTo(Parameters pars, Inventory inv)
		{
			int stack = Stack?.Get(pars) ?? 1;
			stack = StackTo(pars, stack, inv);
			InsertTo(pars, stack, inv);
		}

		private int StackTo(Parameters pars, int stack, Inventory inv)
		{
			foreach (ItemData item in inv.m_inventory)
			{
				if (MatchItem(pars, item))
				{
					int num = Mathf.Min(item.m_shared.m_maxStackSize - item.m_stack, stack);
					item.m_stack += num;
					stack -= num;
					if (stack <= 0)
					{
						break;
					}
				}
			}
			return stack;
		}

		private int InsertTo(Parameters pars, int stack, Inventory inv)
		{
			//IL_02ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_028c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0291: Unknown result type (might be due to invalid IL or missing references)
			//IL_0293: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a3: Unknown result type (might be due to invalid IL or missing references)
			ItemDrop val = default(ItemDrop);
			while (stack > 0)
			{
				int valueOrDefault = Prefab.Get(pars).GetValueOrDefault();
				GameObject itemPrefab = ObjectDB.instance.GetItemPrefab(valueOrDefault);
				if ((Object)(object)itemPrefab == (Object)null || !itemPrefab.TryGetComponent<ItemDrop>(ref val))
				{
					return stack;
				}
				ItemData val2 = val.m_itemData.Clone();
				val2.m_dropPrefab = itemPrefab;
				val2.m_quality = Quality?.Get(pars) ?? 1;
				val2.m_variant = (Variant?.Get(pars)).GetValueOrDefault();
				val2.m_crafterID = (CrafterID?.Get(pars)).GetValueOrDefault();
				val2.m_crafterName = CrafterName?.Get(pars) ?? "";
				val2.m_worldLevel = (WorldLevel?.Get(pars)).GetValueOrDefault();
				val2.m_durability = Durability?.Get(pars) ?? val2.GetMaxDurability(val2.m_quality);
				val2.m_equipped = Equipped?.GetBool(pars) == true;
				val2.m_pickedUp = PickedUp?.GetBool(pars) == true;
				val2.m_customData = CustomData.ToDictionary<KeyValuePair<string, IStringValue>, string, string>((KeyValuePair<string, IStringValue> x) => x.Key, (KeyValuePair<string, IStringValue> x) => x.Value.Get(pars) ?? "");
				int num = Mathf.Min(val2.m_shared.m_maxStackSize, stack);
				stack -= num;
				val2.m_stack = num;
				if (Position == "")
				{
					Vector2i val3 = inv.FindEmptySlot(true);
					if (val3.x < 0)
					{
						return stack;
					}
					val2.m_gridPos = val3;
					inv.m_inventory.Add(val2);
				}
				else
				{
					val2.m_gridPos = RolledPosition;
					inv.m_inventory.RemoveAll((ItemData x) => x.m_gridPos == RolledPosition);
					inv.m_inventory.Add(val2);
				}
			}
			return stack;
		}

		public void RemoveFrom(Parameters pars, Inventory inv)
		{
			int num = Stack?.Get(pars) ?? 1;
			for (int num2 = inv.m_inventory.Count - 1; num2 >= 0; num2--)
			{
				ItemData val = inv.m_inventory[num2];
				if (MatchItem(pars, val))
				{
					int num3 = Mathf.Min(val.m_stack, num);
					val.m_stack -= num3;
					num -= num3;
					if (num <= 0)
					{
						break;
					}
				}
			}
			inv.m_inventory.RemoveAll((ItemData x) => x.m_stack <= 0);
		}

		public bool Match(Parameters pars, Inventory inv)
		{
			ItemData val = FindMatch(pars, inv);
			if (val == null)
			{
				return false;
			}
			inv.RemoveItem(val);
			return true;
		}

		private ItemData? FindMatch(Parameters pars, Inventory inv)
		{
			if (Position != "")
			{
				ItemData itemAt = inv.GetItemAt(RolledPosition.x, RolledPosition.y);
				if (itemAt == null)
				{
					return null;
				}
				IIntValue? stack = Stack;
				if (stack != null && stack.Match(pars, itemAt.m_stack) == false)
				{
					return null;
				}
				if (MatchItem(pars, itemAt))
				{
					return itemAt;
				}
			}
			foreach (ItemData item in inv.m_inventory)
			{
				IIntValue? stack2 = Stack;
				if ((stack2 == null || stack2.Match(pars, item.m_stack) != false) && MatchItem(pars, item))
				{
					return item;
				}
			}
			return null;
		}

		private bool MatchItem(Parameters pars, ItemData item)
		{
			GameObject dropPrefab = item.m_dropPrefab;
			string text = ((dropPrefab != null) ? ((Object)dropPrefab).name : null) ?? item.m_shared.m_name;
			bool? flag = Prefab.Match(pars, StringExtensionMethods.GetStableHashCode(text));
			bool flag2 = false;
			if (flag == flag2)
			{
				return false;
			}
			IFloatValue? durability = Durability;
			if (durability != null)
			{
				flag = durability.Match(pars, item.m_durability);
				flag2 = false;
				if (flag == flag2)
				{
					return false;
				}
			}
			IBoolValue? equipped = Equipped;
			if (equipped != null)
			{
				flag = equipped.Match(pars, item.m_equipped);
				flag2 = false;
				if (flag == flag2)
				{
					return false;
				}
			}
			IIntValue? quality = Quality;
			if (quality != null)
			{
				flag = quality.Match(pars, item.m_quality);
				flag2 = false;
				if (flag == flag2)
				{
					return false;
				}
			}
			IIntValue? variant = Variant;
			if (variant != null)
			{
				flag = variant.Match(pars, item.m_variant);
				flag2 = false;
				if (flag == flag2)
				{
					return false;
				}
			}
			ILongValue? crafterID = CrafterID;
			if (crafterID != null)
			{
				flag = crafterID.Match(pars, item.m_crafterID);
				flag2 = false;
				if (flag == flag2)
				{
					return false;
				}
			}
			IStringValue? crafterName = CrafterName;
			if (crafterName != null)
			{
				flag = crafterName.Match(pars, item.m_crafterName);
				flag2 = false;
				if (flag == flag2)
				{
					return false;
				}
			}
			IIntValue? worldLevel = WorldLevel;
			if (worldLevel != null)
			{
				flag = worldLevel.Match(pars, item.m_worldLevel);
				flag2 = false;
				if (flag == flag2)
				{
					return false;
				}
			}
			IBoolValue? pickedUp = PickedUp;
			if (pickedUp != null)
			{
				flag = pickedUp.Match(pars, item.m_pickedUp);
				flag2 = false;
				if (flag == flag2)
				{
					return false;
				}
			}
			if (CustomData == null)
			{
				return true;
			}
			foreach (KeyValuePair<string, IStringValue> customDatum in CustomData)
			{
				if (!item.m_customData.TryGetValue(customDatum.Key, out var value))
				{
					flag2 = false;
				}
				else
				{
					if (customDatum.Value.Match(pars, value) != false)
					{
						continue;
					}
					flag2 = false;
				}
				goto IL_025f;
			}
			return true;
			IL_025f:
			return flag2;
		}
	}
	public class Parameters(string prefab, string arg, Vector3 pos)
	{
		protected string[]? args;

		private readonly double time = ZNet.instance.GetTimeSeconds();

		public string Replace(string str)
		{
			StringBuilder stringBuilder = new StringBuilder();
			int num = 0;
			int num2 = 0;
			for (int i = 0; i < str.Length; i++)
			{
				if (str[i] == '<')
				{
					if (num == 0)
					{
						stringBuilder.Append(str.Substring(num2, i - num2));
						num2 = i;
					}
					num++;
				}
				if (str[i] == '>')
				{
					if (num == 1)
					{
						string str2 = str.Substring(num2, i - num2 + 1);
						stringBuilder.Append(ResolveParameters(str2));
						num2 = i + 1;
					}
					if (num > 0)
					{
						num--;
					}
				}
			}
			if (num2 < str.Length)
			{
				stringBuilder.Append(str.Substring(num2));
			}
			return stringBuilder.ToString();
		}

		private string ResolveParameters(string str)
		{
			int num;
			for (num = 0; num < str.Length; num++)
			{
				int num2 = str.IndexOf(">", num);
				if (num2 == -1)
				{
					break;
				}
				num = num2;
				int num3 = str.LastIndexOf("<", num2);
				if (num3 != -1)
				{
					int num4 = num2 - num3 + 1;
					if (TryReplaceParameter(str.Substring(num3, num4), out string resolved))
					{
						str = str.Remove(num3, num4);
						str = str.Insert(num3, resolved);
						num = num3 - 1;
					}
					else
					{
						num = num2;
					}
				}
			}
			return str;
		}

		private bool TryReplaceParameter(string key, out string? resolved)
		{
			resolved = GetParameter(key);
			if (resolved == null)
			{
				resolved = ResolveValue(key);
			}
			return resolved != key;
		}

		protected virtual string? GetParameter(string key)
		{
			return key switch
			{
				"<prefab>" => prefab, 
				"<par>" => arg, 
				"<par0>" => GetArg(0), 
				"<par1>" => GetArg(1), 
				"<par2>" => GetArg(2), 
				"<par3>" => GetArg(3), 
				"<par4>" => GetArg(4), 
				"<par5>" => GetArg(5), 
				"<par6>" => GetArg(6), 
				"<par7>" => GetArg(7), 
				"<par8>" => GetArg(8), 
				"<par9>" => GetArg(9), 
				"<time>" => Format(time), 
				"<day>" => EnvMan.instance.GetDay(time).ToString(), 
				"<ticks>" => ((long)(time * 10000000.0)).ToString(), 
				"<x>" => Format(pos.x), 
				"<y>" => Format(pos.y), 
				"<z>" => Format(pos.z), 
				"<snap>" => Format(WorldGenerator.instance.GetHeight(pos.x, pos.z)), 
				_ => null, 
			};
		}

		private string GetArg(int index)
		{
			if (args == null)
			{
				args = arg.Split(new char[1] { ' ' });
			}
			if (args.Length > index)
			{
				return args[index];
			}
			return "";
		}

		protected static string Format(float value)
		{
			return value.ToString("0.#####", NumberFormatInfo.InvariantInfo);
		}

		protected static string Format(double value)
		{
			return value.ToString("0.#####", NumberFormatInfo.InvariantInfo);
		}

		private static string ResolveValue(string value)
		{
			if (!value.StartsWith("<", StringComparison.OrdinalIgnoreCase))
			{
				return value;
			}
			if (!value.EndsWith(">", StringComparison.OrdinalIgnoreCase))
			{
				return value;
			}
			if (TryGetValueFromGroup(value.Substring(1, value.Length - 2), out string value2))
			{
				return value2;
			}
			return value;
		}

		private static bool TryGetValueFromGroup(string group, out string value)
		{
			int stableHashCode = StringExtensionMethods.GetStableHashCode(group.ToLowerInvariant());
			if (!DataLoading.ValueGroups.ContainsKey(stableHashCode))
			{
				value = group;
				return false;
			}
			int index = Random.Range(0, DataLoading.ValueGroups[stableHashCode].Count);
			value = ResolveValue(DataLoading.ValueGroups[stableHashCode][index]);
			return true;
		}
	}
	public class ObjectParameters : Parameters
	{
		private Inventory? inventory;

		public ObjectParameters(string prefab, string arg, ZDO zdo)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			<zdo>P = zdo;
			base..ctor(prefab, arg, <zdo>P.m_position);
		}

		protected override string? GetParameter(string key)
		{
			string parameter = base.GetParameter(key);
			if (parameter != null)
			{
				return parameter;
			}
			parameter = GetGeneralParameter(key);
			if (parameter != null)
			{
				return parameter;
			}
			KeyValuePair<string, string> keyValuePair = Parse.Kvp(key, '_');
			if (keyValuePair.Value != "")
			{
				string key2 = keyValuePair.Key.Substring(1);
				string value = keyValuePair.Value.Substring(0, keyValuePair.Value.Length - 1);
				return GetZdoValue(key2, value);
			}
			return null;
		}

		private string? GetGeneralParameter(string key)
		{
			//IL_0203: Unknown result type (might be due to invalid IL or missing references)
			//IL_0208: 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_0226: 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_0230: Unknown result type (might be due to invalid IL or missing references)
			return key switch
			{
				"<zdo>" => ((object)Unsafe.As<ZDOID, ZDOID>(ref <zdo>P.m_uid)/*cast due to .constrained prefix*/).ToString(), 
				"<pos>" => Parameters.Format(<zdo>P.m_position.x) + "," + Parameters.Format(<zdo>P.m_position.z) + "," + Parameters.Format(<zdo>P.m_position.y), 
				"<i>" => ZoneSystem.GetZone(<zdo>P.m_position).x.ToString(), 
				"<j>" => ZoneSystem.GetZone(<zdo>P.m_position).y.ToString(), 
				"<a>" => Parameters.Format(<zdo>P.m_rotation.y), 
				"<rot>" => Parameters.Format(<zdo>P.m_rotation.y) + "," + Parameters.Format(<zdo>P.m_rotation.x) + "," + Parameters.Format(<zdo>P.m_rotation.z), 
				"<pid>" => GetPid(<zdo>P), 
				"<pname>" => GetPname(<zdo>P), 
				"<pchar>" => GetPchar(<zdo>P), 
				"<owner>" => <zdo>P.GetOwner().ToString(), 
				_ => null, 
			};
		}

		private static string GetPid(ZDO zdo)
		{
			ZNetPeer peer = GetPeer(zdo);
			if (peer != null)
			{
				return peer.m_rpc.GetSocket().GetHostName();
			}
			if (Object.op_Implicit((Object)(object)Player.m_localPlayer))
			{
				return "Server";
			}
			return "";
		}

		private static string GetPname(ZDO zdo)
		{
			ZNetPeer peer = GetPeer(zdo);
			if (peer != null)
			{
				return peer.m_playerName;
			}
			if (Object.op_Implicit((Object)(object)Player.m_localPlayer))
			{
				return Player.m_localPlayer.GetPlayerName();
			}
			return "";
		}

		private static string GetPchar(ZDO zdo)
		{
			ZNetPeer peer = GetPeer(zdo);
			if (peer != null)
			{
				return ((object)Unsafe.As<ZDOID, ZDOID>(ref peer.m_characterID)/*cast due to .constrained prefix*/).ToString();
			}
			if (Object.op_Implicit((Object)(object)Player.m_localPlayer))
			{
				return Player.m_localPlayer.GetPlayerID().ToString();
			}
			return "";
		}

		private static ZNetPeer? GetPeer(ZDO zdo)
		{
			if (zdo.GetOwner() == 0L)
			{
				return null;
			}
			return ZNet.instance.GetPeer(zdo.GetOwner());
		}

		private string GetZdoValue(string key, string value)
		{
			//IL_0276: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_0267: Unknown result type (might be due to invalid IL or missing references)
			//IL_029f: 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)
			switch (key)
			{
			case "key":
				return DataHelper.GetGlobalKey(value);
			case "string":
				return GetString(value);
			case "float":
				return GetFloat(value).ToString(CultureInfo.InvariantCulture);
			case "int":
				return GetInt(value).ToString(CultureInfo.InvariantCulture);
			case "long":
				return GetLong(value).ToString(CultureInfo.InvariantCulture);
			case "bool":
				return GetBool(value) ? "true" : "false";
			case "hash":
			{
				GameObject prefab = ZNetScene.instance.GetPrefab(<zdo>P.GetInt(value, 0));
				return ((prefab != null) ? ((Object)prefab).name : null) ?? "";
			}
			case "vec":
				return DataEntry.PrintVectorXZY(GetVec3(value));
			case "quat":
				return DataEntry.PrintAngleYXZ(GetQuaternion(value));
			case "byte":
				return Convert.ToBase64String(<zdo>P.GetByteArray(value, (byte[])null));
			case "zdo":
				return ((object)<zdo>P.GetZDOID(value)/*cast due to .constrained prefix*/).ToString();
			case "item":
				return GetAmountOfItems(value).ToString();
			case "pos":
				return DataEntry.PrintVectorXZY(GetPos(value));
			default:
				return "";
			}
		}

		private string GetString(string value)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			string result = default(string);
			if (!ZDOExtraData.s_strings.TryGetValue(<zdo>P.m_uid, out var value2) || !value2.TryGetValue(StringExtensionMethods.GetStableHashCode(value), ref result))
			{
				return GetStringField(value);
			}
			return result;
		}

		private float GetFloat(string value)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			float result = default(float);
			if (!ZDOExtraData.s_floats.TryGetValue(<zdo>P.m_uid, out var value2) || !value2.TryGetValue(StringExtensionMethods.GetStableHashCode(value), ref result))
			{
				return GetFloatField(value);
			}
			return result;
		}

		private int GetInt(string value)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			int result = default(int);
			if (!ZDOExtraData.s_ints.TryGetValue(<zdo>P.m_uid, out var value2) || !value2.TryGetValue(StringExtensionMethods.GetStableHashCode(value), ref result))
			{
				return GetIntField(value);
			}
			return result;
		}

		private long GetLong(string value)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			long result = default(long);
			if (!ZDOExtraData.s_longs.TryGetValue(<zdo>P.m_uid, out var value2) || !value2.TryGetValue(StringExtensionMethods.GetStableHashCode(value), ref result))
			{
				return GetLongField(value);
			}
			return result;
		}

		private bool GetBool(string value)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			int num = default(int);
			if (!ZDOExtraData.s_ints.TryGetValue(<zdo>P.m_uid, out var value2) || !value2.TryGetValue(StringExtensionMethods.GetStableHashCode(value), ref num))
			{
				return GetBoolField(value);
			}
			return num > 0;
		}

		private Vector3 GetVec3(string value)
		{
			//IL_000b: 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: Unknown result type (might be due to invalid IL or missing references)
			Vector3 result = default(Vector3);
			if (!ZDOExtraData.s_vec3.TryGetValue(<zdo>P.m_uid, out var value2) || !value2.TryGetValue(StringExtensionMethods.GetStableHashCode(value), ref result))
			{
				return GetVecField(value);
			}
			return result;
		}

		private Quaternion GetQuaternion(string value)
		{
			//IL_000b: 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: Unknown result type (might be due to invalid IL or missing references)
			Quaternion result = default(Quaternion);
			if (!ZDOExtraData.s_quats.TryGetValue(<zdo>P.m_uid, out var value2) || !value2.TryGetValue(StringExtensionMethods.GetStableHashCode(value), ref result))
			{
				return GetQuatField(value);
			}
			return result;
		}

		private string GetStringField(string value)
		{
			if (!(GetField(value) is string result))
			{
				return "";
			}
			return result;
		}

		private float GetFloatField(string value)
		{
			object field = GetField(value);
			if (field is float)
			{
				return (float)field;
			}
			return 0f;
		}

		private int GetIntField(string value)
		{
			object field = GetField(value);
			if (field is int)
			{
				return (int)field;
			}
			return 0;
		}

		private bool GetBoolField(string value)
		{
			object field = GetField(value);
			if (field is bool)
			{
				return (bool)field;
			}
			return false;
		}

		private long GetLongField(string value)
		{
			object field = GetField(value);
			if (field is long)
			{
				return (long)field;
			}
			return 0L;
		}

		private Vector3 GetVecField(string value)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: 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)
			object field = GetField(value);
			if (field is Vector3)
			{
				return (Vector3)field;
			}
			return Vector3.zero;
		}

		private Quaternion GetQuatField(string value)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: 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)
			object field = GetField(value);
			if (field is Quaternion)
			{
				return (Quaternion)field;
			}
			return Quaternion.identity;
		}

		private object? GetField(string value)
		{
			KeyValuePair<string, string> keyValuePair = Parse.Kvp(value, '.');
			if (keyValuePair.Value == "")
			{
				return null;
			}
			GameObject prefab = ZNetScene.instance.GetPrefab(<zdo>P.m_prefab);
			if ((Object)(object)prefab == (Object)null)
			{
				return null;
			}
			Component component = prefab.GetComponent(keyValuePair.Key);
			if ((Object)(object)component == (Object)null)
			{
				return null;
			}
			string[] array = keyValuePair.Value.Split(new char[1] { '.' });
			object obj = component;
			string[] array2 = array;
			foreach (string name in array2)
			{
				FieldInfo field = obj.GetType().GetField(name);
				if (field == null)
				{
					return null;
				}
				obj = field.GetValue(obj);
				if (obj == null)
				{
					return null;
				}
			}
			return obj;
		}

		private int GetAmountOfItems(string prefab)
		{
			LoadInventory();
			if (inventory == null)
			{
				return 0;
			}
			int num = 0;
			foreach (ItemData item in inventory.m_inventory)
			{
				GameObject dropPrefab = item.m_dropPrefab;
				if ((((dropPrefab != null) ? ((Object)dropPrefab).name : null) ?? item.m_shared.m_name) == prefab)
				{
					num += item.m_stack;
				}
			}
			return num;
		}

		private void LoadInventory()
		{
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Expected O, but got Unknown
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Expected O, but got Unknown
			if (inventory == null)
			{
				string text = <zdo>P.GetString(ZDOVars.s_items, "");
				if (!(text == ""))
				{
					inventory = new Inventory("", (Sprite)null, 4, 2);
					inventory.Load(new ZPackage(text));
				}
			}
		}

		private Vector3 GetPos(string 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)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: 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_0023: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = Parse.VectorXZY(value);
			return <zdo>P.GetPosition() + <zdo>P.GetRotation() * val;
		}
	}
	public class PrefabHelper
	{
		private static readonly Dictionary<string, List<int>> ResultCache = new Dictionary<string, List<int>>();

		private static Dictionary<string, int> PrefabCache = new Dictionary<string, int>();

		public static int? GetPrefab(string value)
		{
			List<int> prefabs = GetPrefabs(value);
			if (prefabs.Count == 0)
			{
				return null;
			}
			if (prefabs.Count == 1)
			{
				return prefabs[0];
			}
			return prefabs[Random.Range(0, prefabs.Count)];
		}

		public static void ClearCache()
		{
			ResultCache.Clear();
			PrefabCache.Clear();
		}

		public static List<int> GetPrefabs(string value)
		{
			if (ResultCache.ContainsKey(value))
			{
				return ResultCache[value];
			}
			List<int> prefabs = GetPrefabs(Parse.ToList(value));
			if (prefabs == null)
			{
				return new List<int>();
			}
			ResultCache[value] = prefabs;
			return prefabs;
		}

		public static List<int>? GetPrefabs(List<string> values)
		{
			if (values.Count == 0)
			{
				return null;
			}
			if (values.Count == 1)
			{
				return ParsePrefabs(values[0]);
			}
			List<List<int>> list = (from s in values.Select(ParsePrefabs)
				where s != null
				select s).ToList();
			HashSet<int> hashSet = new HashSet<int>();
			foreach (List<int> item in list)
			{
				if (item == null)
				{
					continue;
				}
				foreach (int item2 in item)
				{
					hashSet.Add(item2);
				}
			}
			if (hashSet.Count != 0)
			{
				HashSet<int> hashSet2 = hashSet;
				List<int> list2 = new List<int>(hashSet2.Count);
				list2.AddRange(hashSet2);
				return list2;
			}
			return null;
		}

		private static List<int>? ParsePrefabs(string prefab)
		{
			string p = prefab.ToLowerInvariant();
			if (PrefabCache.Count == 0)
			{
				PrefabCache = ZNetScene.instance.m_namedPrefabs.ToDictionary((KeyValuePair<int, GameObject> pair) => ((Object)pair.Value).name, (KeyValuePair<int, GameObject> pair) => pair.Key);
			}
			if (p == "*")
			{
				Dictionary<string, int>.ValueCollection values = PrefabCache.Values;
				List<int> list = new List<int>(values.Count);
				list.AddRange(values);
				return list;
			}
			if (p[0] == '*' && p[p.Length - 1] == '*')
			{
				p = p.Substring(1, p.Length - 2);
				return (from pair in PrefabCache
					where pair.Key.ToLowerInvariant().Contains(p)
					select pair.Value).ToList();
			}
			if (p[0] == '*')
			{
				p = p.Substring(1);
				return (from pair in PrefabCache
					where pair.Key.EndsWith(p, StringComparison.OrdinalIgnoreCase)
					select pair.Value).ToList();
			}
			if (p[p.Length - 1] == '*')
			{
				p = p.Substring(0, p.Length - 1);
				return (from pair in PrefabCache
					where pair.Key.StartsWith(p, StringComparison.OrdinalIgnoreCase)
					select pair.Value).ToList();
			}
			if (PrefabCache.ContainsKey(prefab))
			{
				return new List<int>(1) { PrefabCache[prefab] };
			}
			List<string> valuesFromGroup = DataHelper.GetValuesFromGroup(prefab);
			if (valuesFromGroup != null)
			{
				return valuesFromGroup.Select((string s) => StringExtensionMethods.GetStableHashCode(s)).ToList();
			}
			Log.Warning("Failed to resolve prefab: " + prefab);
			return null;
		}
	}
	public class BoolValue : AnyValue, IBoolValue
	{
		public BoolValue(string[] values)
			: base(values)
		{
		}

		public int? GetInt(Parameters pars)
		{
			string value = GetValue(pars);
			if (value == null)
			{
				return null;
			}
			return (value == "true" || value == "1") ? 1 : 0;
		}

		public bool? GetBool(Parameters pars)
		{
			string value = GetValue(pars);
			if (value == null)
			{
				return null;
			}
			return value == "true" || value == "1";
		}

		public bool? Match(Parameters pars, bool value)
		{
			bool flag = true;
			string[] values = values;
			foreach (string str in values)
			{
				string text = pars.Replace(str);
				if (text != null)
				{
					flag = false;
					if ((text == "true" || text == "1") == value)
					{
						return true;
					}
				}
			}
			if (!flag)
			{
				return false;
			}
			return null;
		}
	}
	public class SimpleBoolValue(bool value) : IBoolValue
	{
		private readonly bool Value = value;

		public int? GetInt(Parameters pars)
		{
			return value ? 1 : 0;
		}

		public bool? GetBool(Parameters pars)
		{
			return value;
		}

		public bool? Match(Parameters pars, bool value)
		{
			return value == value;
		}
	}
	public interface IBoolValue
	{
		int? GetInt(Parameters pars);

		bool? GetBool(Parameters pars);

		bool? Match(Parameters pars, bool value);
	}
	public class FloatValue : AnyValue, IFloatValue
	{
		public FloatValue(string[] values)
			: base(values)
		{
		}

		public float? Get(Parameters pars)
		{
			string value = GetValue(pars);
			if (value == null)
			{
				return null;
			}
			if (!value.Contains(";"))
			{
				return Calculator.EvaluateFloat(value);
			}
			string[] array = value.Split(new char[1] { ';' });
			if (array.Length < 2)
			{
				throw new InvalidOperationException("Invalid range format: " + value);
			}
			float? num = Calculator.EvaluateFloat(array[0]);
			float? num2 = Calculator.EvaluateFloat(array[1]);
			if (!num.HasValue || !num2.HasValue)
			{
				return null;
			}
			float? num3;
			if (array.Length < 3 || array[2] == "")
			{
				num3 = Random.Range(num.Value, num2.Value);
			}
			else
			{
				float? num4 = Calculator.EvaluateFloat(array[2]);
				if (!num4.HasValue)
				{
					num3 = Random.Range(num.Value, num2.Value);
				}
				else
				{
					int num5 = (int)((num2.Value - num.Value) / num4.Value);
					int num6 = Random.Range(0, num5 + 1);
					num3 = num + (float)num6 * num4;
				}
			}
			if (array.Length < 4)
			{
				return num3;
			}
			return Calculator.EvaluateFloat(array[3].Replace("<value>", num3?.ToString(CultureInfo.InvariantCulture)));
		}

		public bool TryGet(Parameters pars, out float value)
		{
			float? num = Get(pars);
			if (num.HasValue)
			{
				value = num.Value;
			}
			else
			{
				value = 0f;
			}
			return num.HasValue;
		}

		public bool? Match(Parameters pars, float value)
		{
			bool flag = true;
			string[] values = values;
			foreach (string str in values)
			{
				string text = pars.Replace(str);
				if (!text.Contains(";"))
				{
					float? num = Calculator.EvaluateFloat(text);
					if (num.HasValue)
					{
						flag = false;
						if (Helper.Approx(num.Value, value))
						{
							return true;
						}
					}
					continue;
				}
				string[] array = text.Split(new char[1] { ';' });
				if (array.Length < 2)
				{
					throw new InvalidOperationException("Invalid range format: " + text);
				}
				float? num2 = Calculator.EvaluateFloat(array[0]);
				float? num3 = Calculator.EvaluateFloat(array[1]);
				if (!num2.HasValue || !num3.HasValue)
				{
					continue;
				}
				if (array.Length < 3)
				{
					flag = false;
					if (Helper.ApproxBetween(value, num2.Value, num3.Value))
					{
						return true;
					}
					continue;
				}
				if (array.Length < 4)
				{
					float? num4 = Calculator.EvaluateFloat(array[2]);
					if (!num4.HasValue)
					{
						continue;
					}
					flag = false;
					int num5 = (int)((num3.Value - num2.Value) / num4.Value);
					for (int j = 0; j <= num5; j++)
					{
						if (Helper.Approx(num2.Value + (float)j * num4.Value, value))
						{
							return true;
						}
					}
					continue;
				}
				if (array[2] == "")
				{
					float? num6 = Calculator.EvaluateFloat(array[3].Replace("<value>", num2?.ToString(CultureInfo.InvariantCulture)));
					float? num7 = Calculator.EvaluateFloat(array[3].Replace("<value>", num3?.ToString(CultureInfo.InvariantCulture)));
					if (num6.HasValue && num7.HasValue)
					{
						flag = false;
						if (Helper.ApproxBetween(value, num6.Value, num7.Value))
						{
							return true;
						}
					}
					continue;
				}
				float? num8 = Calculator.EvaluateFloat(array[2]);
				if (!num8.HasValue)
				{
					continue;
				}
				flag = false;
				int num9 = (int)((num3.Value - num2.Value) / num8.Value);
				for (int k = 0; k <= num9; k++)
				{
					float? num10 = num2;
					float num11 = k;
					float? num12 = num8;
					float? num13 = Calculator.EvaluateFloat(array[3].Replace("<value>", (num10 + num11 * num12)?.ToString(CultureInfo.InvariantCulture)));
					if (num13.HasValue && Helper.Approx(num13.Value, value))
					{
						return true;
					}
				}
			}
			if (!flag)
			{
				return false;
			}
			return null;
		}
	}
	public class SimpleFloatValue(float value) : IFloatValue
	{
		private readonly float Value = value;

		public float? Get(Parameters pars)
		{
			return value;
		}

		public bool TryGet(Parameters pars, out float value)
		{
			value = value;
			return true;
		}

		public bool? Match(Parameters pars, float value)
		{
			return value == value;
		}
	}
	public interface IFloatValue
	{
		float? Get(Parameters pars);

		bool TryGet(Parameters pars, out float value);

		bool? Match(Parameters pars, float value);
	}
	public class HashValue : AnyValue, IHashValue
	{
		public HashValue(string[] values)
			: base(values)
		{
		}

		public int? Get(Parameters pars)
		{
			string? value = GetValue(pars);
			if (value == null)
			{
				return null;
			}
			return StringExtensionMethods.GetStableHashCode(value);
		}

		public bool? Match(Parameters pars, int value)
		{
			List<string> allValues = GetAllValues(pars);
			if (allValues.Count == 0)
			{
				return null;
			}
			return allValues.Any((string v) => StringExtensionMethods.GetStableHashCode(v) == value);
		}
	}
	public class SimpleHashValue : IHashValue
	{
		private readonly int Value = StringExtensionMethods.GetStableHashCode(value);

		public SimpleHashValue(string value)
		{
		}

		public int? Get(Parameters pars)
		{
			return Value;
		}

		public bool? Match(Parameters pars, int value)
		{
			return Value == value;
		}
	}
	public interface IHashValue
	{
		int? Get(Parameters pars);

		bool? Match(Parameters pars, int value);
	}
	public class IntValue : AnyValue, IIntValue
	{
		public IntValue(string[] values)
			: base(values)
		{
		}

		public int? Get(Parameters pars)
		{
			string value = GetValue(pars);
			if (value == null)
			{
				return null;
			}
			if (!value.Contains(";"))
			{
				return Calculator.EvaluateInt(value);
			}
			string[] array = value.Split(new char[1] { ';' });
			if (array.Length < 2)
			{
				throw new InvalidOperationException("Invalid range format: " + value);
			}
			int? num = Calculator.EvaluateInt(array[0]);
			int? num2 = Calculator.EvaluateInt(array[1]);
			if (!num.HasValue || !num2.HasValue)
			{
				return null;
			}
			int? result;
			if (array.Length < 3 || array[2] == "")
			{
				result = Random.Range(num.Value, num2.Value + 1);
			}
			else
			{
				int? num3 = Calculator.EvaluateInt(array[2]);
				if (!num3.HasValue)
				{
					result = Random.Range(num.Value, num2.Value + 1);
				}
				else
				{
					int num4 = Random.Range(0, ((num2 - num) / num3).Value + 1);
					result = num + num4 * num3;
				}
			}
			if (array.Length < 4)
			{
				return result;
			}
			return Calculator.EvaluateInt(array[3].Replace("<value>", result.ToString()));
		}

		public bool? Match(Parameters pars, int value)
		{
			bool flag = true;
			string[] values = values;
			foreach (string str in values)
			{
				string text = pars.Replace(str);
				if (!text.Contains(";"))
				{
					int? num = Calculator.EvaluateInt(text);
					if (num.HasValue)
					{
						flag = false;
						if (num.Value == value)
						{
							return true;
						}
					}
					continue;
				}
				string[] array = text.Split(new char[1] { ';' });
				if (array.Length < 2)
				{
					throw new InvalidOperationException("Invalid range format: " + text);
				}
				int? num2 = Calculator.EvaluateInt(array[0]);
				int? num3 = Calculator.EvaluateInt(array[1]);
				if (!num2.HasValue || !num3.HasValue)
				{
					continue;
				}
				if (array.Length < 3)
				{
					flag = false;
					if (value >= num2.Value && value <= num3.Value)
					{
						return true;
					}
					continue;
				}
				if (array.Length < 4)
				{
					int? num4 = Calculator.EvaluateInt(array[2]);
					if (!num4.HasValue)
					{
						continue;
					}
					flag = false;
					int num5 = (num3.Value - num2.Value) / num4.Value;
					for (int j = 0; j <= num5; j++)
					{
						if (num2.Value + j * num4.Value == value)
						{
							return true;
						}
					}
					continue;
				}
				if (array[2] == "")
				{
					int? num6 = Calculator.EvaluateInt(array[3].Replace("<value>", num2?.ToString(CultureInfo.InvariantCulture)));
					int? num7 = Calculator.EvaluateInt(array[3].Replace("<value>", num3?.ToString(CultureInfo.InvariantCulture)));
					if (num6.HasValue && num7.HasValue)
					{
						flag = false;
						if (value >= num6.Value && value <= num7.Value)
						{
							return true;
						}
					}
					continue;
				}
				int? num8 = Calculator.EvaluateInt(array[2]);
				if (!num8.HasValue)
				{
					continue;
				}
				flag = false;
				int num9 = (num3.Value - num2.Value) / num8.Value;
				for (int k = 0; k <= num9; k++)
				{
					int? num10 = num2;
					int num11 = k;
					int? num12 = num8;
					int? num13 = Calculator.EvaluateInt(array[3].Replace("<value>", (num10 + num11 * num12)?.ToString(CultureInfo.InvariantCulture)));
					if (num13.HasValue && num13.Value == value)
					{
						return true;
					}
				}
			}
			if (!flag)
			{
				return false;
			}
			return null;
		}
	}
	public class SimpleIntValue(int value) : IIntValue
	{
		private readonly int Value = value;

		public int? Get(Parameters pars)
		{
			return value;
		}

		public bool? Match(Parameters pars, int value)
		{
			return value == value;
		}
	}
	public interface IIntValue
	{
		int? Get(Parameters pars);

		bool? Match(Parameters pars, int value);
	}
	public class LongValue : AnyValue, ILongValue
	{
		public LongValue(string[] values)
			: base(values)
		{
		}

		public long? Get(Parameters pars)
		{
			string value = GetValue(pars);
			if (value == null)
			{
				return null;
			}
			if (!value.Contains(";"))
			{
				return Calculator.EvaluateLong(value);
			}
			string[] array = value.Split(new char[1] { ';' });
			if (array.Length < 2)
			{
				throw new InvalidOperationException("Invalid range format: " + value);
			}
			long? num = Calculator.EvaluateLong(array[0]);
			long? num2 = Calculator.EvaluateLong(array[1]);
			if (!num.HasValue || !num2.HasValue)
			{
				return null;
			}
			long? result;
			if (array.Length < 3 || array[2] == "")
			{
				result = (long)(Random.value * (float)(num2.Value - num.Value) + (float)num.Value);
			}
			else
			{
				long? num3 = Calculator.EvaluateLong(array[2]);
				if (!num3.HasValue)
				{
					result = (long)(Random.value * (float)(num2.Value - num.Value) + (float)num.Value);
				}
				else
				{
					float num4 = Random.Range(0f, (float)(((num2 - num) / num3).Value + 1));
					result = (long?)((float?)num + num4 * (float?)num3);
				}
			}
			if (array.Length < 4)
			{
				return result;
			}
			return Calculator.EvaluateLong(array[3].Replace("<value>", result.ToString()));
		}

		public bool? Match(Parameters pars, long value)
		{
			bool flag = true;
			string[] values = values;
			foreach (string str in values)
			{
				string text = pars.Replace(str);
				if (!text.Contains(";"))
				{
					long? num = Calculator.EvaluateLong(text);
					if (num.HasValue)
					{
						flag = false;
						if (num.Value == value)
						{
							return true;
						}
					}
					continue;
				}
				string[] array = text.Split(new char[1] { ';' });
				if (array.Length < 2)
				{
					throw new InvalidOperationException("Invalid range format: " + text);
				}
				long? num2 = Calculator.EvaluateLong(array[0]);
				long? num3 = Calculator.EvaluateLong(array[1]);
				if (!num2.HasValue || !num3.HasValue)
				{
					continue;
				}
				if (array.Length < 3)
				{
					flag = false;
					if (value >= num2.Value && value <= num3.Value)
					{
						return true;
					}
					continue;
				}
				if (array.Length < 4)
				{
					long? num4 = Calculator.EvaluateLong(array[2]);
					if (!num4.HasValue)
					{
						continue;
					}
					flag = false;
					long num5 = (num3.Value - num2.Value) / num4.Value;
					for (int j = 0; j <= num5; j++)
					{
						if (num2.Value + j * num4.Value == value)
						{
							return true;
						}
					}
					continue;
				}
				if (array[2] == "")
				{
					long? num6 = Calculator.EvaluateLong(array[3].Replace("<value>", num2?.ToString(CultureInfo.InvariantCulture)));
					long? num7 = Calculator.EvaluateLong(array[3].Replace("<value>", num3?.ToString(CultureInfo.InvariantCulture)));
					if (num6.HasValue && num7.HasValue)
					{
						flag = false;
						if (value >= num6.Value && value <= num7.Value)
						{
							return true;
						}
					}
					continue;
				}
				long? num8 = Calculator.EvaluateLong(array[2]);
				if (!num8.HasValue)
				{
					continue;
				}
				flag = false;
				long num9 = (num3.Value - num2.Value) / num8.Value;
				for (int k = 0; k <= num9; k++)
				{
					long? num10 = num2;
					long num11 = k;
					long? num12 = num8;
					long? num13 = Calculator.EvaluateLong(array[3].Replace("<value>", (num10 + num11 * num12)?.ToString(CultureInfo.InvariantCulture)));
					if (num13.HasValue && num13.Value == value)
					{
						return true;
					}
				}
			}
			if (!flag)
			{
				return false;
			}
			return null;
		}
	}
	public class SimpleLongValue(long value) : ILongValue
	{
		private readonly long Value = value;

		public long? Get(Parameters pars)
		{
			return value;
		}

		public bool? Match(Parameters pars, long value)
		{
			return value == value;
		}
	}
	public interface ILongValue
	{
		long? Get(Parameters pars);

		bool? Match(Parameters pars, long value);
	}
	public class PrefabValue : AnyValue, IPrefabValue
	{
		private List<int>? Cache;

		private Parameters? LastParameters;

		public PrefabValue(string[] values)
			: base(values)
		{
		}

		public int? Get(Parameters pars)
		{
			if (pars != LastParameters)
			{
				List<string> allValues = GetAllValues(pars);
				Cache = PrefabHelper.GetPrefabs(allValues);
				LastParameters = pars;
			}
			if (Cache == null || Cache.Count == 0)
			{
				return null;
			}
			if (Cache.Count == 1)
			{
				return Cache[0];
			}
			return Cache[Random.Range(0, Cache.Count)];
		}

		public bool? Match(Parameters pars, int value)
		{
			if (pars != LastParameters)
			{
				List<string> allValues = GetAllValues(pars);
				Cache = PrefabHelper.GetPrefabs(allValues);
				LastParameters = pars;
			}
			if (Cache == null || Cache.Count == 0)
			{
				return null;
			}
			return Cache.Contains(value);
		}
	}
	public class SimplePrefabsValue(List<int> value) : IPrefabValue
	{
		private readonly List<int> Values = value;

		public int? Get(Parameters pars)
		{
			return RollValue();
		}

		public bool? Match(Parameters pars, int value)
		{
			return value.Contains(value);
		}

		private int RollValue()
		{
			return value[Random.Range(0, value.Count)];
		}
	}
	public class SimplePrefabValue(int? value) : IPrefabValue
	{
		private readonly int? Value = value;

		public int? Get(Parameters pars)
		{
			return value;
		}

		public bool? Match(Parameters pars, int value)
		{
			return value == value;
		}
	}
	public interface IPrefabValue
	{
		int? Get(Parameters pars);

		bool? Match(Parameters pars, int value);
	}
	public class QuaternionValue : AnyValue, IQuaternionValue
	{
		public QuaternionValue(string[] values)
			: base(values)
		{
		}

		public Quaternion? Get(Parameters pars)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			string value = GetValue(pars);
			if (value != null)
			{
				return Calculator.EvaluateQuaternion(value);
			}
			return null;
		}

		public bool? Match(Parameters pars, Quaternion value)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			List<string> allValues = GetAllValues(pars);
			if (allValues.Count == 0)
			{
				return null;
			}
			return allValues.Any(delegate(string v)
			{
				//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)
				//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)
				Quaternion? val = Parse.AngleYXZNull(v);
				Quaternion val2 = value;
				return val.HasValue && val.GetValueOrDefault() == val2;
			});
		}
	}
	public class SimpleQuaternionValue(Quaternion value) : IQuaternionValue
	{
		private readonly Quaternion Value = value;

		public Quaternion? Get(Parameters pars)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return value;
		}

		public bool? Match(Parameters pars, Quaternion 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)
			return value == value;
		}
	}
	public interface IQuaternionValue
	{
		Quaternion? Get(Parameters pars);

		bool? Match(Parameters pars, Quaternion value);
	}
	public class StringValue : AnyValue, IStringValue
	{
		private readonly bool IsPattern = values.Any((string v) => v.Contains("*"));

		public StringValue(string[] values)
			: base(values)
		{
		}

		public string? Get(Parameters pars)
		{
			return GetValue(pars);
		}

		public bool? Match(Parameters pars, string value)
		{
			List<string> allValues = GetAllValues(pars);
			if (allValues.Count == 0)
			{
				return null;
			}
			return IsPattern ? allValues.Any((string v) => SimpleStringValue.PatternMatch(value, v)) : allValues.Contains(value);
		}
	}
	public class SimpleStringValue(string value) : IStringValue
	{
		private readonly string Value = value;

		private readonly bool IsPattern = value.Contains("*");

		public string? Get(Parameters pars)
		{
			return value;
		}

		public bool? Match(Parameters pars, string value)
		{
			return IsPattern ? PatternMatch(value, value) : (value == value);
		}

		public static bool PatternMatch(string value, string pattern)
		{
			if (value == pattern)
			{
				return true;
			}
			if (pattern == "")
			{
				return false;
			}
			if (pattern[0] == '*' && pattern[pattern.Length - 1] == '*')
			{
				return value.Contains(pattern.Substring(1, pattern.Length - 2));
			}
			if (pattern[0] == '*')
			{
				return value.EndsWith(pattern.Substring(1), StringComparison.Ordinal);
			}
			if (pattern[pattern.Length - 1] == '*')
			{
				return value.StartsWith(pattern.Substring(0, pattern.Length - 1), StringComparison.Ordinal);
			}
			return false;
		}
	}
	public interface IStringValue
	{
		string? Get(Parameters pars);

		bool? Match(Parameters pars, string value);
	}
	public class Vector3Value : AnyValue, IVector3Value
	{
		public Vector3Value(string[] values)
			: base(values)
		{
		}

		public Vector3? Get(Parameters pars)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			string value = GetValue(pars);
			if (value != null)
			{
				return Calculator.EvaluateVector3(value);
			}
			return null;
		}

		public bool? Match(Parameters pars, Vector3 value)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			List<string> allValues = GetAllValues(pars);
			if (allValues.Count == 0)
			{
				return null;
			}
			return allValues.Any(delegate(string v)
			{
				//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)
				//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)
				Vector3? val = Parse.VectorXZYNull(v);
				Vector3 val2 = value;
				return val.HasValue && val.GetValueOrDefault() == val2;
			});
		}
	}
	public class SimpleVector3Value(Vector3 value) : IVector3Value
	{
		private readonly Vector3 Value = value;

		public Vector3? Get(Parameters pars)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return value;
		}

		public bool? Match(Parameters pars, Vector3 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)
			return value == value;
		}
	}
	public interface IVector3Value
	{
		Vector3? Get(Parameters pars);

		bool? Match(Parameters pars, Vector3 value);
	}
	public class ZdoIdValue : AnyValue, IZdoIdValue
	{
		public ZdoIdValue(string[] values)
			: base(values)
		{
		}

		public ZDOID? Get(Parameters pars)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			string value = GetValue(pars);
			if (value == null)
			{
				return null;
			}
			return Parse.ZdoId(value);
		}

		public bool? Match(Parameters pars, ZDOID value)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			List<string> allValues = GetAllValues(pars);
			if (allValues.Count == 0)
			{
				return null;
			}
			return allValues.Any((string v) => Parse.ZdoId(v) == value);
		}
	}
	public class SimpleZdoIdValue(ZDOID value) : IZdoIdValue
	{
		private readonly ZDOID Value = value;

		public ZDOID? Get(Parameters pars)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return value;
		}

		public bool? Match(Parameters pars, ZDOID 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)
			return value == value;
		}
	}
	public interface IZdoIdValue
	{
		ZDOID? Get(Parameters pars);

		bool? Match(Parameters pars, ZDOID value);
	}
}
namespace Service
{
	public class ConfigWrapper
	{
		private readonly ConfigFile ConfigFile;

		private readonly ConfigSync ConfigSync;

		private readonly Action Regenerate;

		public static Dictionary<ConfigEntry<string>, float> Floats = new Dictionary<ConfigEntry<string>, float>();

		public static Dictionary<ConfigEntry<string>, int?> Ints = new Dictionary<ConfigEntry<string>, int?>();

		public static Dictionary<ConfigEntry<int>, float> Amounts = new Dictionary<ConfigEntry<int>, float>();

		private readonly Dictionary<string, Action<Terminal, string>> SettingHandlers = new Dictionary<string, Action<Terminal, string>>();

		private static readonly HashSet<string> Truthies = new HashSet<string> { "1", "true", "yes", "on" };

		private static readonly HashSet<string> Falsies = new HashSet<string> { "0", "false", "no", "off" };

		public ConfigWrapper(string command, ConfigFile configFile, ConfigSync configSync, Action regenerate)
		{
			//IL_004d: 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_006b: Expected O, but got Unknown
			//IL_006b: Expected O, but got Unknown
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			ConfigWrapper configWrapper = this;
			ConfigFile = configFile;
			ConfigSync = configSync;
			Regenerate = regenerate;
			new ConsoleCommand(command, "[key] [value] - Toggles or sets a config value.", (ConsoleEvent)delegate(ConsoleEventArgs args)
			{
				Action<Terminal, string> value;
				if (configSync.IsLocked && !configSync.IsAdmin)
				{
					args.Context.AddString("Error: Unable to edit locked config.");
				}
				else if (args.Length < 2)
				{
					args.Context.AddString("Error: Missing the key.");
				}
				else if (!configWrapper.SettingHandlers.TryGetValue(args[1].ToLowerInvariant(), out value))
				{
					args.Context.AddString("Error: Key not found.");
				}
				else if (args.Length == 2)
				{
					value(args.Context, "");
				}
				else
				{
					value(args.Context, string.Join(" ", args.Args.Skip(2)));
				}
			}, false, false, false, false, false, (ConsoleOptionsFetcher)(() => configWrapper.SettingHandlers.Keys.ToList()), false, false, false);
		}

		public CustomSyncedValue<string> AddValue(string identifier)
		{
			return new CustomSyncedValue<string>(ConfigSync, identifier);
		}

		public ConfigEntry<bool> BindLocking(string group, string name, bool value, ConfigDescription description)
		{
			ConfigEntry<bool> val = ConfigFile.Bind<bool>(group, name, value, description);
			Register(val);
			ConfigSync.AddLockingConfigEntry<bool>(val).SynchronizedConfig = true;
			return val;
		}

		public ConfigEntry<bool> BindLocking(string group, string name, bool value, string description)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Expected O, but got Unknown
			return BindLocking(group, name, value, new ConfigDescription(description, (AcceptableValueBase)null, Array.Empty<object>()));
		}

		public ConfigEntry<T> Bind<T>(string group, string name, T value, bool automaticRegenerate, ConfigDescription description, bool synchronizedSetting = true)
		{
			ConfigEntry<T> val = ConfigFile.Bind<T>(group, name, value, description);
			if (automaticRegenerate)
			{
				val.SettingChanged += ForceRegen;
			}
			if (val is ConfigEntry<bool> setting)
			{
				Register(setting);
			}
			else
			{
				if (!(val is ConfigEntry<string> setting2))
				{
					throw new NotImplementedException("Config type not implemented for " + name + ".");
				}
				Register(setting2);
			}
			ConfigSync.AddConfigEntry<T>(val).SynchronizedConfig = synchronizedSetting;
			return val;
		}

		public ConfigEntry<T> Bind<T>(string group, string name, T value, bool forceRegen, string description = "", bool synchronizedSetting = true)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Expected O, but got Unknown
			return Bind(group, name, value, forceRegen, new ConfigDescription(description, (AcceptableValueBase)null, Array.Empty<object>()), synchronizedSetting);
		}

		private void ForceRegen(object e, EventArgs s)
		{
			Regenerate();
		}

		public ConfigEntry<string> BindFloat(string group, string name, float value, bool forceRegen, string description = "", bool synchronizedSetting = true)
		{
			ConfigEntry<string> entry = Bind(group, name, value.ToString(NumberFormatInfo.InvariantInfo), forceRegen, description, synchronizedSetting);
			entry.SettingChanged += delegate
			{
				Floats[entry] = TryParseFloat(entry);
			};
			Floats[entry] = TryParseFloat(entry);
			return entry;
		}

		public ConfigEntry<string> BindInt(string group, string name, int? value, bool forceRegen, string description = "", bool synchronizedSetting = true)
		{
			ConfigEntry<string> entry = Bind(group, name, value.HasValue ? value.ToString() : "", forceRegen, description, synchronizedSetting);
			entry.SettingChanged += delegate
			{
				Ints[entry] = TryParseInt(entry);
			};
			Ints[entry] = TryParseInt(entry);
			return entry;
		}

		private static void AddMessage(Terminal context, string message)
		{
			context.AddString(message);
			Player localPlayer = Player.m_localPlayer;
			if (localPlayer != null)
			{
				((Character)localPlayer).Message((MessageType)1, message, 0, (Sprite)null);
			}
		}

		private string ToKey(string name)
		{
			return name.ToLowerInvariant().Replace(' ', '_').Replace("(", "")
				.Replace(")", "");
		}

		private void Register(ConfigEntry<bool> setting)
		{
			string name = ((ConfigEntryBase)setting).Definition.Key;
			string key = ToKey(name);
			SettingHandlers.Add(key, delegate(Terminal terminal, string value)
			{
				Toggle(terminal, setting, name, value);
			});
		}

		private void Register(ConfigEntry<string> setting)
		{
			string name = ((ConfigEntryBase)setting).Definition.Key;
			string key = ToKey(name);
			SettingHandlers.Add(key, delegate(Terminal terminal, string value)
			{
				SetValue(terminal, setting, name, value);
			});
		}

		private static string State(bool value)
		{
			if (!value)
			{
				return "disabled";
			}
			return "enabled";
		}

		private static bool IsTruthy(string value)
		{
			return Truthies.Contains(value);
		}

		private static bool IsFalsy(string value)
		{
			return Falsies.Contains(value);
		}

		private static void Toggle(Terminal context, ConfigEntry<bool> setting, string name, string value)
		{
			if (value == "")
			{
				setting.Value = !setting.Value;
			}
			else if (IsTruthy(value))
			{
				setting.Value = true;
			}
			else if (IsFalsy(value))
			{
				setting.Value = false;
			}
			AddMessage(context, name + " " + State(setting.Value) + ".");
		}

		private static int? TryParseInt(ConfigEntry<string> setting)
		{
			if (int.TryParse(setting.Value, NumberStyles.Integer, CultureInfo.InvariantCulture, out var result))
			{
				return result;
			}
			return null;
		}

		private static float TryParseFloat(string value, float defaultValue)
		{
			if (float.TryParse(value, NumberStyles.Float, CultureInfo.InvariantCulture, out var result))
			{
				return result;
			}
			return defaultValue;
		}

		private static float TryParseFloat(ConfigEntry<string> setting)
		{
			if (float.TryParse(setting.Value, NumberStyles.Float, CultureInfo.InvariantCulture, out var result))
			{
				return result;
			}
			return TryParseFloat((string)((ConfigEntryBase)setting).DefaultValue, 0f);
		}

		private static void SetValue(Terminal context, ConfigEntry<string> setting, string name, string value)
		{
			if (value == "")
			{
				AddMessage(context, name + ": " + setting.Value + ".");
				return;
			}
			setting.Value = value;
			AddMessage(context, name + " set to " + value + ".");
		}
	}
	public class AssetTracker
	{
		private static readonly Dictionary<string, string> PrefabToBundleMapping = new Dictionary<string, string>();

		private static readonly Dictionary<string, string> BundleToModMapping = new Dictionary<string, string>();

		internal static void MapPrefabsToBundles()
		{
			foreach (AssetBundle allLoadedAssetBundle in AssetBundle.GetAllLoadedAssetBundles())
			{
				foreach (string item in from name in allLoadedAssetBundle.GetAllAssetNames()
					where name.EndsWith(".prefab")
					select name)
				{
					string fileNameWithoutExtension = Path.GetFileNameWithoutExtension(item);
					PrefabToBundleMapping[fileNameWithoutExtension] = ((Object)allLoadedAssetBundle).name;
				}
			}
		}

		internal static void MapBundlesToMods()
		{
			_ = Chainloader.PluginInfos.Values;
			Dictionary<string, string[]> source = Chainloader.PluginInfos.ToDictionary((KeyValuePair<string, PluginInfo> kvp) => kvp.Value.Metadata.Name, delegate(KeyValuePair<string, PluginInfo> kvp)
			{
				try
				{
					return ((object)kvp.Value.Instance).GetType().Assembly.GetManifestResourceNames();
				}
				catch
				{
					return Array.Empty<string>();
				}
			});
			foreach (string bundleName in PrefabToBundleMapping.Values.Distinct())
			{
				KeyValuePair<string, string[]> keyValuePair = source.FirstOrDefault((KeyValuePair<string, string[]> kvp) => kvp.Value.Any((string name) => name.EndsWith(bundleName, StringComparison.OrdinalIgnoreCase)));
				if (keyValuePair.Key != null)
				{
					BundleToModMapping[bundleName] = keyValuePair.Key;
				}
			}
		}

		public static string GetModFromPrefab(string prefabName)
		{
			if (PrefabToBundleMapping.Count == 0)
			{
				MapPrefabsToBundles();
				MapBundlesToMods();
			}
			if (PrefabToBundleMapping.TryGetValue(prefabName.ToLowerInvariant(), out string value) && BundleToModMapping.TryGetValue(value, out string value2))
			{
				return value2;
			}
			return "Valheim";
		}

		public static string GetFileNameFromMod(string modName)
		{
			if (modName == "" || modName == "Valheim")
			{
				return "";
			}
			return "_" + modName.Replace(" ", "_").ToLowerInvariant();
		}

		public static string GetBundleForPrefab(string prefabName)
		{
			if (!PrefabToBundleMapping.TryGetValue(prefabName, out string value))
			{
				return "";
			}
			return value;
		}
	}
	public class PlayerInfo
	{
		public string Name;

		public Vector3 Pos;

		public Quaternion Rot;

		public long Character;

		public string HostId;

		public ZDOID ZDOID;

		public long PeerId;

		public PlayerInfo(ZNetPeer peer)
		{
			//IL_002a: 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_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: 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_0075: 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_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)
			HostId = peer.m_rpc.GetSocket().GetHostName();
			Name = peer.m_playerName;
			Pos = peer.m_refPos;
			ZDOID = peer.m_characterID;
			PeerId = peer.m_uid;
			ZDO zDO = ZDOMan.instance.GetZDO(peer.m_characterID);
			if (zDO != null)
			{
				Character = zDO.GetLong(ZDOVars.s_playerID, 0L);
				Pos = zDO.m_position;
				Rot = zDO.GetRotation();
			}
		}

		public PlayerInfo(Player player)
		{
			//IL_001f: 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_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: 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)
			HostId = "self";
			Name = player.GetPlayerName();
			ZDOID = ((Character)player).GetZDOID();
			Character = player.GetPlayerID();
			Pos = ((Component)player).transform.position;
			Rot = ((Component)player).transform.rotation;
			PeerId = ZRoutedRpc.instance.m_id;
		}
	}
	public class CommandManager
	{
		public static void Run(IEnumerable<string> commands)
		{
			Run(commands, (PlayerInfo?)null);
		}

		public static void Run(IEnumerable<string> commands, PlayerInfo? player)
		{
			string[] array = commands.Select((string c) => Parse(c, player)).ToArray();
			foreach (string text in array)
			{
				try
				{
					((Terminal)Console.instance).TryRunCommand(text, false, false);
				}
				catch (Exception ex)
				{
					Log.Error("Failed to run command: " + text + "\n" + ex.Message);
				}
			}
		}

		public static void Run(IEnumerable<string> commands, List<PlayerInfo> players)
		{
			foreach (PlayerInfo player in players)
			{
				Run(commands, player);
			}
		}

		private static string Parse(string command, PlayerInfo? player)
		{
			string text = command;
			if (player != null)
			{
				text = text.Replace("<px>", player.Pos.x.ToString("0.#####", NumberFormatInfo.InvariantInfo)).Replace("<py>", player.Pos.y.ToString("0.#####", NumberFormatInfo.InvariantInfo)).Replace("<pz>", player.Pos.z.ToString("0.#####", NumberFormatInfo.InvariantInfo))
					.Replace("<pname>", player.Name)
					.Replace("<pid>", player.HostId)
					.Replace("<pchar>", player.Character.ToString());
			}
			string[] array = (from s in text.Split(new char[1] { ' ' })
				select s.Split(new char[1] { '=' }) into a
				select a[^1].Trim()).SelectMany((string s) => s.Split(new char[1] { ',' })).ToArray();
			foreach (string text2 in array)
			{
				if (text2.Length != 0)
				{
					string source = text2.Substring(1);
					if (Enumerable.Contains(source, '*') || Enumerable.Contains(source, '/') || Enumerable.Contains(source, '+') || Enumerable.Contains(source, '-'))
					{
						text = text.Replace(text2, Calculator.EvaluateFloat(text2).GetValueOrDefault().ToString("0.#####", NumberFormatInfo.InvariantInfo));
					}
				}
			}
			return text;
		}
	}
	public class Log
	{
		private static ManualLogSource Logger;

		public static void Init(ManualLogSource logger)
		{
			Logger = logger;
		}

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

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

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

		public static void Debug(string message)
		{
			Logger.LogDebug((object)message);
		}
	}
	public class Range<T>
	{
		public T Min;

		public T Max;

		public bool Uniform = true;

		public Range(T value)
		{
			Min = value;
			Max = value;
		}

		public Range(T min, T max)
		{
			Min = min;
			Max = max;
		}
	}
	public static class Parse
	{
		public static List<string> ToList(string str, bool removeEmpty = true)
		{
			string[] array = Split(str, removeEmpty);
			List<string> list = new List<string>(array.Length);
			list.AddRange(array);
			return list;
		}

		public static Vector2i Vector2Int(string arg)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			string[] array = SplitWithEmpty(arg);
			return new Vector2i(Int(array[0]), (array.Length > 1) ? Int(array[1]) : 0);
		}

		public static int Int(string arg, int defaultValue = 0)
		{
			if (!TryInt(arg, out var result))
			{
				return defaultValue;
			}
			return result;
		}

		public static uint UInt(string arg, uint defaultValue = 0u)
		{
			if (!TryUInt(arg, out var result))
			{
				return defaultValue;
			}
			return result;
		}

		public static long Long(string arg, long defaultValue = 0L)
		{
			if (!long.TryParse(arg, NumberStyles.Integer, CultureInfo.InvariantCulture, out var result))
			{
				return defaultValue;
			}
			return result;
		}

		public static bool TryLong(string arg, out long result)
		{
			return long.TryParse(arg, NumberStyles.Integer, CultureInfo.InvariantCulture, out result);
		}

		public static int Int(string[] args, int index, int defaultValue = 0)
		{
			if (args.Length <= index)
			{
				return defaultValue;
			}
			return Int(args[index], defaultValue);
		}

		public static bool TryUInt(string arg, out uint result)
		{
			return uint.TryParse(arg, NumberStyles.Integer, CultureInfo.InvariantCulture, out result);
		}

		public static bool TryInt(string arg, out int result)
		{
			return int.TryParse(arg, NumberStyles.Integer, CultureInfo.InvariantCulture, out result);
		}

		public static float Float(string arg, float defaultValue = 0f)
		{
			if (!TryFloat(arg, out var result))
			{
				return defaultValue;
			}
			return result;
		}

		public static float Float(string[] args, int index, float defaultValue = 0f)
		{
			if (args.Length <= index)
			{
				return defaultValue;
			}
			return Float(args[index], defaultValue);
		}

		public static bool TryFloat(string arg, out float result)
		{
			return float.TryParse(arg, NumberStyles.Float, CultureInfo.InvariantCulture, out result);
		}

		public static Quaternion AngleYXZ(string arg)
		{
			//IL_000a: 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)
			return AngleYXZ(Split(arg), 0, Vector3.zero);
		}

		public static Quaternion AngleYXZ(string[] args, int index)
		{
			//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)
			return AngleYXZ(args, index, Vector3.zero);
		}

		public static Quaternion AngleYXZ(string[] args, int index, Vector3 defaultValue)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: 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_0036: 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)
			Vector3 zero = Vector3.zero;
			zero.y = Float(args, index, defaultValue.y);
			zero.x = Float(args, index + 1, defaultValue.x);
			zero.z = Float(args, index + 2, defaultValue.z);
			return Quaternion.Euler(zero);
		}

		public static string[] Split(string arg, bool removeEmpty = true, char split = ',')
		{
			return (from s in arg.Split(new char[1] { split })
				select s.Trim() into s
				where !removeEmpty || s != ""
				select s).ToArray();
		}

		public static KeyValuePair<string, string> Kvp(string str, char separator = ',')
		{
			string[] array = str.Split(new char[1] { separator }, 2);
			if (array.Length < 2)
			{
				return new KeyValuePair<string, string>(array[0], "");
			}
			return new KeyValuePair<string, string>(array[0], array[1].Trim());
		}

		public static string[] SplitWithEmpty(string arg, char split = ',')
		{
			return (from s in arg.Split(new char[1] { split })
				select s.Trim()).ToArray();
		}

		public static string[] SplitWithEscape(string arg, char separator = ',')
		{
			List<string> list = new List<string>();
			string[] array = arg.Split(new char[1] { separator });
			for (int i = 0; i < array.Length; i++)
			{
				string text = array[i].TrimStart(Array.Empty<char>());
				if (text.StartsWith("\""))
				{
					array[i] = text.Substring(1);
					int j;
					for (j = i; j < array.Length; j++)
					{
						text = array[j].TrimEnd(Array.Empty<char>());
						if (text.EndsWith("\""))
						{
							array[j] = text.Substring(0, text.Length - 1);
							break;
						}
					}
					list.Add(string.Join(separator.ToString(), array.Skip(i).Take(j - i + 1)));
					i = j;
				}
				else
				{
					list.Add(array[i].Trim());
				}
			}
			return list.ToArray();
		}

		public static string Name(string arg)
		{
			return arg.Split(new char[1] { ':' })[0];
		}

		public static Vector3 VectorXZY(string arg)
		{
			//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 VectorXZY(arg, Vector3.zero);
		}

		public static Vector3 VectorXZY(string arg, Vector3 defaultValue)
		{
			//IL_000a: 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)
			return VectorXZY(Split(arg), 0, defaultValue);
		}

		public static Vector3 VectorXZY(string[] args, int index)
		{
			//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)
			return VectorXZY(args, index, Vector3.zero);
		}

		public static Vector3 VectorXZY(string[] args, int index, Vector3 defaultValue)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: 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_0036: 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)
			Vector3 zero = Vector3.zero;
			zero.x = Float(args, index, defaultValue.x);
			zero.z = Float(args, index + 1, defaultValue.z);
			zero.y = Float(args, index + 2, defaultValue.y);
			return zero;
		}

		public static Vector2 VectorXY(string arg)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			Vector2 zero = Vector2.zero;
			string[] args = Split(arg);
			zero.x = Float(args, 0);
			zero.y = Float(args, 1);
			return zero;
		}

		public static Vector3 Scale(string args)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			return Scale(Split(args), 0);
		}

		public static Vector3 Scale(string[] args)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			return Scale(args, 0);
		}

		public static Vector3 Scale(string[] args, int index)
		{
			//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)
			return SanityCheck(VectorXZY(args, index));
		}

		private static Vector3 SanityCheck(Vector3 scale)
		{
			//IL_0000: 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_0033: 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)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			if (scale.x == 0f)
			{
				scale.x = 1f;
			}
			if (scale.y == 0f)
			{
				scale.y = scale.x;
			}
			if (scale.z == 0f)
			{
				scale.z = scale.x;
			}
			return scale;
		}

		public static Range<string> StringRange(string arg)
		{
			List<string> list = arg.Split(new char[1] { '-' }).ToList();
			if (list.Count > 1 && list[0] == "")
			{
				list[0] = "-" + list[1];
				list.RemoveAt(1);
			}
			if (list.Count > 2 && list[1] == "")
			{
				list[1] = "-" + list[2];
				list.RemoveAt(2);
			}
			if (list.Count == 1)
			{
				return new Range<string>(list[0]);
			}
			return new Range<string>(list[0], list[1]);
		}

		public static Range<int> IntRange(string arg)
		{
			Range<string> range = StringRange(arg);
			return new Range<int>(Int(range.Min), Int(range.Max));
		}

		public static Range<float> FloatRange(string arg)
		{
			Range<string> range = StringRange(arg);
			return new Range<float>(Float(range.Min), Float(range.Max));
		}

		public static Range<long> LongRange(string arg)
		{
			Range<string> range = StringRange(arg);
			return new Range<long>(Long(range.Min, 0L), Long(range.Max, 0L));
		}

		public static int? IntNull(string arg)
		{
			if (int.TryParse(arg, NumberStyles.Integer, CultureInfo.InvariantCulture, out var result))
			{
				return result;
			}
			return null;
		}

		public static int? IntNull(string[] args, int index)
		{
			if (args.Length <= index)
			{
				return null;
			}
			return IntNull(args[index]);
		}

		public static float? FloatNull(string arg)
		{
			if (float.TryParse(arg, NumberStyles.Float, CultureInfo.InvariantCulture, out var result))
			{
				return result;
			}
			return null;
		}

		public static float? FloatNull(string[] args, int index)
		{
			if (args.Length <= index)
			{
				return null;
			}
			return FloatNull(args[index]);
		}

		public static long? LongNull(string[] args, int index)
		{
			if (args.Length <= index)
			{
				return null;
			}
			return LongNull(args[index]);
		}

		public static long? LongNull(string arg)
		{
			if (long.TryParse(arg, NumberStyles.Integer, CultureInfo.InvariantCulture, out var result))
			{
				return result;
			}
			return null;
		}

		public static Vector3? VectorXZYNull(string? arg)
		{
			if (arg != null)
			{
				return VectorXZYNull(Split(arg));
			}
			return null;
		}

		public static Vector3? VectorXZYNull(string[] args)
		{
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			float? num = FloatNull(args, 0);
			float? num2 = FloatNull(args, 2);
			float? num3 = FloatNull(args, 1);
			if (!num.HasValue || !num2.HasValue || !num3.HasValue)
			{
				return null;
			}
			return new Vector3(num.Value, num2.Value, num3.Value);
		}

		public static Quaternion? AngleYXZNull(string? arg)
		{
			if (arg != null)
			{
				return AngleYXZNull(Split(arg));
			}
			return null;
		}

		public static Quaternion? AngleYXZNull(string[] values)
		{
			//IL_0052: 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)
			float? num = FloatNull(values, 0);
			float? num2 = FloatNull(values, 1);
			float? num3 = FloatNull(values, 2);
			if (!num.HasValue || !num2.HasValue || !num3.HasValue)
			{
				return null;
			}
			return Quaternion.Euler(new Vector3(num2.Value, num.Value, num3.Value));
		}

		public static string String(string[] args, int index)
		{
			if (args.Length <= index)
			{
				return "";
			}
			return args[index];
		}

		public static int Hash(string[] args, int index)
		{
			if (args.Length <= index)
			{
				return 0;
			}
			return StringExtensionMethods.GetStableHashCode(args[index]);
		}

		public static bool Boolean(string[] args, int index)
		{
			if (args.Length > index)
			{
				return Boolean(args[index]);
			}
			return false;
		}

		public static bool Boolean(string arg)
		{
			return arg.ToLowerInvariant() == "true";
		}

		public static bool BooleanTrue(string arg)
		{
			return arg.ToLowerInvariant() == "false";
		}

		public static ZDOID ZdoId(string arg)
		{
			//IL_0029: 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)
			string[] array = Split(arg, removeEmpty: true, ':');
			if (array.Length < 2)
			{
				return ZDOID.None;
			}
			return new ZDOID(Long(array[0], 0L), UInt(array[1]));
		}

		public static HitData Hit(ZDO? zdo, string arg)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: 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: Expected O, but got Unknown
			//IL_026d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0272: Unknown result type (might be due to invalid IL or missing references)
			//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_02ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_036d: Unknown result type (might be due to invalid IL or missing references)
			//IL_036f: Unknown result type (might be due to invalid IL or missing references)
			HitData val = new HitData
			{
				m_point = (zdo?.m_position ?? Vector3.zero)
			};
			string[] array = Split(arg, removeEmpty: true, ' ');
			for (int i = 0; i < array.Length; i++)
			{
				KeyValuePair<string, string> keyValuePair = Kvp(array[i], '=');
				string key = keyValuePair.Key;
				string value = keyValuePair.Value;
				if (key == "damage")
				{
					val.m_damage.m_damage = Int(value);
				}
				if (key == "blunt")
				{
					val.m_damage.m_blunt = Int(value);
				}
				if (key == "slash")
				{
					val.m_damage.m_slash = Int(value);
				}
				if (key == "pierce")
				{
					val.m_damage.m_pierce = Int(value);
				}
				if (key == "chop")
				{
					val.m_damage.m_chop = Int(value);
				}
				if (key == "pickaxe")
				{
					val.m_damage.m_pickaxe = Int(value);
				}
				if (key == "fire")
				{
					val.m_damage.m_fire = Int(value);
				}
				if (key == "frost")
				{
					val.m_damage.m_frost = Int(value);
				}
				if (key == "lightning")
				{
					val.m_damage.m_lightning = Int(value);
				}
				if (key == "poison")
				{
					val.m_damage.m_poison = Int(value);
				}
				if (key == "spirit")
				{
					val.m_damage.m_spirit = Int(value);
				}
				if (key == "tier")
				{
					val.m_toolTier = (short)Int(value);
				}
				if (key == "force")
				{
					val.m_pushForce = Float(value);
				}
				if (key == "backstab")
				{
					val.m_backstabBonus = Float(value);
				}
				if (key == "stagger")
				{
					val.m_staggerMultiplier = Int(value);
				}
				if (key == "dodge")
				{
					val.m_dodgeable = Boolean(value);
				}
				if (key == "block")
				{
					val.m_blockable = Boolean(value);
				}
				if (key == "dir")
				{
					val.m_dir = VectorXZY(value);
				}
				if (key == "ranged")
				{
					val.m_ranged = Boolean(value);
				}
				if (key == "pvp")
				{
					val.m_ignorePVP = Boolean(value);
				}
				if (key == "pos")
				{
					val.m_point = VectorXZY(value);
				}
				if (key == "status")
				{
					val.m_statusEffectHash = StringExtensionMethods.GetStableHashCode(value);
				}
				if (key == "attacker")
				{
					val.m_attacker = ZdoId(value);
				}
				if (key == "skill")
				{
					val.m_skillLevel = Float(value);
				}
				if (key == "level")
				{
					val.m_itemLevel = (short)Int(value);
				}
				if (key == "world")
				{
					val.m_itemWorldLevel = (byte)Int(value);
				}
				if (key == "type")
				{
					val.m_hitType = (HitType)(Enum.TryParse<HitType>(value, ignoreCase: true, out HitType result) ? ((int)result) : 0);
				}
				if (key == "spot")
				{
					val.m_weakSpot = (short)Int(value);
				}
			}
			return val;
		}

		public static int EnumMessage(string arg)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Expected I4, but got Unknown
			if (!Enum.TryParse<MessageType>(arg, ignoreCase: true, out MessageType result))
			{
				return Int(arg, 2);
			}
			return (int)result;
		}

		public static int EnumReason(string arg)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Expected I4, but got Unknown
			if (!Enum.TryParse<AggravatedReason>(arg, ignoreCase: true, out AggravatedReason result))
			{
				return Int(arg);
			}
			return (int)result;
		}

		public static int EnumTrap(string arg)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Expected I4, but got Unknown
			if (!Enum.TryParse<TrapState>(arg, ignoreCase: true, out TrapState result))
			{
				return Int(arg);
			}
			return (int)result;
		}

		public static int EnumDamageText(string arg)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Expected I4, but got Unknown
			if (!Enum.TryParse<TextType>(arg, ignoreCase: true, out TextType result))
			{
				return Int(arg);
			}
			return (int)result;
		}

		public static int EnumTerrainPaint(string arg)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Expected I4, but got Unknown
			if (!Enum.TryParse<PaintType>(arg, ignoreCase: true, out PaintType result))
			{
				return Int(arg);
			}
			return (int)result;
		}
	}
	public class Yaml
	{
		public static string BaseDirectory = Path.Combine(Paths.ConfigPath, "expand_world");

		public static string Directory = BaseDirectory;

		public static string BackupDirectory = Path.Combine(Paths.ConfigPath, "expand_world_backups");

		private static readonly YamlFormatter formatter = new YamlFormatter
		{
			NumberFormat = NumberFormatInfo.InvariantInfo
		};

		public static List<T> Read<T>(string pattern)
		{
			if (!System.IO.Directory.Exists(BaseDirectory))
			{
				System.IO.Directory.CreateDirectory(BaseDirectory);
			}
			return Read<T>(System.IO.Directory.GetFiles(BaseDirectory, pattern, SearchOption.AllDirectories).Reverse().ToList());
		}

		public static List<T> Read<T>(List<string> files)
		{
			List<T> list = new List<T>();
			foreach (string file in files)
			{
				try
				{
					string raw = File.ReadAllText(file);
					list.AddRange(Deserialize<T>(raw, file));
				}
				catch (Exception ex)
				{
					Log.Error("Error reading " + Path.GetFileName(file) + ": " + ex.Message);
				}
			}
			return list;
		}

		public static Biome ToBiomes(string biomeStr)
		{
			//IL_0001: 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_0074: 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_0077: 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_002d: 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_0086: 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_008a: Unknown result type (might be due to invalid IL or missing references)
			Biome val = (Biome)0;
			if (biomeStr == "")
			{
				foreach (object value in Enum.GetValues(typeof(Biome)))
				{
					val = (Biome)(val | (Biome)value);
				}
			}
			else
			{
				string[] array = Parse.Split(biomeStr);
				foreach (string text in array)
				{
					if (Enum.TryParse<Biome>(text, ignoreCase: true, out Biome result))
					{
						val |= result;
						continue;
					}
					if (int.TryParse(text, out var result2))
					{
						val = (Biome)(val + result2);
						continue;
					}
					throw new InvalidOperationException("Invalid biome " + text + ".");
				}
			}
			return val;
		}

		public static void SetupWatcher(ConfigFile config)
		{
			FileSystemWatcher fileSystemWatcher = new FileSystemWatcher(Path.GetDirectoryName(config.ConfigFilePath), Path.GetFileName(config.ConfigFilePath));
			fileSystemWatcher.Changed += delegate(object s, FileSystemEventArgs e)
			{
				ReadConfigValues(e.FullPath, config);
			};
			fileSystemWatcher.Created += delegate(object s, FileSystemEventArgs e)
			{
				ReadConfigValues(e.FullPath, config);
			};
			fileSystemWatcher.Renamed += delegate(object s, RenamedEventArgs e)
			{
				ReadConfigValues(e.FullPath, config);
			};
			fileSystemWatcher.IncludeSubdirectories = true;
			fileSystemWatcher.SynchronizingObject = ThreadingHelper.SynchronizingObject;
			fileSystemWatcher.EnableRaisingEvents = true;
		}

		private static void ReadConfigValues(string path, ConfigFile config)
		{
			if (!File.Exists(path))
			{
				return;
			}
			BackupFile(path);
			try
			{
				config.Reload();
			}
			catch
			{
				Log.Error("There was an issue loading your " + config.ConfigFilePath);
				Log.Error("Please check your config entries for spelling and format!");
			}
		}

		public static void SetupWatcher(string pattern, Action<string> action)
		{
			SetupWatcher(Paths.ConfigPath, pattern, action);
		}

		public static void SetupWatcher(string folder, string pattern, Action<string> action)
		{
			FileSystemWatcher fileSystemWatcher = new FileSystemWatcher(folder, pattern);
			fileSystemWatcher.Created += delegate(object s, FileSystemEventArgs e)
			{
				action(e.FullPath);
			};
			fileSystemWatcher.Changed += delegate(object s, FileSystemEventArgs e)
			{
				action(e.FullPath);
			};
			fileSystemWatcher.Renamed += delegate(object s, RenamedEventArgs e)
			{
				action(e.FullPath);
			};
			fileSystemWatcher.Deleted += delegate(object s, FileSystemEventArgs e)
			{
				action(e.FullPath);
			};
			fileSystemWatcher.IncludeSubdirectories = true;
			fileSystemWatcher.SynchronizingObject = ThreadingHelper.SynchronizingObject;
			fileSystemWatcher.EnableRaisingEvents = true;
		}

		public static void SetupWatcher(string folder, string pattern, Action action)
		{
			FileSystemWatcher fileSystemWatcher = new FileSystemWatcher(folder, pattern);
			fileSystemWatcher.Created += delegate
			{
				action();
			};
			fileSystemWatcher.Changed += delegate
			{
				action();
			};
			fileSystemWatcher.Renamed += delegate
			{
				action();
			};
			fileSystemWatcher.Deleted += delegate
			{
				action();
			};
			fileSystemWatcher.IncludeSubdirectories = true;
			fileSystemWatcher.SynchronizingObject = ThreadingHelper.SynchronizingObject;
			fileSystemWatcher.EnableRaisingEvents = true;
		}

		public static void SetupWatcher(string pattern, Action action)
		{
			SetupWatcher(BaseDirectory, pattern, delegate(string file)
			{
				BackupFile(file);
				action();
			});
		}

		private static void BackupFile(string path)
		{
			if (File.Exists(path))
			{
				if (!System.IO.Directory.Exists(BackupDirectory))
				{
					System.IO.Directory.CreateDirectory(BackupDirectory);
				}
				string text = DateTime.Now.ToString("yyyy-MM-dd");
				string path2 = Path.GetFileNameWithoutExtension(path) + "_" + text + Path.GetExtension(path) + ".bak";
				File.Copy(path, Path.Combine(BackupDirectory, path2), overwrite: true);
			}
		}

		public static void Init()
		{
			if (!System.IO.Directory.Exists(BaseDirectory))
			{
				System.IO.Directory.CreateDirectory(BaseDirectory);
			}
		}

		public static IDeserializer Deserializer()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Expected O, but got Unknown
			return ((BuilderSkeleton<DeserializerBuilder>)(object)((BuilderSkeleton<DeserializerBuilder>)new DeserializerBuilder()).WithNamingConvention(CamelCaseNamingConvention.Instance)).WithYamlFormatter(formatter).Build();
		}

		public static IDeserializer DeserializerUnSafe()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Expected O, but got Unknown
			return ((BuilderSkeleton<DeserializerBuilder>)(object)((BuilderSkeleton<DeserializerBuilder>)new DeserializerBuilder()).WithNamingConvention(CamelCaseNamingConvention.Instance)).WithYamlFormatter(formatter).IgnoreUnmatchedProperties().Build();
		}

		public static ISerializer Serializer()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Expected O, but got Unknown
			return ((BuilderSkeleton<SerializerBuilder>)(object)((BuilderSkeleton<SerializerBuilder>)new SerializerBuilder()).WithNamingConvention(CamelCaseNamingConvention.Instance).DisableAliases().ConfigureDefaultValuesHandling((DefaultValuesHandling)2)).WithYamlFormatter(formatter).Build();
		}

		public static List<T> Deserialize<T>(string raw, string fileName)
		{
			try
			{
				return Deserializer().Deserialize<List<T>>(raw) ?? new List<T>();
			}
			catch (Exception ex)
			{
				Log.Error(fileName + ": " + ex.Message);
				try
				{
					return DeserializerUnSafe().Deserialize<List<T>>(raw) ?? new List<T>();
				}
				catch (Exception)
				{
					return new List<T>();
				}
			}
		}

		public static List<T> LoadList<T>(string file) where T : new()
		{
			if (!File.Exists(file))
			{
				return new List<T>();
			}
			return Deserialize<T>(File.ReadAllText(file), file);
		}
	}
}
namespace ServerSync
{
	[PublicAPI]
	public abstract class OwnConfigEntryBase
	{
		public object? LocalBaseValue;

		public bool SynchronizedConfig = true;

		public abstract ConfigEntryBase BaseConfig { get; }
	}
	[PublicAPI]
	public class SyncedConfigEntry<T>(ConfigEntry<T> sourceConfig) : OwnConfigEntryBase()
	{
		public readonly ConfigEntry<T> SourceConfig = sourceConfig;

		public override ConfigEntryBase BaseConfig => (ConfigEntryBase)(object)SourceConfig;

		public T Value
		{
			get
			{
				return SourceConfig.Value;
			}
			set
			{
				SourceConfig.Value = value;
			}
		}

		public void AssignLocalValue(T value)
		{
			if (LocalBaseValue == null)
			{
				Value = value;
			}
			else
			{
				LocalBaseValue = value;
			}
		}
	}
	public abstract class CustomSyncedValueBase
	{
		public object? LocalBaseValue;

		public readonly string Identifier;

		public readonly Type Type;

		private object? boxedValue;

		protected bool localIsOwner;

		public readonly int Priority;

		public object? BoxedValue
		{
			get
			{
				return boxedValue;
			}
			set
			{
				boxedValue = value;
				this.ValueChanged?.Invoke();
			}
		}

		public event Action? ValueChanged;

		protected CustomSyncedValueBase(ConfigSync configSync, string identifier, Type type, int priority)
		{
			Priority = priority;
			Identifier = identifier;
			Type = type;
			configSync.AddCustomValue(this);
			localIsOwner = configSync.IsSourceOfTruth;
			configSync.SourceOfTruthChanged += delegate(bool truth)
			{
				localIsOwner = truth;
			};
		}
	}
	[PublicAPI]
	public sealed class CustomSyncedValue<T> : CustomSyncedValueBase
	{
		public T Value
		{
			get
			{
				return (T)base.BoxedValue;
			}
			set
			{
				base.BoxedValue = value;
			}
		}

		public CustomSyncedValue(ConfigSync configSync, string identifier, T value = default(T), int priority = 0)
			: base(configSync, identifier, typeof(T), priority)
		{
			Value = value;
		}

		public void AssignLocalValue(T value)
		{
			if (localIsOwner)
			{
				Value = value;
			}
			else
			{
				LocalBaseValue = value;
			}
		}
	}
	internal class ConfigurationManagerAttributes
	{
		[UsedImplicitly]
		public bool? ReadOnly = false;
	}
	[PublicAPI]
	public class ConfigSync
	{
		[HarmonyPatch(typeof(ZRpc), "HandlePackage")]
		private static class SnatchCurrentlyHandlingRPC
		{
			public static ZRpc? currentRpc;

			[HarmonyPrefix]
			private static void Prefix(ZRpc __instance)
			{
				currentRpc = __instance;
			}
		}

		[HarmonyPatch(typeof(ZNet), "Awake")]
		internal static class RegisterRPCPatch
		{
			[HarmonyPostfix]
			private static void Postfix(ZNet __instance)
			{
				isServer = __instance.IsServer();
				foreach (ConfigSync configSync2 in configSyncs)
				{
					ZRoutedRpc.instance.Register<ZPackage>(configSync2.Name + " ConfigSync", (Action<long, ZPackage>)configSync2.RPC_FromOtherClientConfigSync);
					if (isServer)
					{
						configSync2.InitialSyncDone = true;
						Debug.Log((object)("Registered '" + configSync2.Name + " ConfigSync' RPC - waiting for incoming connections"));
					}
				}
				if (isServer)
				{
					((MonoBehaviour)__instance).StartCoroutine(WatchAdminListChanges());
				}
				static void SendAdmin(List<ZNetPeer> peers, bool isAdmin)
				{
					ZPackage package = ConfigsToPackage(null, null, new PackageEntry[1]
					{
						new PackageEntry
						{
							section = "Internal",
							key = "lockexempt",
							type = typeof(bool),
							value = isAdmin
						}
					});
					ConfigSync configSync = configSyncs.First();
					if (configSync != null)
					{
						((MonoBehaviour)ZNet.instance).StartCoroutine(configSync.sendZPackage(peers, package));
					}
				}
				static IEnumerator WatchAdminListChanges()
				{
					MethodInfo listContainsId = AccessTools.DeclaredMethod(typeof(ZNet), "ListContainsId", (Type[])null, (Type[])null);
					SyncedList adminList = (SyncedList)AccessTools.DeclaredField(typeof(ZNet), "m_adminList").GetValue(ZNet.instance);
					List<string> list = adminList.GetList();
					List<string> list2 = new List<string>(list.Count);
					list2.AddRange(list);
					List<string> CurrentList = list2;
					while (true)
					{
						yield return (object)new WaitForSeconds(30f);
						if (!Configuration.ServerOnly && !adminList.GetList().SequenceEqual(CurrentList))
						{
							list = adminList.GetList();
							List<string> list3 = new List<string>(list.Count);
							list3.AddRange(list);
							CurrentList = list3;
							List<ZNetPeer> list4 = ZNet.instance.GetPeers().Where(delegate(ZNetPeer p)
							{
								string hostName = p.m_rpc.GetSocket().GetHostName();
								return ((object)listContainsId != null) ? ((bool)listContainsId.Invoke(ZNet.instance, new object[2] { adminList, hostName })) : adminList.Contains(hostName);
							}).ToList();
							SendAdmin(ZNet.instance.GetPeers().Except(list4).ToList(), isAdmin: false);
							SendAdmin(list4, isAdmin: true);
						}
					}
				}
			}
		}

		[HarmonyPatch(typeof(ZNet), "OnNewConnection")]
		private static class RegisterClientRPCPatch
		{
			[HarmonyPostfix]
			private static void Postfix(ZNet __instance, ZNetPeer peer)
			{
				if (__instance.IsServer())
				{
					return;
				}
				foreach (ConfigSync configSync in configSyncs)
				{
					peer.m_rpc.Register<ZPackage>(configSync.Name + " ConfigSync", (Action<ZRpc, ZPackage>)configSync.RPC_FromServerConfigSync);
				}
			}
		}

		private class ParsedConfigs
		{
			public readonly Dictionary<OwnConfigEntryBase, object?> configValues = new Dictionary<OwnConfigEntryBase, object>();

			public readonly Dictionary<CustomSyncedValueBase, object?> customValues = new Dictionary<CustomSyncedValueBase, object>();
		}

		[HarmonyPatch(typeof(ZNet), "Shutdown")]
		private class ResetConfigsOnShutdown
		{
			[HarmonyPostfix]
			private static void Postfix()
			{
				ProcessingServerUpdate = true;
				foreach (ConfigSync configSync in configSyncs)
				{
					configSync.resetConfigsFromServer();
					configSync.IsSourceOfTruth = true;
					configSync.InitialSyncDone = false;
				}
				ProcessingServerUpdate = false;
			}
		}

		[HarmonyPatch(typeof(ZNet), "RPC_PeerInfo")]
		private class SendConfigsAfterLogin
		{
			private class BufferingSocket : ZPlayFabSocket, ISocket
			{
				public volatile bool finished;

				public volatile int versionMatchQueued = -1;

				public readonly List<ZPackage> Package = new List<ZPackage>();

				public readonly ISocket Original;

				public BufferingSocket(ISocket original)
				{
					Original = original;
					((ZPlayFabSocket)this)..ctor();
				}

				public bool IsConnected()
				{
					return Original.IsConnected();
				}

				public ZPackage Recv()
				{
					return Original.Recv();
				}

				public int GetSendQueueSize()
				{
					return Original.GetSendQueueSize();
				}

				public int GetCurrentSendRate()
				{
					return Original.GetCurrentSendRate();
				}

				public bool IsHost()
				{
					return Original.IsHost();
				}

				public void Dispose()
				{
					Original.Dispose();
				}

				public bool GotNewData()
				{
					return Original.GotNewData();
				}

				public void Close()
				{
					Original.Close();
				}

				public string GetEndPointString()
				{
					return Original.GetEndPointString();
				}

				public void GetAndResetStats(out int totalSent, out int totalRecv)
				{
					Original.GetAndResetStats(ref totalSent, ref totalRecv);
				}

				public void GetConnectionQuality(out float localQuality, out float remoteQuality, out int ping, out float outByteSec, out float inByteSec)
				{
					Original.GetConnectionQuality(ref localQuality, ref remoteQuality, ref ping, ref outByteSec, ref inByteSec);
				}

				public ISocket Accept()
				{
					return Original.Accept();
				}

				public int GetHostPort()
				{
					return Original.GetHostPort();
				}

				public bool Flush()
				{
					return Original.Flush();
				}

				public string GetHostName()
				{
					return Original.GetHostName();
				}

				public void VersionMatch()
				{
					if (finished)
					{
						Original.VersionMatch();
					}
					else
					{
						versionMatchQueued = Package.Count;
					}
				}

				public void Send(ZPackage pkg)
				{
					//IL_004c: Unknown result type (might be due to invalid IL or missing references)
					//IL_0052: Expected O, but got Unknown
					int pos = pkg.GetPos();
					pkg.SetPos(0);
					int num = pkg.ReadInt();
					if ((num == StringExtensionMethods.GetStableHashCode("PeerInfo") || num == StringExtensionMethods.GetStableHashCode("RoutedRPC") || num == StringExtensionMethods.GetStableHashCode("ZDOData")) && !finished)
					{
						ZPackage val = new ZPackage(pkg.GetArray());
						val.SetPos(pos);
						Package.Add(val);
					}
					else
					{
						pkg.SetPos(pos);
						Original.Send(pkg);
					}
				}
			}

			[HarmonyPriority(800)]
			[HarmonyPrefix]
			private static void Prefix(ref Dictionary<Assembly, BufferingSocket>? __state, ZNet __instance, ZRpc rpc)
			{
				//IL_007b: Unknown result type (might be due to invalid IL or missing references)
				if (Configuration.ServerOnly || !__instance.IsServer())
				{
					return;
				}
				BufferingSocket bufferingSocket = new BufferingSocket(rpc.GetSocket());
				AccessTools.DeclaredField(typeof(ZRpc), "m_socket").SetValue(rpc, bufferingSocket);
				object? obj = AccessTools.DeclaredMethod(typeof(ZNet), "GetPeer", new Type[1] { typeof(ZRpc) }, (Type[])null).Invoke(__instance, new object[1] { rpc });
				ZNetPeer val = (ZNetPeer)((obj is ZNetPeer) ? obj : null);
				if (val != null && (int)ZNet.m_onlineBackend != 0)
				{
					FieldInfo fieldInfo = AccessTools.DeclaredField(typeof(ZNetPeer), "m_socket");
					object? value = fieldInfo.GetValue(val);
					ZPlayFabSocket val2 = (ZPlayFabSocket)((value is ZPlayFabSocket) ? value : null);
					if (val2 != null)
					{
						typeof(ZPlayFabSocket).GetField("m_remotePlayerId").SetValue(bufferingSocket, val2.m_remotePlayerId);
					}
					fieldInfo.SetValue(val, bufferingSocket);
				}
				if (__state == null)
				{
					__state = new Dictionary<Assembly, BufferingSocket>();
				}
				__state[Assembly.GetExecutingAssembly()] = bufferingSocket;
			}

			[HarmonyPostfix]
			private static void Postfix(Dictionary<Assembly, BufferingSocket> __state, ZNet __instance, ZRpc rpc)
			{
				ZNetPeer peer;
				if (!Configuration.ServerOnly && __instance.IsServer())
				{
					object obj = AccessTools.DeclaredMethod(typeof(ZNet), "GetPeer", new Type[1] { typeof(ZRpc) }, (Type[])null).Invoke(__instance, new object[1] { rpc });
					peer = (ZNetPeer)((obj is ZNetPeer) ? obj : null);
					if (peer == null)
					{
						SendBufferedData();
					}
					else
					{
						((MonoBehaviour)__instance).StartCoroutine(sendAsync());
					}
				}
				void SendBufferedData()
				{
					if (rpc.GetSocket() is BufferingSocket bufferingSocket)
					{
						AccessTools.DeclaredField(typeof(ZRpc), "m_socket").SetValue(rpc, bufferingSocket.Original);
						object? obj2 = AccessTools.DeclaredMethod(typeof(ZNet), "GetPeer", new Type[1] { typeof(ZRpc) }, (Type[])null).Invoke(__instance, new object[1] { rpc });
						ZNetPeer val = (ZNetPeer)((obj2 is ZNetPeer) ? obj2 : null);
						if (val != null)
						{
							AccessTools.DeclaredField(typeof(ZNetPeer), "m_socket").SetValue(val, bufferingSocket.Original);
						}
					}
					BufferingSocket bufferingSocket2 = __state[Assembly.GetExecutingAssembly()];
					bufferingSocket2.finished = true;
					for (int i = 0; i < bufferingSocket2.Package.Count; i++)
					{
						if (i == bufferingSocket2.versionMatchQueued)
						{
							bufferingSocket2.Original.VersionMatch();
						}
						bufferingSocket2.Original.Send(bufferingSocket2.Package[i]);
					}
					if (bufferingSocket2.Package.Count == bufferingSocket2.versionMatchQueued)
					{
						bufferingSocket2.Original.VersionMatch();
					}
				}
				IEnumerator sendAsync()
				{
					foreach (ConfigSync configSync in configSyncs)
					{
						List<PackageEntry> list = new List<PackageEntry>();
						if (configSync.CurrentVersion != null)
						{
							list.Add(new PackageEntry
							{
								section = "Internal",
								key = "serverversion",
								type = typeof(string),
								value = configSync.CurrentVersion
							});
						}
						MethodInfo methodInfo = AccessTools.DeclaredMethod(typeof(ZNet), "ListContainsId", (Type[])null, (Type[])null);
						SyncedList val = (SyncedList)AccessTools.DeclaredField(typeof(ZNet), "m_adminList").GetValue(ZNet.instance);
						list.Add(new PackageEntry
						{
							section = "Internal",
							key = "lockexempt",
							type = typeof(bool),
							value = (((object)methodInfo == null) ? ((object)val.Contains(rpc.GetSocket().GetHostName())) : methodInfo.Invoke(ZNet.instance, new object[2]
							{
								val,
								rpc.GetSocket().GetHostName()
							}))
						});
						ZPackage package = ConfigsToPackage(configSync.allConfigs.Select((OwnConfigEntryBase c) => c.BaseConfig), configSync.allCustomValues, list, partial: false);
						yield return ((MonoBehaviour)__instance).StartCoroutine(configSync.sendZPackage(new List<ZNetPeer>(1) { peer }, package));
					}
					SendBufferedData();
				}
			}
		}

		private class PackageEntry
		{
			public string section;

			public string key;

			public Type type;

			public object? value;
		}

		[HarmonyPatch(typeof(ConfigEntryBase), "GetSerializedValue")]
		private static class PreventSavingServerInfo
		{
			[HarmonyPrefix]
			private static bool Prefix(ConfigEntryBase __instance, ref string __result)
			{
				OwnConfigEntryBase ownConfigEntryBase = configData(__instance);
				if (ownConfigEntryBase == null || isWritableConfig(ownConfigEntryBase))
				{
					return true;
				}
				__result = TomlTypeConverter.ConvertToString(ownConfigEntryBase.LocalBaseValue, __instance.SettingType);
				return false;
			}
		}

		[HarmonyPatch(typeof(ConfigEntryBase), "SetSerializedValue")]
		private static class PreventConfigRereadChangingValues
		{
			[HarmonyPrefix]
			private static bool Prefix(ConfigEntryBase __instance, string value)
			{
				OwnConfigEntryBase ownConfigEntryBase = configData(__instance);
				if (ownConfigEntryBase == null || ownConfigEntryBase.LocalBaseValue == null)
				{
					return true;
				}
				try
				{
					ownConfigEntryBase.LocalBaseValue = TomlTypeConverter.ConvertToValue(value, __instance.SettingType);
				}
				catch (Exception ex)
				{
					Debug.LogWarning((object)$"Config value of setting \"{__instance.Definition}\" could not be parsed and will be ignored. Reason: {ex.Message}; Value: {value}");
				}
				return false;
			}
		}

		private class InvalidDeserializationTypeException : Exception
		{
			public string expected;

			public string received;

			public string field = "";
		}

		public static bool ProcessingServerUpdate;

		public readonly string Name;

		public string? DisplayName;

		public string? CurrentVersion;

		public string? MinimumRequiredVersion;

		public bool ModRequired;

		private bool? forceConfigLocking;

		private bool isSourceOfTruth = true;

		private static readonly HashSet<ConfigSync> configSyncs;

		private readonly HashSet<OwnConfigEntryBase> allConfigs = new HashSet<OwnConfigEntryBase>();

		private HashSet<CustomSyncedValueBase> allCustomValues = new HashSet<CustomSyncedValueBase>();

		private static bool isServer;

		private static bool lockExempt;

		private OwnConfigEntryBase? lockedConfig;

		private const byte PARTIAL_CONFIGS = 1;

		private const byte FRAGMENTED_CONFIG = 2;

		private const byte COMPRESSED_CONFIG = 4;

		private readonly Dictionary<string, SortedDictionary<int, byte[]>> configValueCache = new Dictionary<string, SortedDictionary<int, byte[]>>();

		private readonly List<KeyValuePair<long, string>> cacheExpirations = new List<KeyValuePair<long, string>>();

		private static long packageCounter;

		public bool IsLocked
		{
			get
			{
				bool? flag = forceConfigLocking;
				bool num;
				if (!flag.HasValue)
				{
					if (lockedConfig == null)
					{
						goto IL_0051;
					}
					num = ((IConvertible)lockedConfig.BaseConfig.BoxedValue).ToInt32(CultureInfo.InvariantCulture) != 0;
				}
				else
				{
					num = flag == true;
				}
				if (num)
				{
					return !lockExempt;
				}
				goto IL_0051;
				IL_0051:
				return false;
			}
			set
			{
				forceConfigLocking = value;
			}
		}

		public bool IsAdmin
		{
			get
			{
				if (!lockExempt)
				{
					return isSourceOfTruth;
				}
				return true;
			}
		}

		public bool IsSourceOfTruth
		{
			get
			{
				return isSourceOfTruth;
			}
			private set
			{
				if (value != isSourceOfTruth)
				{
					isSourceOfTruth = value;
					this.SourceOfTruthChanged?.Invoke(value);
				}
			}
		}

		public bool InitialSyncDone { get; private set; }

		public event Action<bool>? SourceOfTruthChanged;

		private event Action? lockedConfigChanged;

		static ConfigSync()
		{
			ProcessingServerUpdate = false;
			configSyncs = new HashSet<ConfigSync>();
			lockExempt = false;
			packageCounter = 0L;
			RuntimeHelpers.RunClassConstructor(typeof(VersionCheck).TypeHandle);
		}

		public ConfigSync(string name)
			: this(name, sendBiomes: false)
		{
		}

		public ConfigSync(string name, bool sendBiomes)
		{
			Name = name;
			configSyncs.Add(this);
			new VersionCheck(this).SendBiomes = sendBiomes;
		}

		public SyncedConfigEntry<T> AddConfigEntry<T>(ConfigEntry<T> configEntry)
		{
			OwnConfigEntryBase ownConfigEntryBase = configData((ConfigEntryBase)(object)configEntry);
			SyncedConfigEntry<T> syncedEntry = ownConfigEntryBase as SyncedConfigEntry<T>;
			if (syncedEntry == null)
			{
				syncedEntry = new SyncedConfigEntry<T>(configEntry);
				AccessTools.DeclaredField(typeof(ConfigDescription), "<Tags>k__BackingField").SetValue(((ConfigEntryBase)configEntry).Description, new object[1]
				{
					new ConfigurationManagerAttributes()
				}.Concat(((ConfigEntryBase)configEntry).Description.Tags ?? Array.Empty<object>()).Concat(new SyncedConfigEntry<T>[1] { syncedEntry }).ToArray());
				configEntry.SettingChanged += delegate
				{
					if (!ProcessingServerUpdate && syncedEntry.SynchronizedConfig)
					{
						Broadcast(ZRoutedRpc.Everybody, (ConfigEntryBase)configEntry);
					}
				};
				allConfigs.Add(syncedEntry);
			}
			return syncedEntry;
		}

		public SyncedConfigEntry<T> AddLockingConfigEntry<T>(ConfigEntry<T> lockingConfig) where T : IConvertible
		{
			if (lockedConfig != null)
			{
				throw new Exception("Cannot initialize locking ConfigEntry twice");
			}
			lockedConfig = AddConfigEntry<T>(lockingConfig);
			lockingConfig.SettingChanged += delegate
			{
				this.lockedConfigChanged?.Invoke();
			};
			return (SyncedConfigEntry<T>)lockedConfig;
		}

		internal void AddCustomValue(CustomSyncedValueBase customValue)
		{
			if (allCustomValues.Select((CustomSyncedValueBase v) => v.Identifier).Concat(new string[1] { "serverversion" }).Contains(customValue.Identifier))
			{
				throw new Exception("Cannot have multiple settings with the same name or with a reserved name (serverversion)");
			}
			allCustomValues.Add(customValue);
			HashSet<CustomSyncedValueBase> hashSet = new HashSet<CustomSyncedValueBase>();
			foreach (CustomSyncedValueBase item in allCustomValues.OrderByDescending((CustomSyncedValueBase v) => v.Priority))
			{
				hashSet.Add(item);
			}
			allCustomValues = hashSet;
			customValue.ValueChanged += delegate
			{
				if (!ProcessingServerUpdate)
				{
					Broadcast(ZRoutedRpc.Everybody, customValue);
				}
			};
		}

		private void RPC_FromServerConfigSync(ZRpc rpc, ZPackage package)
		{
			lockedConfigChanged += serverLockedSettingChanged;
			IsSourceOfTruth = false;
			if (HandleConfigSyncRPC(0L, package, clientUpdate: false))
			{
				InitialSyncDone = true;
			}
		}

		private void RPC_FromOtherClientConfigSync(long sender, ZPackage package)
		{
			HandleConfigSyncRPC(sender, package, clientUpdate: true);
		}

		private bool HandleConfigSyncRPC(long sender, ZPackage package, bool clientUpdate)
		{
			//IL_0209: Unknown result type (might be due to invalid IL or missing references)
			//IL_0210: 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_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Expected O, but got Unknown
			try
			{
				if (isServer && IsLocked)
				{
					ZRpc? currentRpc = SnatchCurrentlyHandlingRPC.currentRpc;
					object obj;
					if (currentRpc == null)
					{
						obj = null;
					}
					else
					{
						ISocket socket = currentRpc.GetSocket();
						obj = ((socket != null) ? socket.GetHostName() : null);
					}
					string text = (string)obj;
					if (text != null)
					{
						MethodInfo methodInfo = AccessTools.DeclaredMethod(typeof(ZNet), "ListContainsId", (Type[])null, (Type[])null);
						SyncedList val = (SyncedList)AccessTools.DeclaredField(typeof(ZNet), "m_adminList").GetValue(ZNet.instance);
						if (!(((object)methodInfo == null) ? val.Contains(text) : ((bool)methodInfo.Invoke(ZNet.instance, new object[2] { val, text }))))
						{
							return false;
						}
					}
				}
				cacheExpirations.RemoveAll(delegate(KeyValuePair<long, string> kv)
				{
					if (kv.Key < DateTimeOffset.Now.Ticks)
					{
						configValueCache.Remove(kv.Value);
						return true;
					}
					return false;
				});
				byte b = package.ReadByte();
				if ((b & 2) != 0)
				{
					long num = package.ReadLong();
					string text2 = sender.ToString() + num;
					if (!configValueCache.TryGetValue(text2, out SortedDictionary<int, byte[]> value))
					{
						value = new SortedDictionary<int, byte[]>();
						configValueCache[text2] = value;
						cacheExpirations.Add(new KeyValuePair<long, string>(DateTimeOffset.Now.AddSeconds(60.0).Ticks, text2));
					}
					int key = package.ReadInt();
					int num2 = package.ReadInt();
					value.Add(key, package.ReadByteArray());
					if (value.Count < num2)
					{
						return false;
					}
					configValueCache.Remove(text2);
					package = new ZPackage(value.Values.SelectMany((byte[] a) => a).ToArray());
					b = package.ReadByte();
				}
				ProcessingServerUpdate = true;
				if ((b & 4) != 0)
				{
					MemoryStream stream = new MemoryStream(package.ReadByteArray());
					MemoryStream memoryStream = new MemoryStream();
					using (DeflateStream deflateStream = new DeflateStream(stream, CompressionMode.Decompress))
					{
						deflateStream.CopyTo(memoryStream);
					}
					package = new ZPackage(memoryStream.ToArray());
					b = package.ReadByte();
				}
				if ((b & 1) == 0)
				{
					resetConfigsFromServer();
				}
				ParsedConfigs parsedConfigs = ReadConfigsFromPackage(package);
				ConfigFile val2 = null;
				bool saveOnConfigSet = false;
				foreach (KeyValuePair<OwnConfigEntryBase, object> configValue in parsedConfigs.configValues)
				{
					if (!isServer && configValue.Key.LocalBaseValue == null)
					{
						configValue.Key.LocalBaseValue = configValue.Key.BaseConfig.BoxedValue;
					}
					if (val2 == null)
					{
						val2 = configValue.Key.BaseConfig.ConfigFile;
						saveOnConfigSet = val2.SaveOnConfigSet;
						val2.SaveOnConfigSet = false;
					}
					configValue.Key.BaseConfig.BoxedValue = configValue.Value;
				}
				if (val2 != null)
				{
					val2.SaveOnConfigSet = saveOnConfigSet;
					val2.Save();
				}
				foreach (KeyValuePair<CustomSyncedValueBase, object> customValue in parsedConfigs.customValues)
				{
					if (!isServer)
					{
						CustomSyncedValueBase key2 = customValue.Key;
						if (key2.LocalBaseValue == null)
						{
							key2.LocalBaseValue = customValue.Key.BoxedValue;
						}
					}
					customValue.Key.BoxedValue = customValue.Value;
				}
				Debug.Log((object)string.Format("Received {0} configs and {1} custom values from {2} for mod {3}", parsedConfigs.configValues.Count, parsedConfigs.customValues.Count, (isServer || clientUpdate) ? $"client {sender}" : "the server", DisplayName ?? Name));
				if (!isServer)
				{
					serverLockedSettingChanged();
				}
				return true;
			}
			finally
			{
				ProcessingServerUpdate = false;
			}
		}

		private ParsedConfigs ReadConfigsFromPackage(ZPackage package)
		{
			ParsedConfigs parsedConfigs = new ParsedConfigs();
			Dictionary<string, OwnConfigEntryBase> dictionary = allConfigs.Where((OwnConfigEntryBase c) => c.SynchronizedConfig).ToDictionary((OwnConfigEntryBase c) => c.BaseConfig.Definition.Section + "_" + c.BaseConfig.Definition.Key, (OwnConfigEntryBase c) => c);
			Dictionary<string, CustomSyncedValueBase> dictionary2 = allCustomValues.ToDictionary((CustomSyncedValueBase c) => c.Identifier, (CustomSyncedValueBase c) => c);
			int num = package.ReadInt();
			for (int num2 = 0; num2 < num; num2++)
			{
				string text = package.ReadString();
				string text2 = package.ReadString();
				string text3 = package.ReadString();
				Type type = Type.GetType(text3);
				if (text3 == "" || type != null)
				{
					object obj;
					try
					{
						obj = ((text3 == "") ? null : ReadValueWithTypeFromZPackage(package, type));
					}
					catch (InvalidDeserializationTypeException ex)
					{
						Debug.LogWarning((object)("Got unexpected struct internal type " + ex.received + " for field " + ex.field + " struct " + text3 + " for " + text2 + " in section " + text + " for mod " + (DisplayName ?? Name) + ", expecting " + ex.expected));
						continue;
					}
					OwnConfigEntryBase value2;
					if (text == "Internal")
					{
						CustomSyncedValueBase value;
						if (text2 == "serverversion")
						{
							if (obj?.ToString() != CurrentVersion)
							{
								Debug.LogWarning((object)("Received server version is not equal: server version = " + (obj?.ToString() ?? "null") + "; local version = " + (CurrentVersion ?? "unknown")));
							}
						}
						else if (text2 == "lockexempt")
						{
							if (obj is bool flag)
							{
								lockExempt = flag;
							}
						}
						else if (dictionary2.TryGetValue(text2, out value))
						{
							if ((text3 == "" && (!value.Type.IsValueType || Nullable.GetUnderlyingType(value.Type) != null)) || GetZPackageTypeString(value.Type) == text3)
							{
								parsedConfigs.customValues[value] = obj;
								continue;
							}
							Debug.LogWarning((object)("Got unexpected type " + text3 + " for internal value " + text2 + " for mod " + (DisplayName ?? Name) + ", expecting " + value.Type.AssemblyQualifiedName));
						}
					}
					else if (dictionary.TryGetValue(text + "_" + text2, out value2))
					{
						Type type2 = configType(value2.BaseConfig);
						if ((text3 == "" && (!type2.IsValueType || Nullable.GetUnderlyingType(type2) != null)) || GetZPackageTypeString(type2) == text3)
						{
							parsedConfigs.configValues[value2] = obj;
							continue;
						}
						Debug.LogWarning((object)("Got unexpected type " + text3 + " for " + text2 + " in section " + text + " for mod " + (DisplayName ?? Name) + ", expecting " + type2.AssemblyQualifiedName));
					}
					else
					{
						Debug.LogWarning((object)("Received unknown config entry " + text2 + " in section " + text + " for mod " + (DisplayName ?? Name) + ". This may happen if client and server versions of the mod do not match."));
					}
					continue;
				}
				Debug.LogWarning((object)("Got invalid type " + text3 + ", abort reading of received configs"));
				return new ParsedConfigs();
			}
			return parsedConfigs;
		}

		private static bool isWritableConfig(OwnConfigEntryBase config)
		{
			ConfigSync configSync = configSyncs.FirstOrDefault((ConfigSync cs) => cs.allConfigs.Contains(config));
			if (configSync == null)
			{
				return true;
			}
			if (!configSync.IsSourceOfTruth && config.SynchronizedConfig && config.LocalBaseValue != null)
			{
				if (!configSync.IsLocked)
				{
					if (config == configSync.lockedConfig)
					{
						return lockExempt;
					}
					return true;
				}
				return false;
			}
			return true;
		}

		private void serverLockedSettingChanged()
		{
			foreach (OwnConfigEntryBase allConfig in allConfigs)
			{
				configAttribute<ConfigurationManagerAttributes>(allConfig.BaseConfig).ReadOnly = !isWritableConfig(allConfig);
			}
		}

		private void resetConfigsFromServer()
		{
			ConfigFile val = null;
			bool saveOnConfigSet = false;
			foreach (OwnConfigEntryBase item in allConfigs.Where((OwnConfigEntryBase config) => config.LocalBaseValue != null))
			{
				if (val == null)
				{
					val = item.BaseConfig.ConfigFile;
					saveOnConfigSet = val.SaveOnConfigSet;
					val.SaveOnConfigSet = false;
				}
				item.BaseConfig.BoxedValue = item.LocalBaseValue;
				item.LocalBaseValue = null;
			}
			if (val != null)
			{
				val.SaveOnConfigSet = saveOnConfigSet;
			}
			foreach (CustomSyncedValueBase item2 in allCustomValues.Where((CustomSyncedValueBase config) => config.LocalBaseValue != null))
			{
				item2.BoxedValue = item2.LocalBaseValue;
				item2.LocalBaseValue = null;
			}
			lockedConfigChanged -= serverLockedSettingChanged;
			serverLockedSettingChanged();
		}

		private IEnumerator<bool> distributeConfigToPeers(ZNetPeer peer, ZPackage package)
		{
			ZRoutedRpc rpc = ZRoutedRpc.instance;
			if (rpc == null)
			{
				yield break;
			}
			byte[] data = package.GetArray();
			if (data != null && data.LongLength > 250000)
			{
				int fragments = (int)(1 + (data.LongLength - 1) / 250000);
				long packageIdentifier = ++packageCounter;
				int fragment = 0;
				while (fragment < fragments)
				{
					foreach (bool item in waitForQueue())
					{
						yield return item;
					}
					if (peer.m_socket.IsConnected())
					{
						ZPackage val = new ZPackage();
						val.Write((byte)2);
						val.Write(packageIdentifier);
						val.Write(fragment);
						val.Write(fragments);
						val.Write(data.Skip(250000 * fragment).Take(250000).ToArray());
						SendPackage(val);
						if (fragment != fragments - 1)
						{
							yield return true;
						}
						int num = fragment + 1;
						fragment = num;
						continue;
					}
					break;
				}
				yield break;
			}
			foreach (bool item2 in waitForQueue())
			{
				yield return item2;
			}
			SendPackage(package);
			void SendPackage(ZPackage pkg)
			{
				string text = Name + " ConfigSync";
				if (isServer)
				{
					peer.m_rpc.Invoke(text, new object[1] { pkg });
				}
				else
				{
					rpc.InvokeRoutedRPC(peer.m_server ? 0 : peer.m_uid, text, new object[1] { pkg });
				}
			}
			IEnumerable<bool> waitForQueue()
			{
				float timeout = Time.time + 30f;
				while (peer.m_socket.GetSendQueueSize() > 20000)
				{
					if (Time.time > timeout)
					{
						Debug.Log((object)$"Disconnecting {peer.m_uid} after 30 seconds config sending timeout");
						peer.m_rpc.Invoke("Error", new object[1] { (object)(ConnectionStatus)5 });
						ZNet.instance.Disconnect(peer);
						break;
					}
					yield return false;
				}
			}
		}

		private IEnumerator sendZPackage(long target, ZPackage package)
		{
			if (!Object.op_Implicit((Object)(object)ZNet.instance))
			{
				return Enumerable.Empty<object>().GetEnumerator();
			}
			List<ZNetPeer> list = (List<ZNetPeer>)AccessTools.DeclaredField(typeof(ZRoutedRpc), "m_peers").GetValue(ZRoutedRpc.instance);
			if (target != ZRoutedRpc.Everybody)
			{
				list = list.Where((ZNetPeer p) => p.m_uid == target).ToList();
			}
			return sendZPackage(list, package);
		}

		private IEnumerator sendZPackage(List<ZNetPeer> peers, ZPackage package)
		{
			if (!Object.op_Implicit((Object)(object)ZNet.instance))
			{
				yield break;
			}
			byte[] array = package.GetArray();
			if (array != null && array.LongLength > 10000)
			{
				ZPackage val = new ZPackage();
				val.Write((byte)4);
				MemoryStream memoryStream = new MemoryStream();
				using (DeflateStream deflateStream = new DeflateStream(memoryStream, CompressionLevel.Optimal))
				{
					deflateStream.Write(array, 0, array.Length);
				}
				val.Write(memoryStream.ToArray());
				package = val;
			}
			List<IEnumerator<bool>> writers = (from p in peers
				where p.IsReady()
				select distributeConfigToPeers(p, package)).ToList();
			writers.RemoveAll((IEnumerator<bool> writer) => !writer.MoveNext());
			while (writers.Count > 0)
			{
				yield return null;
				writers.RemoveAll((IEnumerator<bool> writer) => !writer.MoveNext());
			}
		}

		private void Broadcast(long target, params ConfigEntryBase[] configs)
		{
			if (!Configuration.ServerOnly && (!IsLocked || isServer))
			{
				ZPackage package = ConfigsToPackage(configs);
				ZNet instance = ZNet.instance;
				if (instance != null)
				{
					((MonoBehaviour)instance).StartCoroutine(sendZPackage(target, package));
				}
			}
		}

		private void Broadcast(long target, params CustomSyncedValueBase[] customValues)
		{
			if (!Configuration.ServerOnly && (!IsLocked || isServer))
			{
				ZPackage package = ConfigsToPackage(null, customValues);
				ZNet instance = ZNet.instance;
				if (instance != null)
				{
					((MonoBehaviour)instance).StartCoroutine(sendZPackage(target, package));
				}
			}
		}

		private static OwnConfigEntryBase? configData(ConfigEntryBase config)
		{
			return config.Description.Tags?.OfType<OwnConfigEntryBase>().SingleOrDefault();
		}

		public static SyncedConfigEntry<T>? ConfigData<T>(ConfigEntry<T> config)
		{
			return ((ConfigEntryBase)config).Description.Tags?.OfType<SyncedConfigEntry<T>>().SingleOrDefault();
		}

		private static T configAttribute<T>(ConfigEntryBase config)
		{
			return config.Description.Tags.OfType<T>().First();
		}

		private static Type configType(ConfigEntryBase config)
		{
			return configType(config.SettingType);
		}

		private static Type configType(Type type)
		{
			if (!type.IsEnum)
			{
				return type;
			}
			return Enum.GetUnderlyingType(type);
		}

		private static ZPackage ConfigsToPackage(IEnumerable<ConfigEntryBase>? configs = null, IEnumerable<CustomSyncedValueBase>? customValues = null, IEnumerable<PackageEntry>? packageEntries = null, bool partial = true)
		{
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Expected O, but got Unknown
			List<ConfigEntryBase> list = configs?.Where((ConfigEntryBase config) => configData(config).SynchronizedConfig).ToList() ?? new List<ConfigEntryBase>();
			List<CustomSyncedValueBase> list2 = customValues?.ToList() ?? new List<CustomSyncedValueBase>();
			ZPackage val = new ZPackage();
			val.Write(partial ? ((byte)1) : ((byte)0));
			val.Write(list.Count + list2.Count + (packageEntries?.Count() ?? 0));
			foreach (PackageEntry item in packageEntries ?? Array.Empty<PackageEntry>())
			{
				AddEntryToPackage(val, item);
			}
			foreach (CustomSyncedValueBase item2 in list2)
			{
				AddEntryToPackage(val, new PackageEntry
				{
					section = "Internal",
					key = item2.Identifier,
					type = item2.Type,
					value = item2.BoxedValue
				});
			}
			foreach (ConfigEntryBase item3 in list)
			{
				AddEntryToPackage(val, new PackageEntry
				{
					section = item3.Definition.Section,
					key = item3.Definition.Key,
					type = configType(item3),
					value = item3.BoxedValue
				});
			}
			return val;
		}

		private static void AddEntryToPackage(ZPackage package, PackageEntry entry)
		{
			package.Write(entry.section);
			package.Write(entry.key);
			package.Write((entry.value == null) ? "" : GetZPackageTypeString(entry.type));
			AddValueToZPackage(package, entry.value);
		}

		private static string GetZPackageTypeString(Type type)
		{
			return type.AssemblyQualifiedName;
		}

		private static void AddValueToZPackage(ZPackage package, object? value)
		{
			Type type = value?.GetType();
			if (value is Enum)
			{
				value = ((IConvertible)value).ToType(Enum.GetUnderlyingType(value.GetType()), CultureInfo.InvariantCulture);
			}
			else
			{
				if (value is ICollection collection)
				{
					package.Write(collection.Count);
					{
						foreach (object item in collection)
						{
							AddValueToZPackage(package, item);
						}
						return;
					}
				}
				if ((object)type != null && type.IsValueType && !type.IsPrimitive)
				{
					FieldInfo[] fields = type.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
					package.Write(fields.Length);
					FieldInfo[] array = fields;
					foreach (FieldInfo fieldInfo in array)
					{
						package.Write(GetZPackageTypeString(fieldInfo.FieldType));
						AddValueToZPackage(package, fieldInfo.GetValue(value));
					}
					return;
				}
			}
			if (value != null)
			{
				Serialize(value, ref package);
			}
		}

		private static void Serialize(object obj, ref ZPackage pkg)
		{
			//IL_00c9: 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_00d2: 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_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: 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_011b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: 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_0152: Unknown result type (might be due to invalid IL or missing references)
			//IL_0156: Unknown result type (might be due to invalid IL or missing references)
			if (obj is int num)
			{
				pkg.Write(num);
				return;
			}
			if (obj is uint num2)
			{
				pkg.Write(num2);
				return;
			}
			if (obj is long num3)
			{
				pkg.Write(num3);
				return;
			}
			if (obj is float num4)
			{
				pkg.Write(num4);
				return;
			}
			if (obj is double num5)
			{
				pkg.Write(num5);
				return;
			}
			if (obj is bool flag)
			{
				pkg.Write(flag);
				return;
			}
			if (obj is string text)
			{
				pkg.Write(text);
				return;
			}
			ZPackage val = (ZPackage)((obj is ZPackage) ? obj : null);
			if (val != null)
			{
				pkg.Write(val);
				return;
			}
			if (obj is Vector3 val2)
			{
				pkg.Write(val2.x);
				pkg.Write(val2.y);
				pkg.Write(val2.z);
				return;
			}
			if (obj is Quaternion val3)
			{
				pkg.Write(val3.x);
				pkg.Write(val3.y);
				pkg.Write(val3.z);
				pkg.Write(val3.w);
				return;
			}
			if (obj is ZDOID val4)
			{
				pkg.Write(val4);
				return;
			}
			HitData val5 = (HitData)((obj is HitData) ? obj : null);
			if (val5 != null)
			{
				val5.Serialize(ref pkg);
				return;
			}
			ISerializableParameter val6 = (ISerializableParameter)((obj is ISerializableParameter) ? obj : null);
			if (val6 != null)
			{
				val6.Serialize(ref pkg);
			}
		}

		private static object ReadValueWithTypeFromZPackage(ZPackage package, Type type)
		{
			if ((object)type != null && type.IsValueType && !type.IsPrimitive && !type.IsEnum)
			{
				FieldInfo[] fields = type.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				int num = package.ReadInt();
				if (num != fields.Length)
				{
					throw new InvalidDeserializationTypeException
					{
						received = $"(field count: {num})",
						expected = $"(field count: {fields.Length})"
					};
				}
				object uninitializedObject = FormatterServices.GetUninitializedObject(type);
				FieldInfo[] array = fields;
				foreach (FieldInfo fieldInfo in array)
				{
					string text = package.ReadString();
					if (text != GetZPackageTypeString(fieldInfo.FieldType))
					{
						throw new InvalidDeserializationTypeException
						{
							received = text,
							expected = GetZPackageTypeString(fieldInfo.FieldType),
							field = fieldInfo.Name
						};
					}
					fieldInfo.SetValue(uninitializedObject, ReadValueWithTypeFromZPackage(package, fieldInfo.FieldType));
				}
				return uninitializedObject;
			}
			if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Dictionary<, >))
			{
				int num2 = package.ReadInt();
				IDictionary dictionary = (IDictionary)Activator.CreateInstance(type);
				Type type2 = typeof(KeyValuePair<, >).MakeGenericType(type.GenericTypeArguments);
				FieldInfo field = type2.GetField("key", BindingFlags.Instance | BindingFlags.NonPublic);
				FieldInfo field2 = type2.GetField("value", BindingFlags.Instance | BindingFlags.NonPublic);
				for (int j = 0; j < num2; j++)
				{
					object obj = ReadValueWithTypeFromZPackage(package, type2);
					dictionary.Add(field.GetValue(obj), field2.GetValue(obj));
				}
				return dictionary;
			}
			if (type.IsGenericType)
			{
				Type type3 = typeof(ICollection<>).MakeGenericType(type.GenericTypeArguments[0]);
				if ((object)type3 != null && type3.IsAssignableFrom(type))
				{
					int num3 = package.ReadInt();
					object obj2 = Activator.CreateInstance(type);
					MethodInfo method = type3.GetMethod("Add");
					for (int k = 0; k < num3; k++)
					{
						method.Invoke(obj2, new object[1] { ReadValueWithTypeFromZPackage(package, type.GenericTypeArguments[0]) });
					}
					return obj2;
				}
			}
			return Deserialize(type, package);
		}

		private static object Deserialize(Type type, ZPackage pkg)
		{
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			//IL_015d: Unknown result type (might be due to invalid IL or missing references)
			//IL_017a: Unknown result type (might be due to invalid IL or missing references)
			//IL_017f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0188: Expected O, but got Unknown
			//IL_01a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ae: Expected O, but got Unknown
			if (type == typeof(int))
			{
				return pkg.ReadInt();
			}
			if (type == typeof(uint))
			{
				return pkg.ReadUInt();
			}
			if (type == typeof(long))
			{
				return pkg.ReadLong();
			}
			if (type == typeof(float))
			{
				return pkg.ReadSingle();
			}
			if (type == typeof(double))
			{
				return pkg.ReadDouble();
			}
			if (type == typeof(bool))
			{
				return pkg.ReadBool();
			}
			if (type == typeof(string))
			{
				return pkg.ReadString();
			}
			if (type == typeof(ZPackage))
			{
				return pkg.ReadPackage();
			}
			if (type == typeof(Vector3))
			{
				return (object)new Vector3(pkg.ReadSingle(), pkg.ReadSingle(), pkg.ReadSingle());
			}
			if (type == typeof(Quaternion))
			{
				return (object)new Quaternion(pkg.ReadSingle(), pkg.ReadSingle(), pkg.ReadSingle(), pkg.ReadSingle());
			}
			if (type == typeof(ZDOID))
			{
				return pkg.ReadZDOID();
			}
			if (type == typeof(HitData))
			{
				HitData val = new HitData();
				val.Deserialize(ref pkg);
				return (object)val;
			}
			if (typeof(ISerializableParameter).IsAssignableFrom(type))
			{
				ISerializableParameter val2 = (ISerializableParameter)Activator.CreateInstance(type);
				val2.Deserialize(ref pkg);
				return (object)val2;
			}
			throw new NotSupportedException($"Type {type} is not supported for deserialization");
		}
	}
	[PublicAPI]
	[HarmonyPatch]
	public class VersionCheck
	{
		private static readonly HashSet<VersionCheck> versionChecks;

		private static readonly Dictionary<string, string> notProcessedNames;

		public string Name;

		private string? displayName;

		private string? currentVersion;

		private string? minimumRequiredVersion;

		public bool ModRequired = true;

		private string? ReceivedCurrentVersion;

		private string? ReceivedMinimumRequiredVersion;

		private readonly List<ZRpc> ValidatedClients = new List<ZRpc>();

		private readonly ConfigSync? ConfigSync;

		public string DisplayName
		{
			get
			{
				return displayName ?? Name;
			}
			set
			{
				displayName = value;
			}
		}

		public bool SendBiomes { get; set; }

		public string CurrentVersion
		{
			get
			{
				return currentVersion ?? "0.0.0";
			}
			set
			{
				currentVersion = value;
			}
		}

		public string MinimumRequiredVersion
		{
			get
			{
				string text = minimumRequiredVersion;
				if (text == null)
				{
					if (!ModRequired)
					{
						return "0.0.0";
					}
					text = CurrentVersion;
				}
				return text;
			}
			set
			{
				minimumRequiredVersion = value;
			}
		}

		private static void PatchServerSync()
		{
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Expected O, but got Unknown
			Patches patchInfo = PatchProcessor.GetPatchInfo((MethodBase)AccessTools.DeclaredMethod(typeof(ZNet), "Awake", (Type[])null, (Type[])null));
			if (patchInfo != null && patchInfo.Postfixes.Count((Patch p) => p.PatchMethod.DeclaringType == typeof(ConfigSync.RegisterRPCPatch)) > 0)
			{
				return;
			}
			Harmony val = new Harmony("org.bepinex.helpers.ServerSync");
			foreach (Type item in from t in typeof(ConfigSync).GetNestedTypes(BindingFlags.NonPublic).Concat(new Type[1] { typeof(VersionCheck) })
				where t.IsClass
				select t)
			{
				val.PatchAll(item);
			}
		}

		static VersionCheck()
		{
			versionChecks = new HashSet<VersionCheck>();
			notProcessedNames = new Dictionary<string, string>();
			typeof(ThreadingHelper).GetMethod("StartSyncInvoke").Invoke(ThreadingHelper.Instance, new object[1]
			{
				new Action(PatchServerSync)
			});
		}

		public VersionCheck(string name)
		{
			Name = name;
			ModRequired = true;
			versionChecks.Add(this);
		}

		public VersionCheck(ConfigSync configSync)
		{
			ConfigSync = configSync;
			Name = ConfigSync.Name;
			versionChecks.Add(this);
		}

		public void Initialize()
		{
			ReceivedCurrentVersion = null;
			ReceivedMinimumRequiredVersion = null;
			if (ConfigSync != null)
			{
				Name = ConfigSync.Name;
				DisplayName = ConfigSync.DisplayName;
				CurrentVersion = ConfigSync.CurrentVersion;
				MinimumRequiredVersion = ConfigSync.MinimumRequiredVersion;
				ModRequired = ConfigSync.ModRequired;
			}
		}

		private bool IsVersionOk()
		{
			if (ReceivedMinimumRequiredVersion == null || ReceivedCurrentVersion == null)
			{
				return !ModRequired;
			}
			bool num = new Version(CurrentVersion) >= new Version(ReceivedMinimumRequiredVersion);
			bool flag = new Version(ReceivedCurrentVersion) >= new Version(MinimumRequiredVersion);
			return num && flag;
		}

		private string ErrorClient()
		{
			if (ReceivedMinimumRequiredVersion == null)
			{
				return DisplayName + " is not installed on the server.";
			}
			if (!(new Version(CurrentVersion) >= new Version(ReceivedMinimumRequiredVersion)))
			{
				return DisplayName + " needs to be at least version " + ReceivedMinimumRequiredVersion + ". You have version " + CurrentVersion + ".";
			}
			return DisplayName + " may not be higher than version " + ReceivedCurrentVersion + ". You have version " + CurrentVersion + ".";
		}

		private string ErrorServer(ZRpc rpc)
		{
			return "Disconnect: The client (" + rpc.GetSocket().GetHostName() + ") doesn't have the correct " + DisplayName + " version " + MinimumRequiredVersion;
		}

		private string Error(ZRpc? rpc = null)
		{
			if (rpc != null)
			{
				return ErrorServer(rpc);
			}
			return ErrorClient();
		}

		private static VersionCheck[] GetFailedClient()
		{
			return versionChecks.Where((VersionCheck check) => !check.IsVersionOk()).ToArray();
		}

		private static VersionCheck[] GetFailedServer(ZRpc rpc)
		{
			return versionChecks.Where((VersionCheck check) => check.ModRequired && !check.ValidatedClients.Contains(rpc)).ToArray();
		}

		private static void Logout()
		{
			Game.instance.Logout(true, true);
			AccessTools.DeclaredField(typeof(ZNet), "m_connectionStatus").SetValue(null, (object)(ConnectionStatus)3);
		}

		private static void DisconnectClient(ZRpc rpc)
		{
			rpc.Invoke("Error", new object[1] { 3 });
		}

		private static void CheckVersion(ZRpc rpc, ZPackage pkg)
		{
			CheckVersion(rpc, pkg, null);
		}

		private static void CheckVersion(ZRpc rpc, ZPackage pkg, Action<ZRpc, ZPackage>? original)
		{
			//IL_0125: 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)
			string text = pkg.ReadString();
			string text2 = pkg.ReadString();
			string text3 = pkg.ReadString();
			bool flag = false;
			foreach (VersionCheck versionCheck in versionChecks)
			{
				if (!(text != versionCheck.Name))
				{
					Debug.Log((object)("Received " + versionCheck.DisplayName + " version " + text3 + " and minimum version " + text2 + " from the " + (ZNet.instance.IsServer() ? "client" : "server") + "."));
					versionCheck.ReceivedMinimumRequiredVersion = text2;
					versionCheck.ReceivedCurrentVersion = text3;
					if (ZNet.instance.IsServer() && versionCheck.IsVersionOk())
					{
						versionCheck.ValidatedClients.Add(rpc);
					}
					flag = true;
				}
			}
			if (flag && !ZNet.instance.IsServer() && pkg.GetPos() < pkg.Size())
			{
				Dictionary<Biome, string> dictionary = new Dictionary<Biome, string>();
				while (pkg.m_reader.BaseStream.Position != pkg.m_reader.BaseStream.Length)
				{
					Biome key = (Biome)pkg.ReadInt();
					string value = pkg.ReadString();
					dictionary.Add(key, value);
				}
				BiomeManager.SetNames(dictionary);
			}
			if (flag)
			{
				return;
			}
			pkg.SetPos(0);
			if (original != null)
			{
				original(rpc, pkg);
				if (pkg.GetPos() == 0)
				{
					notProcessedNames.Add(text, text3);
				}
			}
		}

		[HarmonyPatch(typeof(ZNet), "RPC_PeerInfo")]
		[HarmonyPrefix]
		private static bool RPC_PeerInfo(ZRpc rpc, ZNet __instance)
		{
			if (ZNet.instance.IsServer() && Configuration.ServerOnly)
			{
				return true;
			}
			VersionCheck[] array = (__instance.IsServer() ? GetFailedServer(rpc) : GetFailedClient());
			if (array.Length == 0)
			{
				return true;
			}
			VersionCheck[] array2 = array;
			for (int i = 0; i < array2.Length; i++)
			{
				Debug.LogWarning((object)array2[i].Error(rpc));
			}
			if (__instance.IsServer())
			{
				DisconnectClient(rpc);
			}
			else
			{
				Logout();
			}
			return false;
		}

		[HarmonyPatch(typeof(ZNet), "OnNewConnection")]
		[HarmonyPrefix]
		private static void RegisterAndCheckVersion(ZNetPeer peer, ZNet __instance)
		{
			//IL_0186: Unknown result type (might be due to invalid IL or missing references)
			//IL_018d: Expected O, but got Unknown
			//IL_01e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f1: Expected I4, but got Unknown
			if (ZNet.instance.IsServer() && Configuration.ServerOnly)
			{
				return;
			}
			notProcessedNames.Clear();
			IDictionary dictionary = (IDictionary)typeof(ZRpc).GetField("m_functions", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(peer.m_rpc);
			if (dictionary.Contains(StringExtensionMethods.GetStableHashCode("ServerSync VersionCheck")))
			{
				object obj = dictionary[StringExtensionMethods.GetStableHashCode("ServerSync VersionCheck")];
				Action<ZRpc, ZPackage> action = (Action<ZRpc, ZPackage>)obj.GetType().GetField("m_action", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(obj);
				peer.m_rpc.Register<ZPackage>("ServerSync VersionCheck", (Action<ZRpc, ZPackage>)delegate(ZRpc rpc, ZPackage pkg)
				{
					CheckVersion(rpc, pkg, action);
				});
			}
			else
			{
				peer.m_rpc.Register<ZPackage>("ServerSync VersionCheck", (Action<ZRpc, ZPackage>)CheckVersion);
			}
			foreach (VersionCheck versionCheck in versionChecks)
			{
				versionCheck.Initialize();
				if (!versionCheck.ModRequired && !__instance.IsServer())
				{
					continue;
				}
				Debug.Log((object)("Sending " + versionCheck.DisplayName + " version " + versionCheck.CurrentVersion + " and minimum version " + versionCheck.MinimumRequiredVersion + " to the " + (__instance.IsServer() ? "client" : "server") + "."));
				ZPackage val = new ZPackage();
				val.Write(versionCheck.Name);
				val.Write(versionCheck.MinimumRequiredVersion);
				val.Write(versionCheck.CurrentVersion);
				if (ZNet.instance.IsServer() && versionCheck.SendBiomes)
				{
					foreach (KeyValuePair<Biome, string> item in BiomeManager.BiomeToDisplayName)
					{
						val.Write((int)item.Key);
						val.Write(item.Value);
					}
				}
				peer.m_rpc.Invoke("ServerSync VersionCheck", new object[1] { val });
			}
		}

		[HarmonyPatch(typeof(ZNet), "Disconnect")]
		[HarmonyPrefix]
		private static void RemoveDisconnected(ZNetPeer peer, ZNet __instance)
		{
			if (!__instance.IsServer())
			{
				return;
			}
			foreach (VersionCheck versionCheck in versionChecks)
			{
				versionCheck.ValidatedClients.Remove(peer.m_rpc);
			}
		}

		[HarmonyPatch(typeof(FejdStartup), "ShowConnectError")]
		[HarmonyPostfix]
		private static void ShowConnectionError(FejdStartup __instance)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Invalid comparison between Unknown and I4
			//IL_014e: 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_0161: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01be: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01de: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ee: Unknown result type (might be due to invalid IL or missing references)
			if (!__instance.m_connectionFailedPanel.activeSelf || (int)ZNet.GetConnectionStatus() != 3)
			{
				return;
			}
			bool flag = false;
			VersionCheck[] failedClient = GetFailedClient();
			if (failedClient.Length != 0)
			{
				string text = string.Join("\n", failedClient.Select((VersionCheck check) => check.Error()));
				TMP_Text connectionFailedError = __instance.m_connectionFailedError;
				connectionFailedError.text = connectionFailedError.text + "\n" + text;
				flag = true;
			}
			foreach (KeyValuePair<string, string> item in notProcessedNames.OrderBy<KeyValuePair<string, string>, string>((KeyValuePair<string, string> kv) => kv.Key))
			{
				if (!__instance.m_connectionFailedError.text.Contains(item.Key))
				{
					TMP_Text connectionFailedError2 = __instance.m_connectionFailedError;
					connectionFailedError2.text = connectionFailedError2.text + "\nServer expects you to have " + item.Key + " (Version: " + item.Value + ") installed.";
					flag = true;
				}
			}
			if (flag)
			{
				RectTransform component = ((Component)__instance.m_connectionFailedPanel.transform.Find("Image")).GetComponent<RectTransform>();
				Vector2 sizeDelta = component.sizeDelta;
				sizeDelta.x = 675f;
				component.sizeDelta = sizeDelta;
				__instance.m_connectionFailedError.ForceMeshUpdate(false, false);
				float num = __instance.m_connectionFailedError.renderedHeight + 105f;
				RectTransform component2 = ((Component)((Component)component).transform.Find("ButtonOk")).GetComponent<RectTransform>();
				component2.anchoredPosition = new Vector2(component2.anchoredPosition.x, component2.anchoredPosition.y - (num - component.sizeDelta.y) / 2f);
				sizeDelta = component.sizeDelta;
				sizeDelta.y = num;
				component.sizeDelta = sizeDelta;
			}
		}
	}
}
namespace ExpandWorldData
{
	public static class Api
	{
		public static float GetMinimapHeight(float height, Biome biome)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			if (!BiomeManager.TryGetData(biome, out BiomeData data))
			{
				return height;
			}
			if (height < WorldInfo.WaterLevel)
			{
				return height;
			}
			return (height - WorldInfo.WaterLevel) * data.mapColorMultiplier + WorldInfo.WaterLevel;
		}

		public static void AddBiome(BiomeYaml data)
		{
			BiomeManager.AddBiome(data);
		}

		public static void AddTerritory(TerritoryYaml data)
		{
			TerritoryManager.AddTerritory(data);
		}

		public static void AddClutter(ClutterYaml data)
		{
			ClutterManager.AddClutter(data);
		}

		public static void AddDungeon(DungeonYaml data)
		{
			Loader.AddDungeon(data);
		}

		public static void AddLocation(LocationYaml data)
		{
			LocationLoading.AddLocation(data);
		}

		public static void AddRoom(RoomYaml data)
		{
			RoomLoading.AddRoom(data);
		}

		public static void AddVegetation(VegetationYaml data)
		{
			VegetationLoading.AddVegetation(data);
		}

		public static void ChangeWorld(WorldYaml data, int index)
		{
			WorldManager.AddWorld(data, index);
		}

		public static HashSet<string> GetLocationGroups(ZoneLocation location)
		{
			if (!LocationExtra.TryGet(location, out LocationExtraInfo extra))
			{
				return new HashSet<string>();
			}
			return extra.Groups;
		}

		public static List<Tuple<string, float>>? GetLocationAwayFrom(ZoneLocation location)
		{
			if (!LocationExtra.TryGet(location, out LocationExtraInfo extra))
			{
				return null;
			}
			return extra.AwayFrom;
		}

		public static List<Tuple<string, float>>? GetLocationCloseTo(ZoneLocation location)
		{
			if (!LocationExtra.TryGet(location, out LocationExtraInfo extra))
			{
				return null;
			}
			return extra.CloseTo;
		}
	}
	[HarmonyPatch]
	public class TryParseBiome
	{
		private static IEnumerable<MethodBase> TargetMethods()
		{
			return (from method in (from method in typeof(Enum).GetMethods()
					where method.Name == "TryParse"
					select method).Take(2)
				select method.MakeGenericMethod(typeof(Biome))).Cast<MethodBase>();
		}

		private static bool Prefix(string value, ref Biome result, ref bool __result)
		{
			__result = BiomeManager.TryGetBiome(value, out result);
			return false;
		}
	}
	[HarmonyPatch]
	public class TryParseTheme
	{
		private static IEnumerable<MethodBase> TargetMethods()
		{
			return (from method in (from method in typeof(Enum).GetMethods()
					where method.Name == "TryParse"
					select method).Take(2)
				select method.MakeGenericMethod(typeof(Theme))).Cast<MethodBase>();
		}

		private static bool Prefix(string value, ref Theme result, ref bool __result)
		{
			__result = RoomLoading.TryGetTheme(value, out result);
			return false;
		}
	}
	[HarmonyPatch(typeof(Enum), "GetValues")]
	public class GetValues
	{
		private static bool Prefix(Type enumType, ref Array __result)
		{
			if (enumType == typeof(Biome))
			{
				__result = BiomeManager.BiomeToDisplayName.Keys.ToArray();
				return false;
			}
			if (enumType == typeof(Theme))
			{
				__result = RoomLoading.ThemeToName.Keys.ToArray();
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(Enum), "GetNames")]
	public class GetNames
	{
		private static bool Prefix(Type enumType, ref string[] __result)
		{
			if (enumType == typeof(Biome))
			{
				__result = BiomeManager.BiomeToDisplayName.Values.ToArray();
				return false;
			}
			if (enumType == typeof(Theme))
			{
				__result = RoomLoading.ThemeToName.Values.ToArray();
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(Enum), "GetName")]
	public class GetName
	{
		private static bool Prefix(Type enumType, object value, ref string __result)
		{
			//IL_0013: 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)
			if (enumType == typeof(Biome))
			{
				if (BiomeManager.TryGetDisplayName((Biome)value, out string name))
				{
					__result = name;
				}
				else
				{
					__result = "None";
				}
				return false;
			}
			if (enumType == typeof(Theme))
			{
				if (RoomLoading.ThemeToName.TryGetValue((Theme)value, out string value2))
				{
					__result = value2;
				}
				else
				{
					__result = ((int)value).ToString();
				}
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(Enum), "Parse", new Type[]
	{
		typeof(Type),
		typeof(string)
	})]
	public class EnumParse
	{
		private static bool Prefix(Type enumType, string value, ref object __result)
		{
			//IL_001d: 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)
			if (enumType == typeof(Biome) && BiomeManager.TryGetBiome(value, out var biome))
			{
				__result = biome;
				return false;
			}
			if (enumType == typeof(Theme) && RoomLoading.TryGetTheme(value, out var theme))
			{
				__result = theme;
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(Enum), "Parse", new Type[]
	{
		typeof(Type),
		typeof(string),
		typeof(bool)
	})]
	public class ParseIgnoreCase
	{
		private static bool Prefix(Type enumType, string value, ref object __result)
		{
			//IL_001d: 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)
			if (enumType == typeof(Biome) && BiomeManager.TryGetBiome(value, out var biome))
			{
				__result = biome;
				return false;
			}
			if (enumType == typeof(Theme) && RoomLoading.TryGetTheme(value, out var theme))
			{
				__result = theme;
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(ZNet), "RPC_PeerInfo")]
	public class IdManager
	{
		public static string RPC_RequestIds = "EW_RequestIds";

		public static string RPC_SyncLocationIds = "EW_SyncLocationIds";

		public static string RPC_SyncVegetationIds = "EW_SyncVegetationIds";

		private static readonly List<ZRpc> RegisteredIdClients = new List<ZRpc>();

		private static bool IsAllowed(ZRpc rpc)
		{
			ZNet instance = ZNet.instance;
			if (!((Behaviour)instance).enabled)
			{
				return false;
			}
			if (rpc != null)
			{
				return instance.IsAdmin(rpc.GetSocket().GetHostName());
			}
			return false;
		}

		private static void RPC_RegisterIdSyncing(ZRpc rpc)
		{
			if (IsAllowed(rpc) && !RegisteredIdClients.Contains(rpc))
			{
				RegisteredIdClients.Add(rpc);
				rpc.Invoke(RPC_SyncLocationIds, new object[1] { LocationIds() });
				rpc.Invoke(RPC_SyncVegetationIds, new object[1] { VegetationIds() });
			}
		}

		public static void SendLocationIds()
		{
			string text = LocationIds();
			foreach (ZRpc registeredIdClient in RegisteredIdClients)
			{
				if (registeredIdClient.IsConnected())
				{
					registeredIdClient.Invoke(RPC_SyncLocationIds, new object[1] { text });
				}
				else
				{
					RegisteredIdClients.Remove(registeredIdClient);
				}
			}
		}

		private static string LocationIds()
		{
			List<string> list = new List<string>();
			list.AddRange((from l in ZoneSystem.instance.m_locations.Where(IsValid)
				select l.m_prefab.Name).Distinct());
			return string.Join("|", list.ToArray());
		}

		private static bool IsValid(ZoneLocation loc)
		{
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			if (loc != null)
			{
				_ = loc.m_prefab;
				if (!loc.m_prefab.IsValid)
				{
					return loc.m_prefab.m_name != null;
				}
				return true;
			}
			return false;
		}

		public static void SendVegetationIds()
		{
			string text = VegetationIds();
			foreach (ZRpc registeredIdClient in RegisteredIdClients)
			{
				if (registeredIdClient.IsConnected())
				{
					registeredIdClient.Invoke(RPC_SyncVegetationIds, new object[1] { text });
				}
				else
				{
					RegisteredIdClients.Remove(registeredIdClient);
				}
			}
		}

		private static string VegetationIds()
		{
			List<string> list = new List<string>();
			list.AddRange((from v in ZoneSystem.instance.m_vegetation.Where(IsValid)
				select v.m_name).Distinct());
			return string.Join("|", list.ToArray());
		}

		private static bool IsValid(ZoneVegetation veg)
		{
			if (veg != null)
			{
				return (Object)(object)veg.m_prefab != (Object)null;
			}
			return false;
		}

		private static void Postfix(ZNet __instance, ZRpc rpc)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Expected O, but got Unknown
			RegisteredIdClients.Clear();
			if (__instance.IsServer())
			{
				rpc.Register(RPC_RequestIds, new Method(RPC_RegisterIdSyncing));
			}
		}
	}
	public class WorldInfo
	{
		public static float WaterLevel = 30f;

		public static float Radius = 10000f;

		public static float TotalRadius = 10500f;

		public static float Stretch = 1f;

		public static float BiomeStretch = 1f;

		public static void Set(float radius, float totalRadius, float stretch, float biomeStretch)
		{
			if (Radius != radius || TotalRadius != totalRadius || Stretch != stretch || BiomeStretch != biomeStretch)
			{
				Radius = radius;
				TotalRadius = totalRadius;
				Stretch = stretch;
				BiomeStretch = biomeStretch;
				WorldManager.Reload();
			}
		}

		public static void SetWaterLevel(float waterLevel)
		{
			WaterLevel = waterLevel;
		}

		public static void AutomaticRegenerate(Harmony harmony)
		{
			if (WorldGenerator.instance != null)
			{
				Log.Info("Regenerating the world.");
				CheckPatches(harmony);
				WorldGenerator.instance.Pregenerate();
				Heightmap[] array = Object.FindObjectsByType<Heightmap>((FindObjectsInactive)0, (FindObjectsSortMode)0);
				foreach (Heightmap obj in array)
				{
					obj.m_buildData = null;
					obj.Regenerate();
				}
				WaterColor.Regenerate();
				ClutterSystem instance = ClutterSystem.instance;
				if (instance != null)
				{
					instance.ClearAll();
				}
				if (Configuration.RegenerateMap)
				{
					RegenerateMap();
				}
			}
		}

		public static void RegenerateMap()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Invalid comparison between Unknown and I4
			if ((int)SystemInfo.graphicsDeviceType != 4)
			{
				Minimap instance = Minimap.instance;
				if (instance != null)
				{
					instance.GenerateWorldMap();
				}
			}
		}

		public static void CheckPatches(Harmony harmony)
		{
			GetAshlandsHeight.Patch(harmony, Configuration.AshlandsWidthRestriction, Configuration.AshlandsLengthRestriction);
			CreateAshlandsGap.Patch(harmony, !Configuration.AshlandsGap);
			CreateDeepNorthGap.Patch(harmony, !Configuration.DeepNorthGap);
		}
	}
	[HarmonyPatch(typeof(WorldGenerator), "Pregenerate")]
	[HarmonyPriority(500)]
	public class Pregenerate
	{
		private static void Prefix(WorldGenerator __instance)
		{
			//IL_0042: 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)
			__instance.m_riverCacheLock.EnterWriteLock();
			__instance.m_riverPoints = new Dictionary<Vector2i, RiverPoint[]>();
			__instance.m_rivers = new List<River>();
			__instance.m_streams = new List<River>();
			__instance.m_lakes = new List<Vector2>();
			__instance.m_cachedRiverGrid = new Vector2i(-999999, -999999);
			__instance.m_cachedRiverPoints = Array.Empty<RiverPoint>();
			__instance.m_riverCacheLock.ExitWriteLock();
		}
	}
	public class Configuration
	{
		public static ConfigEntry<bool> configServerOnly;

		public static ConfigEntry<bool> configSplitDataPerMod;

		public static ConfigEntry<bool> configLegacyGeneration;

		public static ConfigEntry<bool> configRegenerateMap;

		public static ConfigEntry<bool> configCustomWaterColor;

		public static ConfigEntry<bool> configZoneSpawners;

		public static ConfigEntry<bool> configRandomLocations;

		public static ConfigEntry<bool> configScaleLocationAltitudeRequirement;

		public static ConfigEntry<string> configDistanceWiggleLength;

		public static ConfigEntry<string> configDistanceWiggleWidth;

		public static ConfigEntry<string> configWiggleFrequency;

		public static ConfigEntry<string> configWiggleWidth;

		public static ConfigEntry<string> configAshlandsWidthRestriction;

		public static ConfigEntry<string> configAshlandsLengthRestriction;

		public static ConfigEntry<bool> configRestrictAshlands;

		public static ConfigEntry<bool> configAshlandsGap;

		public static ConfigEntry<bool> configDeepNorthGap;

		public static CustomSyncedValue<string> valueBiomeData;

		public static CustomSyncedValue<string> valueTerritoryData;

		public static CustomSyncedValue<string> valueWorldData;

		public static CustomSyncedValue<string> valueClutterData;

		public static CustomSyncedValue<string> valueEnvironmentData;

		public static CustomSyncedValue<string> valueNoBuildData;

		public static ConfigEntry<bool> configDataEnvironments;

		public static ConfigEntry<bool> configDataVegetation;

		public static ConfigEntry<bool> configDataClutter;

		public static ConfigEntry<bool> configDataDungeons;

		public static ConfigEntry<bool> configDataRooms;

		public static ConfigEntry<bool> configDataLocation;

		public static ConfigEntry<bool> configDataBiome;

		public static ConfigEntry<bool> configDataTerritory;

		public static ConfigEntry<bool> configDataWorld;

		public static ConfigEntry<bool> configDataMigration;

		public static ConfigEntry<bool> configDataReload;

		public static ConfigEntry<string> configBlueprintFolder;

		public static bool ServerOnly => configServerOnly.Value;

		public static bool SplitDataPerMod => configSplitDataPerMod.Value;

		public static bool LegacyGeneration => configLegacyGeneration.Value;

		public static bool RegenerateMap => configRegenerateMap.Value;

		public static bool CustomWaterColor => configCustomWaterColor.Value;

		public static bool ZoneSpawners => configZoneSpawners.Value;

		public static bool RandomLocations => configRandomLocations.Value;

		public static bool ScaleLocationAltitudeRequirement => configScaleLocationAltitudeRequirement.Value;

		public static float DistanceWiggleLength => ConfigWrapper.Floats[configDistanceWiggleLength];

		public static float DistanceWiggleWidth => ConfigWrapper.Floats[configDistanceWiggleWidth];

		public static float WiggleFrequency => ConfigWrapper.Floats[configWiggleFrequency];

		public static float WiggleWidth => ConfigWrapper.Floats[configWiggleWidth];

		public static double AshlandsWidthRestriction
		{
			get
			{
				if (!RestrictAshlands)
				{
					return double.PositiveInfinity;
				}
				return ConfigWrapper.Floats[configAshlandsWidthRestriction];
			}
		}

		public static double AshlandsLengthRestriction
		{
			get
			{
				if (!RestrictAshlands)
				{
					return double.PositiveInfinity;
				}
				return ConfigWrapper.Floats[configAshlandsLengthRestriction];
			}
		}

		public static bool RestrictAshlands => configRestrictAshlands.Value;

		public static bool AshlandsGap => configAshlandsGap.Value;

		public static bool DeepNorthGap => configDeepNorthGap.Value;

		public static bool DataEnvironments => configDataEnvironments.Value;

		public static bool DataVegetation => configDataVegetation.Value;

		public static bool DataClutter => configDataClutter.Value;

		public static bool DataDungeons => configDataDungeons.Value;

		public static bool DataRooms => configDataRooms.Value;

		public static bool DataLocation => configDataLocation.Value;

		public static bool DataBiome => configDataBiome.Value;

		public static bool DataTerritory => configDataTerritory.Value;

		public static bool DataWorld => configDataWorld.Value;

		public static bool DataMigration => configDataMigration.Value;

		public static bool DataReload => configDataReload.Value;

		public static string BlueprintGlobalFolder => Path.Combine("BepInEx", "config", configBlueprintFolder.Value);

		public static string BlueprintLocalFolder => Path.Combine(Paths.ConfigPath, configBlueprintFolder.Value);

		public static void Init(ConfigWrapper wrapper)
		{
			string text = "1. General";
			configRegenerateMap = wrapper.Bind(text, "Regenerate map", value: true, forceRegen: false, "If true, the world map is regenerated automatically on data changes.");
			configServerOnly = wrapper.Bind(text, "Server only", value: false, forceRegen: false, "If true, enables server side only mode and clients can't have the mod installed.");
			configLegacyGeneration = wrapper.Bind(text, "Legacy generation", value: false, forceRegen: true, "Old Expand World had a bug that cause incorrect generation near biome borders. Set this true for older worlds.");
			configZoneSpawners = wrapper.Bind(text, "Zone spawners", value: true, forceRegen: false, "If disabled, zone spawners are not generated.");
			configRandomLocations = wrapper.Bind(text, "Random locations", value: false, forceRegen: false, "If true, all locations have a random generation instead of depending on the location coordinates.");
			text = "2. Features";
			configDistanceWiggleLength = wrapper.BindFloat(text, "Distance wiggle length", 500f, forceRegen: false);
			configDistanceWiggleLength.SettingChanged += delegate
			{
				WorldManager.ReadConfigs();
			};
			configDistanceWiggleWidth = wrapper.BindFloat(text, "Distance wiggle width", 0.01f, forceRegen: false);
			configDistanceWiggleWidth.SettingChanged += delegate
			{
				WorldManager.ReadConfigs();
			};
			configWiggleFrequency = wrapper.BindFloat(text, "Wiggle frequency", 20f, forceRegen: false, "How many wiggles are per each circle.");
			configWiggleFrequency.SettingChanged += delegate
			{
				WorldManager.ReadConfigs();
			};
			configWiggleWidth = wrapper.BindFloat(text, "Wiggle width", 100f, forceRegen: false, "How many meters are the wiggles.");
			configWiggleWidth.SettingChanged += delegate
			{
				WorldManager.ReadConfigs();
			};
			configScaleLocationAltitudeRequirement = wrapper.Bind(text, "Scale location altitude requirement", value: false, forceRegen: false, "If true, location requirements are scaled based on the biome altitude delta and multiplier.");
			configCustomWaterColor = wrapper.Bind(text, "Custom water color", value: false, forceRegen: false, "If true, custom water color system is enabled.");
			text = "3. Data";
			configDataReload = wrapper.Bind(text, "Automatic data reload", value: true, forceRegen: false, "Data is loaded automatically on file changes. Requires restart to take effect.");
			configSplitDataPerMod = wrapper.Bind(text, "Split data per mod", value: true, forceRegen: false, "If true, created data is saved to multiple files. If false, all data is saved in one file.");
			configDataMigration = wrapper.Bind(text, "Automatic data migration", value: true, forceRegen: false, "Automatically add missing location, rooms and vegetation entries.");
			configDataEnvironments = wrapper.Bind(text, "Environment data", value: true, forceRegen: false, "Use environment data");
			configDataEnvironments.SettingChanged += delegate
			{
				EnvironmentManager.FromSetting(valueEnvironmentData.Value);
			};
			configDataBiome = wrapper.Bind(text, "Biome data", value: true, forceRegen: true, "Use biome data");
			configDataBiome.SettingChanged += delegate
			{
				BiomeManager.FromSetting(valueBiomeData.Value);
			};
			configDataTerritory = wrapper.Bind(text, "Territory data", value: true, forceRegen: true, "Use territory data");
			configDataTerritory.SettingChanged += delegate
			{
				TerritoryManager.FromSetting(valueTerritoryData.Value);
			};
			configDataClutter = wrapper.Bind(text, "Clutter data", value: true, forceRegen: false, "Use clutter data");
			configDataClutter.SettingChanged += delegate
			{
				ClutterManager.ReadConfigs();
			};
			configDataDungeons = wrapper.Bind(text, "Dungeon data", value: true, forceRegen: false, "Use dungeon data");
			configDataDungeons.SettingChanged += delegate
			{
				Loader.Load();
			};
			configDataRooms = wrapper.Bind(text, "Room data", value: true, forceRegen: false, "Use dungeon room data");
			configDataRooms.SettingChanged += delegate
			{
				RoomLoading.Load();
			};
			configDataWorld = wrapper.Bind(text, "World data", value: true, forceRegen: true, "Use world data");
			configDataWorld.SettingChanged += delegate
			{
				WorldManager.FromSetting(valueWorldData.Value);
			};
			configDataLocation = wrapper.Bind(text, "Location data", value: true, forceRegen: false, "Use location data");
			configDataLocation.SettingChanged += delegate
			{
				LocationLoading.ReadConfigs();
			};
			configDataVegetation = wrapper.Bind(text, "Vegetation data", value: true, forceRegen: false, "Use vegetation data");
			configDataVegetation.SettingChanged += delegate
			{
				VegetationLoading.ReadConfigs();
			};
			configBlueprintFolder = wrapper.Bind(text, "Blueprint folder", "PlanBuild", forceRegen: false, "Folder relative to the config folder.");
			valueNoBuildData = wrapper.AddValue("no_build_data");
			valueNoBuildData.ValueChanged += delegate
			{
				NoBuildManager.Apply(valueNoBuildData.Value);
			};
			valueEnvironmentData = wrapper.AddValue("environment_data");
			valueEnvironmentData.ValueChanged += delegate
			{
				EnvironmentManager.FromSetting(valueEnvironmentData.Value);
			};
			valueBiomeData = wrapper.AddValue("biome_data");
			valueBiomeData.ValueChanged += delegate
			{
				BiomeManager.FromSetting(valueBiomeData.Value);
			};
			valueTerritoryData = wrapper.AddValue("territory_data");
			valueTerritoryData.ValueChanged += delegate
			{
				TerritoryManager.FromSetting(valueTerritoryData.Value);
			};
			valueClutterData = wrapper.AddValue("clutter_data");
			valueClutterData.ValueChanged += delegate
			{
				ClutterManager.Set(valueClutterData.Value);
			};
			valueWorldData = wrapper.AddValue("world_data");
			valueWorldData.ValueChanged += delegate
			{
				WorldManager.FromSetting(valueWorldData.Value);
			};
			text = "4. Poles";
			configRestrictAshlands = wrapper.Bind(text, "Restrict Ashlands position", value: true, forceRegen: true, "If true, restricts Ashlands biome position.");
			configAshlandsWidthRestriction = wrapper.BindFloat(text, "Ashlands width restriction", 7500f, forceRegen: true, "How wide is the Ashlands biome (meters).");
			configAshlandsLengthRestriction = wrapper.BindFloat(text, "Ashlands length restriction", 1000f, forceRegen: true, "How long/deep is the Ashlands biome (meters).");
			configAshlandsGap = wrapper.Bind(text, "Ashlands gap", value: true, forceRegen: true, "If true, Ashlands biome has an Ocean gap above it.");
			configDeepNorthGap = wrapper.Bind(text, "Deep North gap", value: true, forceRegen: true, "If true, Deep North biome has an Ocean gap below it.");
		}
	}
	public class BlueprintMetaData(string[] snapPieces)
	{
		public string[] SnapPieces = snapPieces;
	}
	public class BlueprintManager
	{
		public static Dictionary<string, Blueprint> BlueprintFiles = new Dictionary<string, Blueprint>();

		private static readonly Dictionary<string, BlueprintMetaData> MetaData = new Dictionary<string, BlueprintMetaData>();

		public static bool Has(string name)
		{
			return BlueprintFiles.ContainsKey(Parse.Name(name));
		}

		public static bool TryGet(string name, out Blueprint bp)
		{
			if (!Has(name))
			{
				Load(name);
			}
			return BlueprintFiles.TryGetValue(Parse.Name(name), out bp);
		}

		public static bool Load(string name)
		{
			return Load(name, Array.Empty<string>());
		}

		public static bool Load(string name, string[] snapPieces)
		{
			int stableHashCode = StringExtensionMethods.GetStableHashCode(name);
			if (ZNetScene.instance.m_namedPrefabs.ContainsKey(stableHashCode))
			{
				return true;
			}
			if (BlueprintFiles.ContainsKey(name) && MetaData.TryGetValue(name, out BlueprintMetaData value) && value.snapPieces == snapPieces)
			{
				return true;
			}
			if (Blueprints.TryGetBluePrint(name, out Blueprint blueprint))
			{
				MetaData[name] = new BlueprintMetaData(snapPieces);
				blueprint.LoadSnapPoints(snapPieces);
				blueprint.Center();
				BlueprintFiles[name] = blueprint;
				foreach (BlueprintObject @object in blueprint.Objects)
				{
					if (@object.Chance != 0f)
					{
						Load(@object.Prefab, snapPieces);
					}
				}
				return true;
			}
			Log.Warning("Object / blueprint " + name + " not found!");
			return false;
		}

		public static void Reload(string name)
		{
			if (Has(name) && Blueprints.TryGetBluePrint(name, out Blueprint _))
			{
				Log.Info("Reloading blueprint " + name + ".");
				BlueprintFiles.Remove(name);
				if (MetaData.TryGetValue(name, out BlueprintMetaData value))
				{
					Load(name, value.snapPieces);
				}
				else
				{
					Load(name);
				}
			}
		}

		private static void ReloadBlueprint(string name)
		{
			Reload(Path.GetFileNameWithoutExtension(name));
		}

		public static void SetupBlueprintWatcher()
		{
			if (!Directory.Exists(Configuration.BlueprintGlobalFolder))
			{
				Directory.CreateDirectory(Configuration.BlueprintGlobalFolder);
			}
			if (!Directory.Exists(Configuration.BlueprintLocalFolder))
			{
				Directory.CreateDirectory(Configuration.BlueprintLocalFolder);
			}
			Yaml.SetupWatcher(Configuration.BlueprintGlobalFolder, "*.blueprint", ReloadBlueprint);
			Yaml.SetupWatcher(Configuration.BlueprintGlobalFolder, "*.vbuild", ReloadBlueprint);
			if (Path.GetFullPath(Configuration.BlueprintLocalFolder) != Path.GetFullPath(Configuration.BlueprintGlobalFolder))
			{
				Yaml.SetupWatcher(Configuration.BlueprintLocalFolder, "*.blueprint", ReloadBlueprint);
				Yaml.SetupWatcher(Configuration.BlueprintLocalFolder, "*.vbuild", ReloadBlueprint);
			}
		}
	}
	public class BlueprintObject
	{
		public string Prefab = "";

		public Vector3 Pos;

		public Quaternion Rot;

		public DataEntry? Data;

		public float Chance = 1f;

		public Vector3? Scale;

		public bool SnapToGround;

		public BlueprintObject(string name, Vector3 pos, Quaternion rot, Vector3 scale, DataEntry? data, float chance, bool snapToGround = false)
		{
			//IL_0024: 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_002d: 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_0051: 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)
			Prefab = name;
			Pos = pos;
			Rot = ((Quaternion)(ref rot)).normalized;
			Data = data;
			Chance = chance;
			SnapToGround = snapToGround;
			if (scale != Vector3.one)
			{
				Scale = scale;
			}
		}
	}
	public class SnapPoint
	{
		public Vector3 Pos;

		public Quaternion Rot;

		public SnapPoint(Vector3 pos, Quaternion rot)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			Pos = pos;
			Rot = rot;
		}
	}
	public class Blueprint
	{
		public string Name;

		public List<BlueprintObject> Objects = new List<BlueprintObject>();

		public string CenterPiece = "piece_bpcenterpoint";

		public float Radius;

		public List<SnapPoint> SnapPoints = new List<SnapPoint>();

		public Vector3 Size = Vector3.one;

		public Blueprint(string name)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			Name = name;
		}

		private void AddSnapPoint(Vector3 pos, Quaternion rot, int index)
		{
			//IL_0028: 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_0014: 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)
			if (SnapPoints.Count <= index)
			{
				SnapPoints.Add(new SnapPoint(pos, rot));
			}
			else
			{
				SnapPoints[index] = new SnapPoint(pos, rot);
			}
		}

		public void LoadSnapPoints(string[] snapPieces)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: 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_002a: 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_0087: Unknown result type (might be due to invalid IL or missing references)
			for (int i = 0; i < snapPieces.Length; i++)
			{
				string text = snapPieces[i];
				if (text.Split(new char[1] { ',' }).Length == 3)
				{
					Vector3 pos = Parse.VectorXZY(text);
					AddSnapPoint(pos, Quaternion.identity, i);
					continue;
				}
				bool flag = false;
				foreach (BlueprintObject @object in Objects)
				{
					if (!(@object.Prefab != text) && @object.Chance != 0f)
					{
						@object.Chance = 0f;
						AddSnapPoint(@object.Pos, @object.Rot, i);
						flag = true;
						break;
					}
				}
				if (!flag)
				{
					Log.Warning("Snap point piece " + text + " not found in blueprint " + Name + ".");
				}
			}
		}

		public void Center()
		{
			//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_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: 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_007f: 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_00c9: 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_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_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: 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_0132: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: 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_0156: Unknown result type (might be due to invalid IL or missing references)
			//IL_017c: 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_0189: Unknown result type (might be due to invalid IL or missing references)
			//IL_0190: Unknown result type (might be due to invalid IL or missing references)
			//IL_0193: Unknown result type (might be due to invalid IL or missing references)
			//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)
			Bounds val = default(Bounds);
			float num = float.MaxValue;
			Quaternion val2 = Quaternion.identity;
			foreach (BlueprintObject @object in Objects)
			{
				num = Mathf.Min(num, @object.Pos.y);
				((Bounds)(ref val)).Encapsulate(@object.Pos);
			}
			num += 0.05f;
			Size = ((Bounds)(ref val)).size;
			Vector3 pos = default(Vector3);
			((Vector3)(ref pos))..ctor(((Bounds)(ref val)).center.x, num, ((Bounds)(ref val)).center.z);
			foreach (BlueprintObject object2 in Objects)
			{
				if (object2.Prefab == CenterPiece)
				{
					pos = object2.Pos;
					val2 = Quaternion.Inverse(object2.Rot);
					object2.Chance = 0f;
					break;
				}
			}
			Radius = Utils.LengthXZ(((Bounds)(ref val)).extents);
			foreach (BlueprintObject object3 in Objects)
			{
				object3.Pos -= pos;
			}
			if (!(val2 != Quaternion.identity))
			{
				return;
			}
			foreach (BlueprintObject object4 in Objects)
			{
				object4.Pos = val2 * object4.Pos;
				object4.Rot = val2 * object4.Rot;
			}
		}
	}
	public class Blueprints
	{
		private static IEnumerable<string> LoadFiles(string folder, IEnumerable<string> bps)
		{
			if (Directory.Exists(folder))
			{
				IEnumerable<string> second = Directory.EnumerateFiles(folder, "*.blueprint", SearchOption.AllDirectories);
				IEnumerable<string> second2 = Directory.EnumerateFiles(folder, "*.vbuild", SearchOption.AllDirectories);
				return bps.Concat(second).Concat(second2);
			}
			return bps;
		}

		private static IEnumerable<string> Files()
		{
			IEnumerable<string> bps = Array.Empty<string>();
			bps = LoadFiles(Configuration.BlueprintGlobalFolder, bps);
			if (Path.GetFullPath(Configuration.BlueprintLocalFolder) != Path.GetFullPath(Configuration.BlueprintGlobalFolder))
			{
				bps = LoadFiles(Configuration.BlueprintLocalFolder, bps);
			}
			return from s in bps.Distinct()
				orderby s
				select s;
		}

		public static bool TryGetBluePrint(string name, out Blueprint blueprint)
		{
			blueprint = new Blueprint("Invalid");
			Blueprint bluePrint = GetBluePrint(name);
			if (bluePrint == null)
			{
				return false;
			}
			blueprint = bluePrint;
			return true;
		}

		public static Blueprint? GetBluePrint(string name)
		{
			name = name.Replace(" ", "_");
			string text = Files().FirstOrDefault((string path) => Path.GetFileNameWithoutExtension(path).Replace(" ", "_") == name);
			if (text == null)
			{
				return null;
			}
			string[] rows = File.ReadAllLines(text);
			string extension = Path.GetExtension(text);
			Blueprint bp = new Blueprint(name);
			if (extension == ".vbuild")
			{
				return GetBuildShare(bp, rows);
			}
			if (extension == ".blueprint")
			{
				return GetPlanBuild(bp, rows);
			}
			throw new InvalidOperationException("Unknown file format.");
		}

		private static Blueprint? GetPlanBuild(Blueprint bp, string[] rows)
		{
			//IL_009e: 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)
			bool flag = true;
			int num = -1;
			try
			{
				foreach (string text in rows)
				{
					num++;
					if (text.StartsWith("#snappoints", StringComparison.OrdinalIgnoreCase))
					{
						flag = false;
					}
					else if (text.StartsWith("#pieces", StringComparison.OrdinalIgnoreCase))
					{
						flag = true;
					}
					else if (text.StartsWith("#center:", StringComparison.OrdinalIgnoreCase))
					{
						bp.CenterPiece = text.Split(new char[1] { ':' })[1];
					}
					else if (!text.StartsWith("#", StringComparison.Ordinal))
					{
						if (flag)
						{
							bp.Objects.Add(GetPlanBuildObject(text, bp.Name));
						}
						else
						{
							bp.SnapPoints.Add(new SnapPoint(GetPlanBuildSnapPoint(text), Quaternion.identity));
						}
					}
				}
				return bp;
			}
			catch
			{
				Log.Error($"Failed to load blueprint {bp.Name} at row {num}: {rows[num]}.");
				return null;
			}
		}

		private static BlueprintObject GetPlanBuildObject(string row, string fileName)
		{
			//IL_00de: 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_00f6: Unknown result type (might be due to invalid IL or missing references)
			if (row.IndexOf(',') > -1)
			{
				row = row.Replace(',', '.');
			}
			string[] array = row.Split(new char[1] { ';' });
			string name = array[0];
			float num = InvariantFloat(array, 2);
			float num2 = InvariantFloat(array, 3);
			float num3 = InvariantFloat(array, 4);
			float num4 = InvariantFloat(array, 5);
			float num5 = InvariantFloat(array, 6);
			float num6 = InvariantFloat(array, 7);
			float num7 = InvariantFloat(array, 8);
			float num8 = InvariantFloat(array, 10, 1f);
			float num9 = InvariantFloat(array, 11, 1f);
			float num10 = InvariantFloat(array, 12, 1f);
			string name2 = ((array.Length > 13) ? array[13] : "");
			return new BlueprintObject(chance: InvariantFloat(array, 14, 1f), name: name, pos: new Vector3(num, num2, num3), rot: new Quaternion(num4, num5, num6, num7), scale: new Vector3(num8, num9, num10), data: DataHelper.Get(name2, fileName));
		}

		private static Vector3 GetPlanBuildSnapPoint(string row)
		{
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			if (row.IndexOf(',') > -1)
			{
				row = row.Replace(',', '.');
			}
			string[] row2 = row.Split(new char[1] { ';' });
			float num = InvariantFloat(row2, 0);
			float num2 = InvariantFloat(row2, 1);
			float num3 = InvariantFloat(row2, 2);
			return new Vector3(num, num2, num3);
		}

		private static Blueprint GetBuildShare(Blueprint bp, string[] rows)
		{
			bp.Objects = rows.Select((string r) => GetBuildShareObject(r, bp.Name)).ToList();
			return bp;
		}

		private static BlueprintObject GetBuildShareObject(string row, string fileName)
		{
			//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)
			if (row.IndexOf(',') > -1)
			{
				row = row.Replace(',', '.');
			}
			string[] array = row.Split(new char[1] { ' ' });
			string name = array[0];
			float num = InvariantFloat(array, 1);
			float num2 = InvariantFloat(array, 2);
			float num3 = InvariantFloat(array, 3);
			float num4 = InvariantFloat(array, 4);
			float num5 = InvariantFloat(array, 5);
			float num6 = InvariantFloat(array, 6);
			float num7 = InvariantFloat(array, 7);
			string name2 = ((array.Length > 8) ? array[8] : "");
			return new BlueprintObject(chance: (array.Length > 9) ? InvariantFloat(array, 9, 1f) : 1f, name: name, pos: new Vector3(num5, num6, num7), rot: new Quaternion(num, num2, num3, num4), scale: Vector3.one, data: DataHelper.Get(name2, fileName));
		}

		private static float InvariantFloat(string[] row, int index, float defaultValue = 0f)
		{
			if (index >= row.Length)
			{
				return defaultValue;
			}
			string text = row[index];
			if (string.IsNullOrEmpty(text))
			{
				return defaultValue;
			}
			return float.Parse(text, NumberStyles.Any, NumberFormatInfo.InvariantInfo);
		}
	}
	public class ClutterYaml
	{
		public string prefab = "";

		[DefaultValue(true)]
		public bool enabled = true;

		public int amount = 80;

		[DefaultValue("")]
		public string biome = "";

		[DefaultValue(false)]
		public bool instanced;

		[DefaultValue(true)]
		public bool onUncleared = true;

		[DefaultValue(false)]
		public bool onCleared;

		[DefaultValue(1f)]
		public float scaleMin = 1f;

		[DefaultValue(1f)]
		public float scaleMax = 1f;

		[DefaultValue(0f)]
		public float minTilt;

		[DefaultValue(10f)]
		public float maxTilt = 10f;

		[DefaultValue(-1000f)]
		public float minAltitude = -1000f;

		[DefaultValue(10000f)]
		public float maxAltitude = 10000f;

		[DefaultValue(0f)]
		public float minVegetation;

		[DefaultValue(0f)]
		public float maxVegetation;

		[DefaultValue(false)]
		public bool snapToWater;

		[DefaultValue(false)]
		public bool terrainTilt;

		[DefaultValue(0f)]
		public float randomOffset;

		[DefaultValue(0f)]
		public float minOceanDepth;

		[DefaultValue(0f)]
		public float maxOceanDepth;

		[DefaultValue(false)]
		public bool inForest;

		[DefaultValue(0f)]
		public float forestTresholdMin;

		[DefaultValue(1f)]
		public float forestTresholdMax = 1f;

		[DefaultValue(0f)]
		public float fractalScale;

		[DefaultValue(0f)]
		public float fractalOffset;

		[DefaultValue(0f)]
		public float fractalThresholdMin;

		[DefaultValue(1f)]
		public float fractalThresholdMax = 1f;
	}
	[HarmonyPatch]
	public class ClutterManager
	{
		public static string FileName = "expand_clutter.yaml";

		public static string FilePath = Path.Combine(Yaml.BaseDirectory, FileName);

		public static string Pattern = "expand_clutter*.yaml";

		private static readonly List<ClutterYaml> ExtraClutterYamls = new List<ClutterYaml>();

		private static List<Clutter> DefaultEntries = new List<Clutter>();

		private static Dictionary<string, GameObject> Prefabs = new Dictionary<string, GameObject>();

		private static bool Initialized;

		private static bool Pending;

		public static void AddClutter(ClutterYaml yaml)
		{
			ExtraClutterYamls.Add(yaml);
		}

		private static void SaveDefaultFile()
		{
			List<ClutterYaml> list = DefaultEntries.Select(ToData).ToList();
			if (ExtraClutterYamls.Count > 0)
			{
				list.AddRange(ExtraClutterYamls);
			}
			Save(list, log: false);
		}

		public static void Initialize()
		{
			Prefabs = Helper.ToDict(ClutterSystem.instance.m_clutter, (Clutter item) => ((Object)item.m_prefab).name, (Clutter item) => item.m_prefab);
			List<Clutter> clutter = ClutterSystem.instance.m_clutter;
			List<Clutter> list = new List<Clutter>(clutter.Count);
			list.AddRange(clutter);
			DefaultEntries = list;
		}

		public static void Load()
		{
			Initialized = true;
			if (Pending)
			{
				Pending = false;
				Set(Configuration.valueClutterData.Value);
			}
		}

		public static Clutter FromData(ClutterYaml data, string fileName)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Expected O, but got Unknown
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			Clutter val = new Clutter();
			if (Prefabs.TryGetValue(data.prefab, out GameObject value))
			{
				val.m_prefab = value;
			}
			else
			{
				Log.Warning(fileName + ": Failed to find clutter prefab " + data.prefab + ".");
			}
			val.m_enabled = data.enabled;
			val.m_amount = data.amount;
			val.m_biome = DataManager.ToBiomes(data.biome, fileName);
			val.m_instanced = data.instanced;
			val.m_onUncleared = data.onUncleared;
			val.m_onCleared = data.onCleared;
			val.m_scaleMin = data.scaleMin;
			val.m_scaleMax = data.scaleMax;
			val.m_maxTilt = data.maxTilt;
			val.m_minTilt = data.minTilt;
			val.m_maxAlt = data.maxAltitude;
			val.m_minAlt = data.minAltitude;
			val.m_maxVegetation = data.maxVegetation;
			val.m_minVegetation = data.minVegetation;
			val.m_snapToWater = data.snapToWater;
			val.m_terrainTilt = data.terrainTilt;
			val.m_randomOffset = data.randomOffset;
			val.m_minOceanDepth = data.minOceanDepth;
			val.m_maxOceanDepth = data.maxOceanDepth;
			val.m_inForest = data.inForest;
			val.m_forestTresholdMin = data.forestTresholdMin;
			val.m_forestTresholdMax = data.forestTresholdMax;
			val.m_fractalScale = data.fractalScale;
			val.m_fractalOffset = data.fractalOffset;
			val.m_fractalTresholdMin = data.fractalThresholdMin;
			val.m_fractalTresholdMax = data.fractalThresholdMax;
			return val;
		}

		public static ClutterYaml ToData(Clutter clutter)
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			return new ClutterYaml
			{
				prefab = ((Object)clutter.m_prefab).name,
				enabled = clutter.m_enabled,
				amount = clutter.m_amount,
				biome = DataManager.FromBiomes(clutter.m_biome),
				instanced = clutter.m_instanced,
				onUncleared = clutter.m_onUncleared,
				onCleared = clutter.m_onCleared,
				scaleMin = clutter.m_scaleMin,
				scaleMax = clutter.m_scaleMax,
				maxTilt = clutter.m_maxTilt,
				minTilt = clutter.m_minTilt,
				maxAltitude = clutter.m_maxAlt,
				minAltitude = clutter.m_minAlt,
				maxVegetation = clutter.m_maxVegetation,
				minVegetation = clutter.m_minVegetation,
				snapToWater = clutter.m_snapToWater,
				terrainTilt = clutter.m_terrainTilt,
				randomOffset = clutter.m_randomOffset,
				minOceanDepth = clutter.m_minOceanDepth,
				maxOceanDepth = clutter.m_maxOceanDepth,
				inForest = clutter.m_inForest,
				forestTresholdMin = clutter.m_forestTresholdMin,
				forestTresholdMax = clutter.m_forestTresholdMax,
				fractalScale = clutter.m_fractalScale,
				fractalOffset = clutter.m_fractalOffset,
				fractalThresholdMin = clutter.m_fractalTresholdMin,
				fractalThresholdMax = clutter.m_fractalTresholdMax
			};
		}

		public static void CreateConfigs()
		{
			if (!Helper.IsClient() && Configuration.DataClutter && !File.Exists(FilePath))
			{
				SaveDefaultFile();
			}
		}

		public static void ReadConfigs()
		{
			if (Helper.IsClient())
			{
				return;
			}
			if (Configuration.DataClutter)
			{
				if (File.Exists(FilePath))
				{
					string value = DataManager.Read<ClutterYaml, Clutter>(Pattern, FromData);
					Configuration.valueClutterData.Value = value;
				}
				else
				{
					CreateConfigs();
				}
			}
			else
			{
				Configuration.valueClutterData.Value = "";
			}
		}

		public static void Set(string yaml)
		{
			if (!Initialized)
			{
				Pending = true;
			}
			else
			{
				if (!TryParseYaml(yaml, out List<Clutter> data))
				{
					return;
				}
				ClutterSystem.instance.m_clutter.Clear();
				foreach (Clutter item in data)
				{
					ClutterSystem.instance.m_clutter.Add(item);
				}
				ClutterSystem.instance.ClearAll();
			}
		}

		private static bool TryParseYaml(string yaml, out List<Clutter> data)
		{
			if (yaml == "")
			{
				Log.Info($"Reloading default clutter data ({DefaultEntries.Count} entries).");
				data = DefaultEntries;
				return true;
			}
			try
			{
				data = (from d in Yaml.Deserialize<ClutterYaml>(yaml, "Clutter")
					select FromData(d, "Clutter") into clutter
					where Object.op_Implicit((Object)(object)clutter.m_prefab)
					select clutter).ToList();
			}
			catch (Exception ex)
			{
				Log.Error(ex.Message);
				Log.Error(ex.StackTrace);
				data = new List<Clutter>();
				return false;
			}
			if (data.Count == 0)
			{
				Log.Warning("Failed to load any clutter data.");
				return false;
			}
			if (Configuration.DataMigration && Helper.IsServer() && AddMissingEntries(data))
			{
				return false;
			}
			Log.Info($"Reloading clutter data ({data.Count} entries).");
			return true;
		}

		private static bool AddMissingEntries(List<Clutter> entries)
		{
			HashSet<string> missingKeys = DefaultEntries.Select((Clutter s) => ((Object)s.m_prefab).name).Distinct().ToHashSet();
			foreach (Clutter entry in entries)
			{
				missingKeys.Remove(((Object)entry.m_prefab).name);
			}
			if (missingKeys.Count == 0)
			{
				return false;
			}
			List<ClutterYaml> list = DefaultEntries.Where((Clutter clutter) => missingKeys.Contains(((Object)clutter.m_prefab).name)).Select(ToData).ToList();
			Log.Warning($"Adding {list.Count} missing clutters to the expand_clutter.yaml file.");
			Save(list, log: true);
			return true;
		}

		private static void Save(List<ClutterYaml> data, bool log)
		{
			Dictionary<string, List<ClutterYaml>> dictionary = new Dictionary<string, List<ClutterYaml>>();
			foreach (ClutterYaml datum in data)
			{
				string modFromPrefab = AssetTracker.GetModFromPrefab(datum.prefab);
				string key = (Configuration.SplitDataPerMod ? AssetTracker.GetFileNameFromMod(modFromPrefab) : "");
				if (!dictionary.ContainsKey(key))
				{
					dictionary[key] = new List<ClutterYaml>();
				}
				dictionary[key].Add(datum);
				if (log)
				{
					Log.Warning(modFromPrefab + ": " + datum.prefab);
				}
			}
			foreach (KeyValuePair<string, List<ClutterYaml>> item in dictionary)
			{
				string path = Path.Combine(Yaml.BaseDirectory, "expand_clutter" + item.Key + ".yaml");
				string text = (File.Exists(path) ? (File.ReadAllText(path) + "\n") : "");
				text += Yaml.Serializer().Serialize((object)item.Value);
				File.WriteAllText(path, text);
			}
		}

		public static void SetupWatcher()
		{
			Yaml.SetupWatcher(Pattern, ReadConfigs);
		}

		public static void CleanUp()
		{
			Initialized = false;
			Pending = false;
		}
	}
	public class PlayerInfo
	{
		public string Name;

		public Vector3 Pos;

		public Quaternion Rot;

		public long Character;

		public string HostId;

		public ZDOID ZDOID;

		public PlayerInfo(ZNetPeer peer)
		{
			//IL_002a: 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_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: 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_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_0075: 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)
			HostId = peer.m_rpc.GetSocket().GetHostName();
			Name = peer.m_playerName;
			Pos = peer.m_refPos;
			ZDOID = peer.m_characterID;
			ZDO zDO = ZDOMan.instance.GetZDO(peer.m_characterID);
			if (zDO != null)
			{
				Character = zDO.GetLong(ZDOVars.s_playerID, 0L);
				Pos = zDO.m_position;
				Rot = zDO.GetRotation();
			}
		}

		public PlayerInfo(Player player)
		{
			//IL_001f: 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_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: 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)
			HostId = "self";
			Name = player.GetPlayerName();
			ZDOID = ((Character)player).GetZDOID();
			Character = player.GetPlayerID();
			Pos = ((Component)player).transform.position;
			Rot = ((Component)player).transform.rotation;
		}
	}
	public class CommandManager
	{
		public static void Run(IEnumerable<string> commands, Vector3 center, Vector3 rot)
		{
			//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)
			Run(commands, center, rot, (PlayerInfo?)null);
		}

		public static void Run(IEnumerable<string> commands, Vector3 center, Vector3 rot, PlayerInfo? player)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			string[] array = commands.Select((string c) => Parse(c, center, rot, player)).ToArray();
			foreach (string text in array)
			{
				try
				{
					((Terminal)Console.instance).TryRunCommand(text, false, false);
				}
				catch (Exception ex)
				{
					Log.Error("Failed to run command: " + text + "\n" + ex.Message);
				}
			}
		}

		public static void Run(IEnumerable<string> commands, Vector3 center, Vector3 rot, PlayerInfo[] players)
		{
			//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)
			foreach (PlayerInfo player in players)
			{
				Run(commands, center, rot, player);
			}
		}

		private static string Parse(string command, Vector3 center, Vector3 rot, PlayerInfo? player)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//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)
			Vector2i zone = ZoneSystem.GetZone(center);
			string text = command.Replace("<x>", center.x.ToString("0.#####", NumberFormatInfo.InvariantInfo)).Replace("<y>", center.y.ToString("0.#####", NumberFormatInfo.InvariantInfo)).Replace("<z>", center.z.ToString("0.#####", NumberFormatInfo.InvariantInfo))
				.Replace("<i>", zone.x.ToString())
				.Replace("<j>", zone.y.ToString())
				.Replace("<a>", rot.y.ToString("0.#####", NumberFormatInfo.InvariantInfo));
			if (player != null)
			{
				text = text.Replace("<px>", player.Pos.x.ToString("0.#####", NumberFormatInfo.InvariantInfo)).Replace("<py>", player.Pos.y.ToString("0.#####", NumberFormatInfo.InvariantInfo)).Replace("<pz>", player.Pos.z.ToString("0.#####", NumberFormatInfo.InvariantInfo))
					.Replace("<pname>", player.Name)
					.Replace("<pid>", player.HostId)
					.Replace("<pchar>", player.Character.ToString());
			}
			string[] array = (from s in text.Split(new char[1] { ' ' })
				select s.Split(new char[1] { '=' }) into a
				select a[^1].Trim()).SelectMany((string s) => s.Split(new char[1] { ',' })).ToArray();
			foreach (string text2 in array)
			{
				string source = text2.Substring(1);
				if (Enumerable.Contains(source, '*') || Enumerable.Contains(source, '/') || Enumerable.Contains(source, '+') || Enumerable.Contains(source, '-'))
				{
					text = text.Replace(text2, Evaluate(text2).ToString("0.#####", NumberFormatInfo.InvariantInfo));
				}
			}
			return text;
		}

		private static float Evaluate(string expression)
		{
			string[] array = expression.Split(new char[1] { '*' });
			if (array.Length > 1)
			{
				float num = 1f;
				string[] array2 = array;
				foreach (string expression2 in array2)
				{
					num *= Evaluate(expression2);
				}
				return num;
			}
			string[] array3 = expression.Split(new char[1] { '/' });
			if (array3.Length > 1)
			{
				float num2 = Evaluate(array3[0]);
				for (int j = 1; j < array3.Length; j++)
				{
					num2 /= Evaluate(array3[j]);
				}
				return num2;
			}
			string[] array4 = expression.Split(new char[1] { '+' });
			if (array4.Length > 1)
			{
				float num3 = 0f;
				string[] array2 = array4;
				foreach (string expression3 in array2)
				{
					num3 += Evaluate(expression3);
				}
				return num3;
			}
			string[] array5 = expression.Split(new char[1] { '-' });
			if (array5.Where((string s) => s != "").Count() > 1)
			{
				float? num4 = null;
				for (int num5 = 0; num5 < array5.Length; num5++)
				{
					if (!(array5[num5] == "") || num5 + 1 >= array5.Length)
					{
						num4 = (num4.HasValue ? (num4 - Evaluate(array5[num5])) : new float?(Evaluate(array5[num5])));
					}
					else
					{
						array5[num5 + 1] = "-" + array5[num5 + 1];
					}
				}
				return num4.GetValueOrDefault();
			}
			try
			{
				return float.Parse(expression.Trim(), NumberFormatInfo.InvariantInfo);
			}
			catch
			{
				throw new Exception("Failed to parse expression: " + expression);
			}
		}
	}
	[HarmonyPatch(typeof(DungeonDB), "Start")]
	[HarmonyPriority(100)]
	public class InitializeRooms
	{
		private static void Postfix()
		{
			RoomLoading.Initialize();
			Loader.Initialize();
		}
	}
	[HarmonyPatch(typeof(WorldGenerator), "VersionSetup")]
	[HarmonyPriority(100)]
	public class InitializeWorld
	{
		private static void Postfix()
		{
			WorldInfo.CheckPatches(EWD.Harmony);
			BiomeManager.ReadConfigs();
			TerritoryManager.ReadConfigs();
			WorldManager.ReadConfigs();
		}
	}
	[HarmonyPatch(typeof(ZoneSystem), "Start")]
	[HarmonyPriority(100)]
	public class InitializeContent
	{
		private static void Postfix()
		{
			AddEmptyAssetReference();
			EnvironmentManager.Initialize();
			ClutterManager.Initialize();
			VegetationLoading.Initialize();
			LocationLoading.Initialize();
			if (Helper.IsServer())
			{
				EnvironmentManager.CreateConfigs();
				BiomeManager.CreateConfigs();
				TerritoryManager.CreateConfigs();
				WorldManager.CreateConfigs();
				ClutterManager.CreateConfigs();
				VegetationLoading.CreateConfigs();
				LocationLoading.CreateConfigs();
				DataLoading.LoadEntries();
				EnvironmentManager.ReadConfigs();
				BiomeManager.ReadConfigs();
				TerritoryManager.ReadConfigs();
				WorldManager.ReadConfigs();
				ClutterManager.ReadConfigs();
				VegetationLoading.ReadConfigs();
				LocationLoading.ReadConfigs();
			}
			EnvironmentManager.Load();
			BiomeManager.Load();
			TerritoryManager.Load();
			WorldManager.Load();
			NoBuildManager.Load();
			ClutterManager.Load();
		}

		private static void AddEmptyAssetReference()
		{
			//IL_0019: 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_0048: 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)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Expected O, but got Unknown
			//IL_0069: 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_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Expected O, but got Unknown
			//IL_00a9: 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_00b5: Unknown result type (might be due to invalid IL or missing references)
			AssetBundleLoader instance = AssetBundleLoader.Instance;
			instance.m_bundleNameToLoaderIndex[""] = 0;
			AssetID val = default(AssetID);
			if (instance.m_assetIDToLoaderIndex.TryGetValue(val, out var value))
			{
				instance.m_assetLoaders[value].m_asset = (Object)new GameObject();
				return;
			}
			AssetLoader val2 = default(AssetLoader);
			((AssetLoader)(ref val2))..ctor(val, new AssetLocation("", ""));
			val2.m_asset = (Object)new GameObject();
			AssetLoader val3 = val2;
			((AssetLoader)(ref val3)).HoldReference();
			value = instance.m_assetIDToLoaderIndex.Count;
			if (value >= instance.m_assetLoaders.Length)
			{
				Array.Resize(ref instance.m_assetLoaders, instance.m_assetIDToLoaderIndex.Count + 1);
			}
			instance.m_assetLoaders[value] = val3;
			instance.m_assetIDToLoaderIndex[val] = value;
		}
	}
	[HarmonyPatch(typeof(ZNet), "Shutdown")]
	public class CleanupOnShutdown
	{
		private static void Postfix()
		{
			NoBuildManager.CleanUp();
			WorldManager.CleanUp();
			TerritoryManager.CleanUp();
			BiomeManager.CleanUp();
			EnvironmentManager.CleanUp();
			ClutterManager.CleanUp();
			LocationLoading.CleanUp();
			VegetationLoading.CleanUp();
		}
	}
	public class DataManager : MonoBehaviour
	{
		private static readonly Biome DefaultMax = (Biome)895;

		private static readonly Dictionary<string, int> ItemDropCache = new Dictionary<string, int>();

		public static string FromList(IEnumerable<string> array)
		{
			return string.Join(", ", array);
		}

		public static string FromList(IEnumerable<ItemDrop> array)
		{
			return FromList(array.Select((ItemDrop i) => FindItemName(i.m_itemData.m_shared?.m_name ?? "")));
		}

		public static List<string> ToList(string str, bool removeEmpty = true)
		{
			string[] array = Parse.Split(str, removeEmpty);
			List<string> list = new List<string>(array.Length);
			list.AddRange(array);
			return list;
		}

		private static ItemDrop FindItem(string name)
		{
			if (ItemDropCache.TryGetValue(name, out var value))
			{
				return ObjectDB.instance.GetItemPrefab(value).GetComponent<ItemDrop>();
			}
			GameObject val = ((IEnumerable<GameObject>)ObjectDB.instance.m_items).FirstOrDefault((Func<GameObject, bool>)((GameObject i) => i.GetComponent<ItemDrop>()?.m_itemData.m_shared?.m_name == name));
			if (Object.op_Implicit((Object)(object)val))
			{
				ItemDropCache[name] = StringExtensionMethods.GetStableHashCode(((Object)val).name);
			}
			if (val == null)
			{
				return null;
			}
			return val.GetComponent<ItemDrop>();
		}

		private static string FindItemName(string name)
		{
			ItemDrop obj = FindItem(name);
			return ((obj != null) ? ((Object)obj).name : null) ?? "";
		}

		public static List<ItemDrop> ToItemList(string str, bool removeEmpty = true)
		{
			return (from s in Parse.Split(str, removeEmpty).Select(delegate(string s)
				{
					GameObject itemPrefab = ObjectDB.instance.GetItemPrefab(s);
					return (itemPrefab == null) ? null : itemPrefab.GetComponent<ItemDrop>();
				})
				where (Object)(object)s != (Object)null
				select s).ToList();
		}

		public static Dictionary<string, string> ToDict(string str)
		{
			return (from s in ToList(str)
				select s.Split(new char[1] { '=' }) into s
				where s.Length == 2
				select s).ToDictionary((string[] s) => s[0].Trim(), (string[] s) => s[1].Trim());
		}

		public static string FromBiomes(Biome biome)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: 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_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Expected I4, but got Unknown
			if (biome == DefaultMax)
			{
				return "";
			}
			if ((int)biome == 0)
			{
				return "None";
			}
			List<string> list = new List<string>();
			int num = 1;
			int num2 = (int)biome;
			while (num <= num2)
			{
				if ((num & num2) > 0)
				{
					if (BiomeManager.TryGetDisplayName((Biome)num, out string name))
					{
						list.Add(name);
					}
					else
					{
						list.Add(num.ToString());
					}
				}
				num *= 2;
			}
			return string.Join(", ", list);
		}

		public static string FromBiomeAreas(BiomeArea biomeArea)
		{
			//IL_0000: 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)
			//IL_0004: Invalid comparison between Unknown and I4
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Invalid comparison between Unknown and I4
			bool flag = (biomeArea & 1) > 0;
			bool flag2 = (biomeArea & 2) > 0;
			if (flag && flag2)
			{
				return "";
			}
			if (flag)
			{
				return "edge";
			}
			if (flag2)
			{
				return "median";
			}
			return "";
		}

		public static string FromEnum<T>(T value) where T : struct, Enum
		{
			List<string> list = new List<string>();
			int num = 1;
			int num2 = (int)(object)value;
			while (num <= num2)
			{
				if ((num & num2) > 0)
				{
					list.Add(((T)(object)num/*cast due to .constrained prefix*/).ToString());
				}
				num *= 2;
			}
			return FromList(list);
		}

		public static T ToEnum<T>(string str) where T : struct, Enum
		{
			return ToEnum<T>(ToList(str));
		}

		public static T ToEnum<T>(List<string> list) where T : struct, Enum
		{
			int num = 0;
			foreach (string item in list)
			{
				string text = item.Trim();
				if (Enum.TryParse<T>(text, ignoreCase: true, out var result))
				{
					num += (int)(object)result;
					continue;
				}
				Log.Warning("Failed to parse value " + text + " as " + result.GetType().Name + ".");
			}
			return (T)(object)num;
		}

		public static T ToByteEnum<T>(List<string> list) where T : struct, Enum
		{
			byte b = 0;
			foreach (string item in list)
			{
				string text = item.Trim();
				if (Enum.TryParse<T>(text, ignoreCase: true, out var result))
				{
					b += (byte)(object)result;
				}
				else
				{
					Log.Warning("Failed to parse value " + text + " as T.");
				}
			}
			return (T)(object)b;
		}

		public static Biome ToBiomes(string biomeStr, string fileName)
		{
			//IL_0001: 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_0066: 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_0069: 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_0023: 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)
			//IL_0029: 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_002b: 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_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_007c: Unknown result type (might be due to invalid IL or missing references)
			Biome val = (Biome)0;
			if (biomeStr == "")
			{
				foreach (Biome key in BiomeManager.BiomeToDisplayName.Keys)
				{
					val |= key;
				}
			}
			else
			{
				string[] array = Parse.Split(biomeStr);
				foreach (string text in array)
				{
					int result;
					if (BiomeManager.TryGetBiome(text, out var biome))
					{
						val |= biome;
					}
					else if (int.TryParse(text, out result))
					{
						val = (Biome)(val + result);
					}
					else
					{
						Log.Warning(fileName + ": Invalid biome " + text + ".");
					}
				}
			}
			return val;
		}

		public static BiomeArea ToBiomeAreas(string m_biome, string fileName)
		{
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: 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_0048: 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_005f: Unknown result type (might be due to invalid IL or missing references)
			if (m_biome == "")
			{
				return (BiomeArea)3;
			}
			IEnumerable<BiomeArea> enumerable = ((IEnumerable<string>)Parse.Split(m_biome)).Select((Func<string, BiomeArea>)delegate(string s)
			{
				//IL_000b: Unknown result type (might be due to invalid IL or missing references)
				if (!Enum.TryParse<BiomeArea>(s, ignoreCase: true, out BiomeArea result))
				{
					Log.Warning(fileName + ": Invalid biome area " + s + ".");
					return (BiomeArea)0;
				}
				return result;
			});
			BiomeArea val = (BiomeArea)0;
			foreach (BiomeArea item in enumerable)
			{
				val |= item;
			}
			return val;
		}

		public static GameObject? ToPrefab(string str, string fileName)
		{
			if (ZNetScene.instance.m_namedPrefabs.TryGetValue(StringExtensionMethods.GetStableHashCode(str), out var value))
			{
				return value;
			}
			Log.Warning(fileName + ": Prefab " + str + " not found!");
			return null;
		}

		public static string FromColor(Color? color)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			if (color.HasValue)
			{
				return FromColor(color.Value);
			}
			return "0,0,0";
		}

		public static string FromColor(Color color)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: 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_009d: 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_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: 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)
			if (color.a < 1f)
			{
				return FormatColor(color.r) + ", " + FormatColor(color.g) + ", " + FormatColor(color.b) + ", " + FormatColor(color.a);
			}
			return FormatColor(color.r) + ", " + FormatColor(color.g) + ", " + FormatColor(color.b);
		}

		private static string FormatColor(float color)
		{
			return color.ToString("0.###", CultureInfo.InvariantCulture);
		}

		public static Color ToColor(string? str)
		{
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			if (str == null)
			{
				return new Color(0f, 0f, 0f, 0f);
			}
			string[] args = str.Split(new char[1] { ',' });
			float num = Parse.Float(args, 0);
			float num2 = Parse.Float(args, 1);
			float num3 = Parse.Float(args, 2);
			float num4 = Parse.Float(args, 3, 1f);
			return new Color(num, num2, num3, num4);
		}

		public static GameObject Instantiate(GameObject prefab, Vector3 pos, Quaternion rot, DataEntry? data)
		{
			//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)
			//IL_0024: 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)
			ZDO? obj = DataHelper.Init(prefab, pos, rot, null, data);
			if (obj != null)
			{
				obj.RemoveLong(ZDOVars.s_creator);
			}
			GameObject obj2 = Object.Instantiate<GameObject>(prefab, pos, rot);
			CleanGhostInit(obj2);
			return obj2;
		}

		public static void CleanGhostInit(GameObject obj)
		{
			if (ZNetView.m_ghostInit)
			{
				CleanGhostInit(obj.GetComponent<ZNetView>());
			}
		}

		public static void CleanGhostInit(ZNetView view)
		{
			if (ZNetView.m_ghostInit && Object.op_Implicit((Object)(object)view))
			{
				view.m_ghost = true;
				view.GetZDO().Created = false;
				ZNetScene.instance.m_instances.Remove(view.GetZDO());
			}
		}

		public static List<U> ReadData<T, U>(string pattern, Func<T, string, U> converter)
		{
			if (!Directory.Exists(Yaml.BaseDirectory))
			{
				Directory.CreateDirectory(Yaml.BaseDirectory);
			}
			return Directory.GetFiles(Yaml.BaseDirectory, pattern, SearchOption.AllDirectories).Reverse().SelectMany(delegate(string name)
			{
				string fileName = Path.GetFileNameWithoutExtension(name);
				return from d in Yaml.Deserialize<T>(File.ReadAllText(name), fileName)
					select converter(d, fileName);
			})
				.ToList();
		}

		public static string Read<T, U>(string pattern, Func<T, string, U> converter)
		{
			if (!Directory.Exists(Yaml.BaseDirectory))
			{
				Directory.CreateDirectory(Yaml.BaseDirectory);
			}
			IEnumerable<string> values = Directory.GetFiles(Yaml.BaseDirectory, pattern, SearchOption.AllDirectories).Reverse().Select(delegate(string name)
			{
				string fileName = Path.GetFileNameWithoutExtension(name);
				string text = File.ReadAllText(name);
				return ((from d in Yaml.Deserialize<T>(File.ReadAllText(name), fileName)
					select converter(d, fileName)).Count() <= 0) ? "" : text;
			});
			return string.Join("\n", values) ?? "";
		}
	}
	public class EnvironmentYaml
	{
		public string name = "";

		[DefaultValue("")]
		public string particles = "";

		[DefaultValue(false)]
		public bool isDefault;

		[DefaultValue(false)]
		public bool isWet;

		[DefaultValue(false)]
		public bool isFreezing;

		[DefaultValue(false)]
		public bool isFreezingAtNight;

		[DefaultValue(false)]
		public bool isCold;

		[DefaultValue(false)]
		public bool isColdAtNight;

		[DefaultValue(false)]
		public bool alwaysDark;

		[DefaultValue(0f)]
		public float windMin;

		[DefaultValue(1f)]
		public float windMax = 1f;

		[DefaultValue(0f)]
		public float rainCloudAlpha;

		[DefaultValue(0.3f)]
		public float ambientVol = 0.3f;

		[DefaultValue("")]
		public string ambientList = "";

		[DefaultValue("")]
		public string musicMorning = "";

		[DefaultValue("")]
		public string musicEvening = "";

		[DefaultValue("")]
		public string musicDay = "";

		[DefaultValue("")]
		public string musicNight = "";

		public string? colorAmbientDay;

		public string? colorAmbientNight;

		public string? colorSunMorning;

		public string? colorSunDay;

		public string? colorSunEvening;

		public string? colorSunNight;

		public string? colorFogMorning;

		public string? colorFogDay;

		public string? colorFogEvening;

		public string? colorFogNight;

		public string? colorFogSunMorning;

		public string? colorFogSunDay;

		public string? colorFogSunEvening;

		public string? colorFogSunNight;

		public Color? ambColorDay;

		public Color? ambColorNight;

		public Color? sunColorMorning;

		public Color? sunColorDay;

		public Color? sunColorEvening;

		public Color? sunColorNight;

		public Color? fogColorMorning;

		public Color? fogColorDay;

		public Color? fogColorEvening;

		public Color? fogColorNight;

		public Color? fogColorSunMorning;

		public Color? fogColorSunDay;

		public Color? fogColorSunEvening;

		public Color? fogColorSunNight;

		[DefaultValue(0.01f)]
		public float fogDensityMorning = 0.01f;

		[DefaultValue(0.01f)]
		public float fogDensityDay = 0.01f;

		[DefaultValue(0.01f)]
		public float fogDensityEvening = 0.01f;

		[DefaultValue(0.01f)]
		public float fogDensityNight = 0.01f;

		[DefaultValue(1.2f)]
		public float lightIntensityDay = 1.2f;

		[DefaultValue(0f)]
		public float lightIntensityNight;

		[DefaultValue(60f)]
		public float sunAngle = 60f;

		[DefaultValue(null)]
		public StatusData[]? statusEffects;
	}
	public class EnvironmentData
	{
		public List<Status> statusEffects = new List<Status>();

		public List<string> requiredGlobalKeys = new List<string>();

		public List<string> forbiddenGlobalKeys = new List<string>();

		public List<string> requiredPlayerKeys = new List<string>();

		public List<string> forbiddenPlayerKeys = new List<string>();

		public EnvironmentData(EnvironmentYaml data)
		{
			if (data.statusEffects != null)
			{
				statusEffects = data.statusEffects.Select((StatusData s) => new Status(s)).ToList();
			}
		}

		public bool CheckKeys()
		{
			if (requiredGlobalKeys.Any((string k) => !ZoneSystem.instance.GetGlobalKey(k)))
			{
				return false;
			}
			if (((IEnumerable<string>)forbiddenGlobalKeys).Any((Func<string, bool>)ZoneSystem.instance.GetGlobalKey))
			{
				return false;
			}
			Player player = Player.m_localPlayer;
			if (Object.op_Implicit((Object)(object)player) && requiredPlayerKeys.Any((string k) => !((Humanoid)player).HaveUniqueKey(k)))
			{
				return false;
			}
			if (Object.op_Implicit((Object)(object)player) && ((IEnumerable<string>)forbiddenPlayerKeys).Any((Func<string, bool>)((Humanoid)player).HaveUniqueKey))
			{
				return false;
			}
			return true;
		}

		public bool HasKeys()
		{
			if (requiredGlobalKeys.Count <= 0 && forbiddenGlobalKeys.Count <= 0 && requiredPlayerKeys.Count <= 0)
			{
				return forbiddenPlayerKeys.Count > 0;
			}
			return true;
		}

		public bool IsValid()
		{
			if (statusEffects.Count <= 0)
			{
				return HasKeys();
			}
			return true;
		}
	}
	public class EnvironmentManager
	{
		public static string FileName = "expand_environments.yaml";

		public static string FilePath = Path.Combine(Yaml.BaseDirectory, FileName);

		public static string Pattern = "expand_environments*.yaml";

		private static bool Initialized;

		private static bool Pending;

		private static Dictionary<string, EnvSetup> Originals = new Dictionary<string, EnvSetup>();

		public static Dictionary<string, EnvironmentData> Extra = new Dictionary<string, EnvironmentData>();

		public static void Initialize()
		{
			Dictionary<string, EnvSetup> dictionary = LocationList.m_allLocationLists.Select((LocationList list) => list.m_environments).Append(EnvMan.instance.m_environments).SelectMany((List<EnvSetup> list) => list)
				.ToLookup((EnvSetup env) => env.m_name, (EnvSetup env) => env)
				.ToDictionary((IGrouping<string, EnvSetup> kvp) => kvp.Key, (IGrouping<string, EnvSetup> kvp) => kvp.First());
			if (dictionary.Count > 0)
			{
				Originals = dictionary;
			}
		}

		public static void Load()
		{
			Initialized = true;
			if (Pending)
			{
				Pending = false;
				Set(Configuration.valueEnvironmentData.Value);
			}
		}

		public static void CleanUp()
		{
			Initialized = false;
			Pending = false;
		}

		public static EnvSetup FromData(EnvironmentYaml data, string fileName)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Expected O, but got Unknown
			//IL_0109: 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_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0133: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_015d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0154: Unknown result type (might be due to invalid IL or missing references)
			//IL_0162: Unknown result type (might be due to invalid IL or missing references)
			//IL_0187: Unknown result type (might be due to invalid IL or missing references)
			//IL_017e: Unknown result type (might be due to invalid IL or missing references)
			//IL_018c: 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_01a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01db: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0205: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_020a: Unknown result type (might be due to invalid IL or missing references)
			//IL_022f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0226: 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_0259: Unknown result type (might be due to invalid IL or missing references)
			//IL_0250: Unknown result type (might be due to invalid IL or missing references)
			//IL_025e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0283: 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_0288: 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_02d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0307: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_030c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0331: Unknown result type (might be due to invalid IL or missing references)
			//IL_0328: Unknown result type (might be due to invalid IL or missing references)
			//IL_0336: Unknown result type (might be due to invalid IL or missing references)
			//IL_035b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0352: Unknown result type (might be due to invalid IL or missing references)
			//IL_0360: Unknown result type (might be due to invalid IL or missing references)
			EnvSetup val = new EnvSetup
			{
				m_psystems = Array.Empty<GameObject>()
			};
			if (Originals.TryGetValue(data.particles, out EnvSetup value))
			{
				val = value.Clone();
			}
			else if (Originals.TryGetValue(data.name, out value))
			{
				val = value.Clone();
			}
			else
			{
				Log.Warning(fileName + ": Failed to find a particle system \"" + data.particles + "\" for environment " + data.name + ". Make sure field \"particles\" is set correctly or remove this entry.");
			}
			val.m_name = data.name;
			val.m_default = data.isDefault;
			val.m_isWet = data.isWet;
			val.m_isFreezing = data.isFreezing;
			val.m_isFreezingAtNight = data.isFreezingAtNight;
			val.m_isCold = data.isCold;
			val.m_isColdAtNight = data.isColdAtNight;
			val.m_alwaysDark = data.alwaysDark;
			val.m_ambColorNight = (Color)(((??)data.ambColorNight) ?? DataManager.ToColor(data.colorAmbientNight));
			val.m_ambColorDay = (Color)(((??)data.ambColorDay) ?? DataManager.ToColor(data.colorAmbientDay));
			val.m_fogColorNight = (Color)(((??)data.fogColorNight) ?? DataManager.ToColor(data.colorFogNight));
			val.m_fogColorMorning = (Color)(((??)data.fogColorMorning) ?? DataManager.ToColor(data.colorFogMorning));
			val.m_fogColorDay = (Color)(((??)data.fogColorDay) ?? DataManager.ToColor(data.colorFogDay));
			val.m_fogColorEvening = (Color)(((??)data.fogColorEvening) ?? DataManager.ToColor(data.colorFogEvening));
			val.m_fogColorSunNight = (Color)(((??)data.fogColorSunNight) ?? DataManager.ToColor(data.colorFogSunNight));
			val.m_fogColorSunMorning = (Color)(((??)data.fogColorSunMorning) ?? DataManager.ToColor(data.colorFogSunMorning));
			val.m_fogColorSunDay = (Color)(((??)data.fogColorSunDay) ?? DataManager.ToColor(data.colorFogSunDay));
			val.m_fogColorSunEvening = (Color)(((??)data.fogColorSunEvening) ?? DataManager.ToColor(data.colorFogSunEvening));
			val.m_fogDensityNight = data.fogDensityNight;
			val.m_fogDensityMorning = data.fogDensityMorning;
			val.m_fogDensityDay = data.fogDensityDay;
			val.m_fogDensityEvening = data.fogDensityEvening;
			val.m_sunColorNight = (Color)(((??)data.sunColorNight) ?? DataManager.ToColor(data.colorSunNight));
			val.m_sunColorMorning = (Color)(((??)data.sunColorMorning) ?? DataManager.ToColor(data.colorSunMorning));
			val.m_sunColorDay = (Color)(((??)data.sunColorDay) ?? DataManager.ToColor(data.colorSunDay));
			val.m_sunColorEvening = (Color)(((??)data.sunColorEvening) ?? DataManager.ToColor(data.colorSunEvening));
			val.m_lightIntensityDay = data.lightIntensityDay;
			val.m_lightIntensityNight = data.lightIntensityNight;
			val.m_sunAngle = data.sunAngle;
			val.m_windMin = data.windMin;
			val.m_windMax = data.windMax;
			val.m_rainCloudAlpha = data.rainCloudAlpha;
			val.m_ambientVol = data.ambientVol;
			val.m_ambientList = data.ambientList;
			val.m_musicMorning = data.musicMorning;
			val.m_musicEvening = data.musicEvening;
			val.m_musicDay = data.musicDay;
			val.m_musicNight = data.musicNight;
			EnvironmentData environmentData = new EnvironmentData(data);
			if (environmentData.IsValid())
			{
				Extra[data.name] = environmentData;
			}
			return val;
		}

		public static EnvironmentYaml ToData(EnvSetup env)
		{
			//IL_0067: 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_0089: 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_00ab: 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_00cd: 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_00ef: 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_0141: 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_0163: 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)
			return new EnvironmentYaml
			{
				name = env.m_name,
				isDefault = env.m_default,
				isWet = env.m_isWet,
				isFreezing = env.m_isFreezing,
				isFreezingAtNight = env.m_isFreezingAtNight,
				isCold = env.m_isCold,
				isColdAtNight = env.m_isColdAtNight,
				alwaysDark = env.m_alwaysDark,
				colorAmbientDay = DataManager.FromColor(env.m_ambColorDay),
				colorAmbientNight = DataManager.FromColor(env.m_ambColorNight),
				colorFogNight = DataManager.FromColor(env.m_fogColorNight),
				colorFogMorning = DataManager.FromColor(env.m_fogColorMorning),
				colorFogDay = DataManager.FromColor(env.m_fogColorDay),
				colorFogEvening = DataManager.FromColor(env.m_fogColorEvening),
				colorFogSunNight = DataManager.FromColor(env.m_fogColorSunNight),
				colorFogSunMorning = DataManager.FromColor(env.m_fogColorSunMorning),
				colorFogSunDay = DataManager.FromColor(env.m_fogColorSunDay),
				colorFogSunEvening = DataManager.FromColor(env.m_fogColorSunEvening),
				fogDensityNight = env.m_fogDensityNight,
				fogDensityMorning = env.m_fogDensityMorning,
				fogDensityDay = env.m_fogDensityDay,
				fogDensityEvening = env.m_fogDensityEvening,
				colorSunNight = DataManager.FromColor(env.m_sunColorNight),
				colorSunMorning = DataManager.FromColor(env.m_sunColorMorning),
				colorSunDay = DataManager.FromColor(env.m_sunColorDay),
				colorSunEvening = DataManager.FromColor(env.m_sunColorEvening),
				lightIntensityDay = env.m_lightIntensityDay,
				lightIntensityNight = env.m_lightIntensityNight,
				sunAngle = env.m_sunAngle,
				windMin = env.m_windMin,
				windMax = env.m_windMax,
				rainCloudAlpha = env.m_rainCloudAlpha,
				ambientVol = env.m_ambientVol,
				ambientList = env.m_ambientList,
				musicMorning = env.m_musicMorning,
				musicEvening = env.m_musicEvening,
				musicDay = env.m_musicDay,
				musicNight = env.m_musicNight
			};
		}

		public static void CreateConfigs()
		{
			if (!Helper.IsClient() && Configuration.DataEnvironments && !File.Exists(FilePath))
			{
				Save(EnvMan.instance.m_environments, log: false);
			}
		}

		public static void ReadConfigs()
		{
			if (Helper.IsClient())
			{
				return;
			}
			if (Configuration.DataEnvironments)
			{
				if (File.Exists(FilePath))
				{
					string text = DataManager.Read<EnvironmentYaml, EnvSetup>(Pattern, FromData);
					Configuration.valueEnvironmentData.Value = text;
					Set(text);
				}
				else
				{
					CreateConfigs();
				}
			}
			else
			{
				Configuration.valueEnvironmentData.Value = "";
				Set("");
			}
		}

		public static void FromSetting(string yaml)
		{
			if (Helper.IsClient())
			{
				Set(yaml);
			}
		}

		private static void Set(string yaml)
		{
			if (!Initialized)
			{
				Pending = true;
				return;
			}
			Extra.Clear();
			if (yaml == "" || !Configuration.DataEnvironments)
			{
				return;
			}
			try
			{
				List<EnvSetup> list = (from d in Yaml.Deserialize<EnvironmentYaml>(yaml, "Environments")
					select FromData(d, "Environments")).ToList();
				if (list.Count == 0)
				{
					Log.Warning("Failed to load any environment data.");
				}
				else
				{
					if (Configuration.DataMigration && Helper.IsServer() && AddMissingEntries(list))
					{
						return;
					}
					Log.Info($"Reloading environment data ({list.Count} entries).");
					foreach (LocationList allLocationList in LocationList.m_allLocationLists)
					{
						allLocationList.m_environments.Clear();
					}
					EnvMan instance = EnvMan.instance;
					instance.m_environments.Clear();
					foreach (EnvSetup item in list)
					{
						instance.AppendEnvironment(item);
					}
					instance.m_environmentPeriod = -1L;
					instance.m_firstEnv = true;
					{
						foreach (BiomeEnvSetup biome in instance.m_biomes)
						{
							instance.InitializeBiomeEnvSetup(biome);
						}
						return;
					}
				}
			}
			catch (Exception ex)
			{
				Log.Error(ex.Message);
				Log.Error(ex.StackTrace);
			}
		}

		private static bool AddMissingEntries(List<EnvSetup> entries)
		{
			new Dictionary<string, List<EnvSetup>>();
			HashSet<string> missingKeys = Originals.Keys.ToHashSet();
			foreach (EnvSetup entry in entries)
			{
				missingKeys.Remove(entry.m_name);
			}
			if (missingKeys.Count == 0)
			{
				return false;
			}
			List<EnvSetup> list = Originals.Values.Where((EnvSetup env) => missingKeys.Contains(env.m_name)).ToList();
			Log.Warning($"Adding {list.Count} missing environments to the expand_environments.yaml file.");
			Save(list, log: true);
			return true;
		}

		private static void Save(List<EnvSetup> data, bool log)
		{
			Dictionary<string, List<EnvSetup>> dictionary = new Dictionary<string, List<EnvSetup>>();
			foreach (EnvSetup datum in data)
			{
				string modFromPrefab = AssetTracker.GetModFromPrefab(datum.m_name);
				string key = (Configuration.SplitDataPerMod ? AssetTracker.GetFileNameFromMod(modFromPrefab) : "");
				if (!dictionary.ContainsKey(key))
				{
					dictionary[key] = new List<EnvSetup>();
				}
				dictionary[key].Add(datum);
				if (log)
				{
					Log.Warning(modFromPrefab + ": " + datum.m_name);
				}
			}
			foreach (KeyValuePair<string, List<EnvSetup>> item in dictionary)
			{
				string path = Path.Combine(Yaml.BaseDirectory, "expand_environments" + item.Key + ".yaml");
				string text = (File.Exists(path) ? (File.ReadAllText(path) + "\n") : "");
				text += Yaml.Serializer().Serialize((object)item.Value.Select(ToData));
				File.WriteAllText(path, text);
			}
		}

		public static void SetupWatcher()
		{
			Yaml.SetupWatcher(Pattern, ReadConfigs);
		}
	}
	public class NoBuildData
	{
		public float X;

		public float Z;

		public float radius;

		public float dungeon;
	}
	public class NoBuildManager
	{
		private static bool Initialized;

		private static bool Pending;

		private static Dictionary<Vector2i, NoBuildData> NoBuild = new Dictionary<Vector2i, NoBuildData>();

		public static void Load()
		{
			Initialized = true;
			if (Pending)
			{
				Pending = false;
				Apply(Configuration.valueNoBuildData.Value);
			}
		}

		public static void CleanUp()
		{
			Initialized = false;
			Pending = false;
			NoBuild.Clear();
		}

		public static void UpdateData()
		{
			if (ZoneSystem.instance.m_locationInstances.Count == 0)
			{
				return;
			}
			HashSet<ZoneLocation> noBuilds = LocationExtra.GetNoBuilds();
			List<NoBuildData> list = (from x in ZoneSystem.instance.m_locationInstances.Values.Where((LocationInstance loc) => noBuilds.Contains(loc.m_location)).Select(delegate(LocationInstance loc)
				{
					//IL_000c: 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_0076: 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_0087: 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)
					string text = "false";
					string text2 = "false";
					if (LocationExtra.TryGetData(loc.m_location, out LocationYaml data))
					{
						text = data.noBuild;
						text2 = data.noBuildDungeon;
					}
					float radius = ((text == "true") ? loc.m_location.m_exteriorRadius : Parse.Float(text));
					float dungeon = ((text2 == "true") ? (-1f) : Parse.Float(text2));
					return new NoBuildData
					{
						X = loc.m_position.x,
						Z = loc.m_position.z,
						radius = radius,
						dungeon = dungeon
					};
				})
				where x.radius != 0f || x.dungeon != 0f
				select x).ToList();
			Configuration.valueNoBuildData.Value = Yaml.Serializer().Serialize((object)list);
		}

		public static bool IsInsideNoBuildZone(Vector3 point)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//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_00e6: 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_00d4: 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_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: 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_007b: 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_00bf: 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_0092: Unknown result type (might be due to invalid IL or missing references)
			Vector2i zone = ZoneSystem.GetZone(point);
			for (int i = zone.x - 1; i <= zone.x + 1; i++)
			{
				for (int j = zone.y - 1; j <= zone.y + 1; j++)
				{
					if (NoBuild.TryGetValue(new Vector2i(i, j), out NoBuildData value))
					{
						if (point.y <= 3000f && Utils.DistanceXZ(new Vector3(value.X, 0f, value.Z), point) < value.radius)
						{
							return true;
						}
						if (value.dungeon < 0f && point.y > 3000f && i == zone.x && j == zone.y)
						{
							return true;
						}
						if (point.y > 3000f && Utils.DistanceXZ(new Vector3(value.X, 0f, value.Z), point) < value.dungeon)
						{
							return true;
						}
					}
				}
			}
			return false;
		}

		public static bool IsInsideNoBuildBiome(Vector3 point)
		{
			//IL_0005: 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_000b: 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_0012: Invalid comparison between Unknown and I4
			return (WorldGenerator.instance.GetBiome(point) & BiomeManager.NoBuildBiomes) > 0;
		}

		public static bool IsInsideNoBuildTerritory(Vector3 point)
		{
			//IL_0000: 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 BiomeCalculator.GetTerritory(point.x, point.z)?.noBuild ?? false;
		}

		public static void Apply(string yaml)
		{
			if (!Initialized)
			{
				Pending = true;
			}
			else
			{
				if (yaml == "")
				{
					return;
				}
				try
				{
					List<NoBuildData> list = Yaml.Deserialize<NoBuildData>(yaml, "No build");
					Log.Info($"Reloading no build data ({list.Count} entries).");
					NoBuild = list.ToDictionary((NoBuildData data) => ZoneSystem.GetZone(new Vector3(data.X, 0f, data.Z)));
				}
				catch (Exception ex)
				{
					Log.Error(ex.Message);
					Log.Error(ex.StackTrace);
				}
			}
		}
	}
	[HarmonyPatch(typeof(Location), "IsInsideNoBuildLocation")]
	public class IsInsideNoBuildLocation
	{
		private static bool Postfix(bool result, Vector3 point)
		{
			//IL_0003: 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_0013: Unknown result type (might be due to invalid IL or missing references)
			if (!result && !NoBuildManager.IsInsideNoBuildZone(point) && !NoBuildManager.IsInsideNoBuildTerritory(point))
			{
				return NoBuildManager.IsInsideNoBuildBiome(point);
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(ZoneSystem), "Load")]
	public class ZoneSystemLoad
	{
		private static void Postfix()
		{
			if (!Helper.IsClient())
			{
				NoBuildManager.UpdateData();
			}
		}
	}
	[HarmonyPatch(typeof(Player), "UpdateEnvStatusEffects")]
	public class StatusManager
	{
		private static float DamageTimer = 0f;

		private static readonly float TickRate = 1f;

		private static string PreviousWeather = "";

		private static bool PreviousDay = false;

		private static Biome PreviousBiome = (Biome)0;

		private static TerritoryData? PreviousTerritory = null;

		private static readonly int SpiritHash = StringExtensionMethods.GetStableHashCode("Spirit");

		private static void Postfix(Player __instance, float dt)
		{
			//IL_0045: 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_0051: 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_0073: 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_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)__instance != (Object)(object)Player.m_localPlayer))
			{
				DamageTimer += dt;
				string text = EnvMan.instance.GetCurrentEnvironment()?.m_name ?? "";
				bool flag = EnvMan.IsDay();
				Biome biome = EnvMan.instance.GetBiome();
				TerritoryData territory = BiomeCalculator.GetTerritory(((Component)__instance).transform.position.x, ((Component)__instance).transform.position.z);
				RemoveBiomeEffects(__instance, flag, biome, territory);
				RemoveWeatherEffects(__instance, flag, text);
				ApplyBiomeEffects(__instance, flag, biome, territory);
				ApplyWeatherEffects(__instance, flag, text);
				if (DamageTimer >= TickRate)
				{
					DamageTimer = 0f;
				}
				PreviousWeather = text;
				PreviousDay = flag;
				PreviousBiome = biome;
				PreviousTerritory = territory;
			}
		}

		private static void RemoveBiomeEffects(Player player, bool day, Biome biome, TerritoryData? territory)
		{
			//IL_0000: 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_0015: Unknown result type (might be due to invalid IL or missing references)
			if (!TryGetBiomeStatusEffects(PreviousBiome, PreviousTerritory, out List<Status> effects))
			{
				return;
			}
			if (biome != PreviousBiome || territory != PreviousTerritory)
			{
				Remove(player, effects);
			}
			if (day == PreviousDay)
			{
				return;
			}
			if (day)
			{
				Remove(player, effects.Where((Status s) => !s.day).ToList());
			}
			else
			{
				Remove(player, effects.Where((Status s) => !s.night).ToList());
			}
		}

		private static void RemoveWeatherEffects(Player player, bool day, string weather)
		{
			if (!EnvironmentManager.Extra.TryGetValue(PreviousWeather, out EnvironmentData value))
			{
				return;
			}
			if (weather != PreviousWeather)
			{
				Remove(player, value.statusEffects);
			}
			if (day == PreviousDay)
			{
				return;
			}
			if (day)
			{
				Remove(player, value.statusEffects.Where((Status s) => !s.day).ToList());
			}
			else
			{
				Remove(player, value.statusEffects.Where((Status s) => !s.night).ToList());
			}
		}

		private static void ApplyBiomeEffects(Player player, bool day, Biome biome, TerritoryData? territory)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			if (!TryGetBiomeStatusEffects(biome, territory, out List<Status> effects))
			{
				return;
			}
			if (day)
			{
				List<Status> list = new List<Status>();
				list.AddRange(effects.Where((Status s) => s.day));
				Add(player, list);
			}
			else
			{
				List<Status> list2 = new List<Status>();
				list2.AddRange(effects.Where((Status s) => s.night));
				Add(player, list2);
			}
		}

		private static void ApplyWeatherEffects(Player player, bool day, string weather)
		{
			if (!EnvironmentManager.Extra.TryGetValue(weather, out EnvironmentData value))
			{
				return;
			}
			if (day)
			{
				List<Status> list = new List<Status>();
				list.AddRange(value.statusEffects.Where((Status s) => s.day));
				Add(player, list);
			}
			else
			{
				List<Status> list2 = new List<Status>();
				list2.AddRange(value.statusEffects.Where((Status s) => s.night));
				Add(player, list2);
			}
		}

		private static void Remove(Player player, List<Status> es)
		{
			foreach (Status e in es)
			{
				Remove(player, e);
			}
		}

		private static bool TryGetBiomeStatusEffects(Biome biome, TerritoryData? territory, out List<Status> effects)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			if (territory != null && territory.statusEffects.Count > 0)
			{
				effects = territory.statusEffects;
				return true;
			}
			if (BiomeManager.TryGetData(biome, out BiomeData data))
			{
				effects = data.statusEffects;
				return true;
			}
			effects = new List<Status>();
			return false;
		}

		private static void Remove(Player player, Status es)
		{
			SEMan sEMan = ((Character)player).GetSEMan();
			StatusEffect statusEffect = sEMan.GetStatusEffect(es.hash);
			if (!((Object)(object)statusEffect == (Object)null) && !(statusEffect.m_ttl > 0f))
			{
				sEMan.RemoveStatusEffect(es.hash, false);
			}
		}

		private static void Add(Player player, List<Status> es)
		{
			foreach (Status e in es)
			{
				Add(player, e);
			}
		}

		private static void Add(Player player, Status es)
		{
			//IL_025c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_017a: Unknown result type (might be due to invalid IL or missing references)
			if (es.requiredGlobalKeys.Any((string k) => !ZoneSystem.instance.GetGlobalKey(k)) || ((IEnumerable<string>)es.forbiddenGlobalKeys).Any((Func<string, bool>)ZoneSystem.instance.GetGlobalKey) || es.requiredPlayerKeys.Any((string k) => !((Humanoid)player).HaveUniqueKey(k)) || ((IEnumerable<string>)es.forbiddenPlayerKeys).Any((Func<string, bool>)((Humanoid)player).HaveUniqueKey))
			{
				return;
			}
			SEMan sEMan = ((Character)player).GetSEMan();
			if (es.reset)
			{
				sEMan.AddStatusEffect(es.hash, es.reset, 0, 0f);
				return;
			}
			StatusEffect statusEffect = ObjectDB.instance.GetStatusEffect(es.hash);
			bool flag = DamageTimer >= TickRate;
			if (statusEffect is SE_Burning)
			{
				if (!flag)
				{
					return;
				}
				bool flag2 = (Object)(object)sEMan.GetStatusEffect(es.hash) != (Object)null;
				if (statusEffect.NameHash() == SpiritHash)
				{
					float num = CalculateDamage(sEMan, es, (DamageType)512);
					if (num != 0f)
					{
						if (!flag2)
						{
							num *= TickRate * statusEffect.m_ttl;
						}
						Log.Debug($"Adding {num} spirit damage to {((Object)statusEffect).name}");
						sEMan.AddStatusEffect(es.hash, false, 0, 0f);
						((SE_Burning)sEMan.GetStatusEffect(es.hash)).AddSpiritDamage(num);
					}
					return;
				}
				float num2 = CalculateDamage(sEMan, es, (DamageType)32);
				if (num2 != 0f)
				{
					if (!flag2)
					{
						num2 *= TickRate * statusEffect.m_ttl;
					}
					Log.Debug($"Adding {num2} fire damage to {((Object)statusEffect).name}");
					sEMan.AddStatusEffect(es.hash, false, 0, 0f);
					((SE_Burning)sEMan.GetStatusEffect(es.hash)).AddFireDamage(num2);
				}
			}
			else if (statusEffect is SE_Poison)
			{
				if (flag)
				{
					float num3 = CalculateDamage(sEMan, es, (DamageType)256);
					if (num3 != 0f)
					{
						Log.Debug($"Adding {num3} poison damage to {((Object)statusEffect).name}");
						sEMan.AddStatusEffect(es.hash, false, 0, 0f);
						((SE_Poison)sEMan.GetStatusEffect(es.hash)).AddDamage(num3);
					}
				}
			}
			else
			{
				sEMan.AddStatusEffect(es.hash, false, 0, 0f);
				StatusEffect statusEffect2 = sEMan.GetStatusEffect(es.hash);
				statusEffect2.m_time = statusEffect2.m_ttl - es.duration;
				SE_Shield val = (SE_Shield)(object)((statusEffect2 is SE_Shield) ? statusEffect2 : null);
				if (val != null)
				{
					val.m_absorbDamage = es.damage;
				}
			}
		}

		private static float CalculateDamage(SEMan seman, Status es, DamageType damageType)
		{
			//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)
			float num = es.damage;
			float num2 = es.damageIgnoreArmor;
			if (Object.op_Implicit((Object)(object)seman.m_character))
			{
				float num3 = ModToMultiplier(seman.m_character.GetDamageModifier(damageType));
				if (num3 < 1f && es.immuneWithResist)
				{
					num3 = 0f;
				}
				num *= num3;
				num2 *= num3;
				if (num > 0f)
				{
					float bodyArmor = seman.m_character.GetBodyArmor();
					num = ApplyArmor(num, bodyArmor);
				}
			}
			return num + num2 + es.damageIgnoreAll;
		}

		private static float ApplyArmor(float dmg, float ac)
		{
			float result = Mathf.Clamp01(dmg / (ac * 4f)) * dmg;
			if ((double)ac < (double)dmg / 2.0)
			{
				result = dmg - ac;
			}
			return result;
		}

		private static float ModToMultiplier(DamageModifier mod)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Invalid comparison between Unknown and I4
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Invalid comparison between Unknown and I4
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Invalid comparison between Unknown and I4
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Invalid comparison between Unknown and I4
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Invalid comparison between Unknown and I4
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Invalid comparison between Unknown and I4
			if ((int)mod == 1)
			{
				return 0.5f;
			}
			if ((int)mod == 5)
			{
				return 0.25f;
			}
			if ((int)mod == 2)
			{
				return 1.5f;
			}
			if ((int)mod == 6)
			{
				return 2f;
			}
			if ((int)mod == 3)
			{
				return 0f;
			}
			if ((int)mod == 4)
			{
				return 0f;
			}
			return 1f;
		}
	}
	public class StatusData
	{
		public string name = "";

		public string requiredGlobalKeys = "";

		public string forbiddenGlobalKeys = "";

		public string requiredPlayerKeys = "";

		public string forbiddenPlayerKeys = "";

		public bool day;

		public bool night;

		public bool immuneWithResist;

		public float duration;

		public float damage;

		public float damageIgnoreArmor;

		public float damageIgnoreAll;
	}
	public class Status
	{
		public int hash;

		public float duration;

		public float damage;

		public float damageIgnoreAll;

		public float damageIgnoreArmor;

		public bool reset;

		public bool day;

		public bool night;

		public bool immuneWithResist;

		public List<string> requiredGlobalKeys = new List<string>();

		public List<string> forbiddenGlobalKeys = new List<string>();

		public List<string> requiredPlayerKeys = new List<string>();

		public List<string> forbiddenPlayerKeys = new List<string>();

		public Status(StatusData status)
		{
			hash = StringExtensionMethods.GetStableHashCode(status.name);
			duration = status.duration;
			damage = status.damage;
			damageIgnoreArmor = status.damageIgnoreArmor;
			damageIgnoreAll = status.damageIgnoreAll;
			day = status.day;
			night = status.night;
			if (!day && !night)
			{
				day = true;
				night = true;
			}
			immuneWithResist = status.immuneWithResist;
			requiredGlobalKeys = DataManager.ToList(status.requiredGlobalKeys);
			forbiddenGlobalKeys = DataManager.ToList(status.forbiddenGlobalKeys);
			requiredPlayerKeys = DataManager.ToList(status.requiredPlayerKeys);
			forbiddenPlayerKeys = DataManager.ToList(status.forbiddenPlayerKeys);
			reset = status.duration == 0f && status.damage == 0f && status.damageIgnoreArmor == 0f && status.damageIgnoreAll == 0f;
		}
	}
	public class DebugCommands
	{
		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static Func<ZNetView, string> <>9__0_0;

			public static Func<string, string> <>9__0_1;

			public static Func<IGrouping<string, string>, string> <>9__0_2;

			public static Func<ZNetView, string> <>9__1_0;

			public static Func<string, string> <>9__1_1;

			public static Func<IGrouping<string, string>, string> <>9__1_2;

			public static ConsoleEvent <>9__3_0;

			public static Func<KeyValuePair<Biome, int>, string> <>9__3_11;

			public static ConsoleEvent <>9__3_1;

			public static Func<NamedMusic, bool> <>9__3_13;

			public static Func<NamedMusic, string> <>9__3_14;

			public static ConsoleEvent <>9__3_2;

			public static Func<LocationSpriteData, string> <>9__3_15;

			public static Func<SpriteData, string> <>9__3_16;

			public static Func<GameObject, string> <>9__3_17;

			public static Func<StatusEffect, string> <>9__3_18;

			public static ConsoleEvent <>9__3_3;

			public static Func<ZoneLocation, bool> <>9__3_20;

			public static Func<RoomData, string> <>9__3_23;

			public static ConsoleEvent <>9__3_6;

			public static Func<KeyValuePair<int, GameObject>, string> <>9__3_30;

			public static ConsoleOptionsFetcher <>9__3_8;

			public static ConsoleEvent <>9__3_9;

			public static Func<KeyValuePair<int, GameObject>, string> <>9__3_37;

			public static ConsoleOptionsFetcher <>9__3_10;

			public static Comparison<RaycastHit> <>9__5_0;

			internal string <GetRoomItems>b__0_0(ZNetView netView)
			{
				return Utils.GetPrefabName(((Component)netView).gameObject);
			}

			internal string <GetRoomItems>b__0_1(string name)
			{
				return name;
			}

			internal string <GetRoomItems>b__0_2(IGrouping<string, string> group)
			{
				return group.Key + " x" + group.Count();
			}

			internal string <GetLocationItems>b__1_0(ZNetView netView)
			{
				return Utils.GetPrefabName(((Component)netView).gameObject);
			}

			internal string <GetLocationItems>b__1_1(string name)
			{
				return name;
			}

			internal string <GetLocationItems>b__1_2(IGrouping<string, string> group)
			{
				return group.Key + " x" + group.Count();
			}

			internal void <.ctor>b__3_0(ConsoleEventArgs args)
			{
				WorldInfo.RegenerateMap();
			}

			internal void <.ctor>b__3_1(ConsoleEventArgs args)
			{
				//IL_0054: Unknown result type (might be due to invalid IL or missing references)
				//IL_0059: Unknown result type (might be due to invalid IL or missing references)
				//IL_0074: 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_007d: 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_0094: 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_00a0: 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)
				<>c__DisplayClass3_0 CS$<>8__locals3 = new <>c__DisplayClass3_0();
				float num = 100f;
				if (args.Length > 1 && int.TryParse(args[1], out var result))
				{
					num = result;
				}
				float radius = WorldInfo.Radius;
				float num2 = (0f - (float)Math.Ceiling(radius / num)) * num;
				Dictionary<Biome, int> dictionary = new Dictionary<Biome, int>();
				for (float num3 = num2; num3 <= radius; num3 += num)
				{
					for (float num4 = num2; num4 <= radius; num4 += num)
					{
						Vector2 val = new Vector2(num3, num4);
						if (!(((Vector2)(ref val)).magnitude > radius))
						{
							Biome biome = WorldGenerator.instance.GetBiome(num3, num4, 0.02f, false);
							if (!dictionary.ContainsKey(biome))
							{
								dictionary[biome] = 0;
							}
							dictionary[biome]++;
						}
					}
				}
				CS$<>8__locals3.total = dictionary.Values.Sum();
				IEnumerable<string> values = from kvp in dictionary
					orderby Enum.GetName(typeof(Biome), kvp.Key)
					select string.Format("{0} ({1}): {2}/{3} ({4}", Enum.GetName(typeof(Biome), kvp.Key), (int)kvp.Key, kvp.Value, CS$<>8__locals3.total, ((float)kvp.Value / CS$<>8__locals3.total).ToString("P2", CultureInfo.InvariantCulture));
				ZLog.Log((object)string.Join("\n", values));
				args.Context.AddString(string.Join("\n", values));
			}

			internal string <.ctor>b__3_11(KeyValuePair<Biome, int> kvp)
			{
				//IL_000c: Unknown result type (might be due to invalid IL or missing references)
				return Enum.GetName(typeof(Biome), kvp.Key);
			}

			internal void <.ctor>b__3_2(ConsoleEventArgs args)
			{
				MusicMan instance = MusicMan.instance;
				if (Object.op_Implicit((Object)(object)instance))
				{
					IEnumerable<string> values = from music in instance.m_music
						where music.m_enabled
						select music.m_name;
					ZLog.Log((object)string.Join("\n", values));
					args.Context.AddString(string.Join("\n", values));
				}
			}

			internal bool <.ctor>b__3_13(NamedMusic music)
			{
				return music.m_enabled;
			}

			internal string <.ctor>b__3_14(NamedMusic music)
			{
				return music.m_name;
			}

			internal unsafe void <.ctor>b__3_3(ConsoleEventArgs args)
			{
				Minimap instance = Minimap.instance;
				if (!Object.op_Implicit((Object)(object)instance))
				{
					return;
				}
				IEnumerable<string> enumerable = instance.m_locationIcons.Select((LocationSpriteData icon) => icon.m_name).Concat<string>(instance.m_icons.Select((SpriteData icon) => ((object)(*(PinType*)(&icon.m_name))/*cast due to .constrained prefix*/).ToString()));
				ObjectDB instance2 = ObjectDB.instance;
				if (Object.op_Implicit((Object)(object)instance2))
				{
					enumerable = enumerable.Concat(instance2.m_items.Select((GameObject item) => ((Object)item).name));
				}
				if (Object.op_Implicit((Object)(object)instance2))
				{
					enumerable = enumerable.Concat(instance2.m_StatusEffects.Select((StatusEffect effect) => effect.m_name));
				}
				ZLog.Log((object)string.Join("\n", enumerable));
				args.Context.AddString(string.Join("\n", enumerable));
			}

			internal string <.ctor>b__3_15(LocationSpriteData icon)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				return icon.m_name;
			}

			internal unsafe string <.ctor>b__3_16(SpriteData icon)
			{
				return ((object)(*(PinType*)(&icon.m_name))/*cast due to .constrained prefix*/).ToString();
			}

			internal string <.ctor>b__3_17(GameObject item)
			{
				return ((Object)item).name;
			}

			internal string <.ctor>b__3_18(StatusEffect effect)
			{
				return effect.m_name;
			}

			internal bool <.ctor>b__3_20(ZoneLocation loc)
			{
				if (loc.m_prefab.IsValid)
				{
					return loc.m_prefab.Name != "Blueprint";
				}
				return false;
			}

			internal void <.ctor>b__3_6(ConsoleEventArgs args)
			{
				//IL_0013: Unknown result type (might be due to invalid IL or missing references)
				//IL_0019: Expected O, but got Unknown
				<>c__DisplayClass3_1 CS$<>8__locals3 = new <>c__DisplayClass3_1();
				if (!Object.op_Implicit((Object)(object)ZoneSystem.instance))
				{
					return;
				}
				GameObject val = new GameObject();
				CS$<>8__locals3.dg = val.AddComponent<DungeonGenerator>();
				List<string> list = DungeonObjects.Generators.Select<KeyValuePair<string, FakeDungeonGenerator>, string>(delegate(KeyValuePair<string, FakeDungeonGenerator> kvp)
				{
					Spawner.Override(CS$<>8__locals3.dg, kvp.Key);
					CS$<>8__locals3.dg.SetupAvailableRooms();
					IEnumerable<string> values = DungeonGenerator.m_availableRooms.Select((RoomData room) => room.m_prefab.Name);
					return kvp.Key + ": " + string.Join(", ", values);
				}).ToList();
				ZLog.Log((object)string.Join("\n", list));
				args.Context.AddString($"Logged {list.Count} dungeons to the log file.");
			}

			internal string <.ctor>b__3_23(RoomData room)
			{
				return room.m_prefab.Name;
			}

			internal List<string> <.ctor>b__3_8()
			{
				return ZNetScene.instance.m_namedPrefabs.Select((KeyValuePair<int, GameObject> prefab) => ((Object)prefab.Value).name).ToList();
			}

			internal string <.ctor>b__3_30(KeyValuePair<int, GameObject> prefab)
			{
				return ((Object)prefab.Value).name;
			}

			internal void <.ctor>b__3_9(ConsoleEventArgs args)
			{
				//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f1: 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_0179: Unknown result type (might be due to invalid IL or missing references)
				//IL_017e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0183: Unknown result type (might be due to invalid IL or missing references)
				<>c__DisplayClass3_3 CS$<>8__locals25 = new <>c__DisplayClass3_3
				{
					name = ""
				};
				if (args.Length < 2)
				{
					CS$<>8__locals25.name = GetHovered(Player.m_localPlayer);
				}
				else
				{
					CS$<>8__locals25.name = args.Args[1];
				}
				if (CS$<>8__locals25.name == "")
				{
					args.Context.AddString("No object specified.");
					return;
				}
				CS$<>8__locals25.distance = args.TryParameterFloat(2, 50f);
				LocationProxy[] source = Object.FindObjectsByType<LocationProxy>((FindObjectsInactive)0, (FindObjectsSortMode)0);
				CS$<>8__locals25.player = Player.m_localPlayer;
				if (!Object.op_Implicit((Object)(object)CS$<>8__locals25.player))
				{
					return;
				}
				CS$<>8__locals25.loc = (from loc in source
					where Utils.DistanceXZ(((Component)loc).transform.position, ((Component)CS$<>8__locals25.player).transform.position) < CS$<>8__locals25.distance
					orderby Utils.DistanceXZ(((Component)loc).transform.position, ((Component)CS$<>8__locals25.player).transform.position)
					select loc).FirstOrDefault();
				if (!Object.op_Implicit((Object)(object)CS$<>8__locals25.loc))
				{
					args.Context.AddString("No location found.");
					return;
				}
				Vector2i zone = ZoneSystem.GetZone(((Component)CS$<>8__locals25.loc).transform.position);
				ZNetScene.instance.m_tempCurrentObjects.Clear();
				ZDOMan.instance.FindSectorObjects(zone, 1, 0, ZNetScene.instance.m_tempCurrentObjects, (List<ZDO>)null);
				CS$<>8__locals25.prefab = StringExtensionMethods.GetStableHashCode(CS$<>8__locals25.name);
				List<ZDO> list = (from zdo in ZNetScene.instance.m_tempCurrentObjects
					where zdo.GetPrefab() == CS$<>8__locals25.prefab
					where Utils.DistanceXZ(zdo.GetPosition(), ((Component)CS$<>8__locals25.loc).transform.position) < CS$<>8__locals25.distance
					orderby Utils.DistanceXZ(zdo.GetPosition(), ((Component)CS$<>8__locals25.loc).transform.position)
					select zdo).ToList();
				CS$<>8__locals25.locRot = Quaternion.Inverse(((Component)CS$<>8__locals25.loc).transform.rotation);
				GUIUtility.systemCopyBuffer = string.Join("\n", list.Select(delegate(ZDO zdo)
				{
					//IL_0001: 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_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_0021: 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_0028: 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_0038: 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_006b: Unknown result type (might be due to invalid IL or missing references)
					Vector3 vec = CS$<>8__locals25.locRot * (zdo.GetPosition() - ((Component)CS$<>8__locals25.loc).transform.position);
					Quaternion quat = CS$<>8__locals25.locRot * zdo.GetRotation();
					return "  - " + CS$<>8__locals25.name + ", " + Helper.Print(vec) + ", " + Helper.Print(quat);
				}));
				args.Context.AddString($"{list.Count} objects copied for room {((Object)CS$<>8__locals25.loc.m_instance).name}");
			}

			internal List<string> <.ctor>b__3_10()
			{
				return ZNetScene.instance.m_namedPrefabs.Select((KeyValuePair<int, GameObject> prefab) => ((Object)prefab.Value).name).ToList();
			}

			internal string <.ctor>b__3_37(KeyValuePair<int, GameObject> prefab)
			{
				return ((Object)prefab.Value).name;
			}

			internal int <GetHovered>b__5_0(RaycastHit x, RaycastHit y)
			{
				return ((RaycastHit)(ref x)).distance.CompareTo(((RaycastHit)(ref y)).distance);
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass3_0
		{
			public float total;

			internal string <.ctor>b__12(KeyValuePair<Biome, int> kvp)
			{
				//IL_0019: Unknown result type (might be due to invalid IL or missing references)
				//IL_002d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0037: Expected I4, but got Unknown
				return string.Format("{0} ({1}): {2}/{3} ({4}", Enum.GetName(typeof(Biome), kvp.Key), (int)kvp.Key, kvp.Value, total, ((float)kvp.Value / total).ToString("P2", CultureInfo.InvariantCulture));
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass3_1
		{
			public DungeonGenerator dg;

			internal string <.ctor>b__22(KeyValuePair<string, FakeDungeonGenerator> kvp)
			{
				Spawner.Override(dg, kvp.Key);
				dg.SetupAvailableRooms();
				IEnumerable<string> values = DungeonGenerator.m_availableRooms.Select((RoomData room) => room.m_prefab.Name);
				return kvp.Key + ": " + string.Join(", ", values);
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass3_3
		{
			public Player player;

			public float distance;

			public int prefab;

			public LocationProxy loc;

			public Quaternion locRot;

			public string name;

			internal bool <.ctor>b__31(LocationProxy loc)
			{
				//IL_0006: 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)
				return Utils.DistanceXZ(((Component)loc).transform.position, ((Component)player).transform.position) < distance;
			}

			internal float <.ctor>b__32(LocationProxy loc)
			{
				//IL_0006: 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)
				return Utils.DistanceXZ(((Component)loc).transform.position, ((Component)player).transform.position);
			}

			internal bool <.ctor>b__33(ZDO zdo)
			{
				return zdo.GetPrefab() == prefab;
			}

			internal bool <.ctor>b__34(ZDO zdo)
			{
				//IL_0001: 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)
				return Utils.DistanceXZ(zdo.GetPosition(), ((Component)loc).transform.position) < distance;
			}

			internal float <.ctor>b__35(ZDO zdo)
			{
				//IL_0001: 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)
				return Utils.DistanceXZ(zdo.GetPosition(), ((Component)loc).transform.position);
			}

			internal string <.ctor>b__36(ZDO zdo)
			{
				//IL_0001: 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_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_0021: 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_0028: 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_0038: 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_006b: Unknown result type (might be due to invalid IL or missing references)
				Vector3 vec = locRot * (zdo.GetPosition() - ((Component)loc).transform.position);
				Quaternion quat = locRot * zdo.GetRotation();
				return "  - " + name + ", " + Helper.Print(vec) + ", " + Helper.Print(quat);
			}
		}

		private GameObject? goCollider;

		private string GetRoomItems(RoomData room)
		{
			GameObject val = Helper.SafeLoad(room);
			if (!Object.op_Implicit((Object)(object)val))
			{
				return "";
			}
			IEnumerable<string> values = from netView in Utils.GetEnabledComponentsInChildren<ZNetView>(val)
				select Utils.GetPrefabName(((Component)netView).gameObject) into name
				group name by name into @group
				select @group.Key + " x" + @group.Count();
			room.m_prefab.Release();
			return string.Join(", ", values);
		}

		private string GetLocationItems(ZoneLocation loc)
		{
			GameObject val = Helper.SafeLoad(loc);
			if (!Object.op_Implicit((Object)(object)val))
			{
				return "";
			}
			IEnumerable<string> values = from netView in Utils.GetEnabledComponentsInChildren<ZNetView>(val)
				select Utils.GetPrefabName(((Component)netView).gameObject) into name
				group name by name into @group
				select @group.Key + " x" + @group.Count();
			loc.m_prefab.Release();
			return string.Join(", ", values);
		}

		public unsafe DebugCommands()
		{
			//IL_0038: 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_002f: Expected O, but got Unknown
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Expected O, but got Unknown
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Expected O, but got Unknown
			//IL_00e0: 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_010a: Expected O, but got Unknown
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_012f: Expected O, but got Unknown
			//IL_012a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: 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_00d7: Expected O, but got Unknown
			//IL_0162: 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)
			//IL_014e: 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_0159: Expected O, but got Unknown
			//IL_01aa: Expected O, but got Unknown
			//IL_01a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0197: Unknown result type (might be due to invalid IL or missing references)
			//IL_019c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a2: Expected O, but got Unknown
			//IL_01c9: 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_01d4: Expected O, but got Unknown
			//IL_01fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f8: Expected O, but got Unknown
			object obj = <>c.<>9__3_0;
			if (obj == null)
			{
				ConsoleEvent val = delegate
				{
					WorldInfo.RegenerateMap();
				};
				<>c.<>9__3_0 = val;
				obj = (object)val;
			}
			new ConsoleCommand("ew_map", "Refreshes the world map.", (ConsoleEvent)obj, true, false, false, false, false, (ConsoleOptionsFetcher)null, false, false, false);
			object obj2 = <>c.<>9__3_1;
			if (obj2 == null)
			{
				ConsoleEvent val2 = delegate(ConsoleEventArgs args)
				{
					//IL_0054: Unknown result type (might be due to invalid IL or missing references)
					//IL_0059: Unknown result type (might be due to invalid IL or missing references)
					//IL_0074: 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_007d: 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_0094: 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_00a0: 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)
					float num = 100f;
					if (args.Length > 1 && int.TryParse(args[1], out var result))
					{
						num = result;
					}
					float radius = WorldInfo.Radius;
					float num2 = (0f - (float)Math.Ceiling(radius / num)) * num;
					Dictionary<Biome, int> dictionary = new Dictionary<Biome, int>();
					for (float num3 = num2; num3 <= radius; num3 += num)
					{
						for (float num4 = num2; num4 <= radius; num4 += num)
						{
							Vector2 val10 = new Vector2(num3, num4);
							if (!(((Vector2)(ref val10)).magnitude > radius))
							{
								Biome biome = WorldGenerator.instance.GetBiome(num3, num4, 0.02f, false);
								if (!dictionary.ContainsKey(biome))
								{
									dictionary[biome] = 0;
								}
								dictionary[biome]++;
							}
						}
					}
					float total = dictionary.Values.Sum();
					IEnumerable<string> values = from kvp in dictionary
						orderby Enum.GetName(typeof(Biome), kvp.Key)
						select string.Format("{0} ({1}): {2}/{3} ({4}", Enum.GetName(typeof(Biome), kvp.Key), (int)kvp.Key, kvp.Value, total, ((float)kvp.Value / total).ToString("P2", CultureInfo.InvariantCulture));
					ZLog.Log((object)string.Join("\n", values));
					args.Context.AddString(string.Join("\n", values));
				};
				<>c.<>9__3_1 = val2;
				obj2 = (object)val2;
			}
			new ConsoleCommand("ew_biomes", "[precision] - Counts biomes by sampling points with a given precision (meters).", (ConsoleEvent)obj2, true, false, false, false, false, (ConsoleOptionsFetcher)null, false, false, false);
			object obj3 = <>c.<>9__3_2;
			if (obj3 == null)
			{
				ConsoleEvent val3 = delegate(ConsoleEventArgs args)
				{
					MusicMan instance = MusicMan.instance;
					if (Object.op_Implicit((Object)(object)instance))
					{
						IEnumerable<string> values = from music in instance.m_music
							where music.m_enabled
							select music.m_name;
						ZLog.Log((object)string.Join("\n", values));
						args.Context.AddString(string.Join("\n", values));
					}
				};
				<>c.<>9__3_2 = val3;
				obj3 = (object)val3;
			}
			new ConsoleCommand("ew_musics", "- Prints available musics.", (ConsoleEvent)obj3, true, false, false, false, false, (ConsoleOptionsFetcher)null, false, false, false);
			object obj4 = <>c.<>9__3_3;
			if (obj4 == null)
			{
				ConsoleEvent val4 = delegate(ConsoleEventArgs args)
				{
					Minimap instance = Minimap.instance;
					if (Object.op_Implicit((Object)(object)instance))
					{
						IEnumerable<string> enumerable = instance.m_locationIcons.Select((LocationSpriteData icon) => icon.m_name).Concat<string>(instance.m_icons.Select((SpriteData icon) => ((object)(*(PinType*)(&icon.m_name))/*cast due to .constrained prefix*/).ToString()));
						ObjectDB instance2 = ObjectDB.instance;
						if (Object.op_Implicit((Object)(object)instance2))
						{
							enumerable = enumerable.Concat(instance2.m_items.Select((GameObject item) => ((Object)item).name));
						}
						if (Object.op_Implicit((Object)(object)instance2))
						{
							enumerable = enumerable.Concat(instance2.m_StatusEffects.Select((StatusEffect effect) => effect.m_name));
						}
						ZLog.Log((object)string.Join("\n", enumerable));
						args.Context.AddString(string.Join("\n", enumerable));
					}
				};
				<>c.<>9__3_3 = val4;
				obj4 = (object)val4;
			}
			new ConsoleCommand("ew_icons", "- Prints available location icons.", (ConsoleEvent)obj4, true, false, false, false, false, (ConsoleOptionsFetcher)null, false, false, false);
			new ConsoleCommand("ew_rooms", "- Logs available rooms.", (ConsoleEvent)delegate(ConsoleEventArgs args)
			{
				DungeonDB instance = DungeonDB.instance;
				if (Object.op_Implicit((Object)(object)instance))
				{
					List<string> list = instance.m_rooms.Select((RoomData room) => room.m_prefab.Name + " (" + DataManager.FromEnum<Theme>(room.m_theme) + "): " + GetRoomItems(room)).ToList();
					ZLog.Log((object)string.Join("\n", list));
					args.Context.AddString($"Logged {list.Count} rooms to the log file.");
				}
			}, true, false, false, false, false, (ConsoleOptionsFetcher)null, false, false, false);
			new ConsoleCommand("ew_locations", "- Logs available locations.", (ConsoleEvent)delegate(ConsoleEventArgs args)
			{
				ZoneSystem instance = ZoneSystem.instance;
				if (Object.op_Implicit((Object)(object)instance))
				{
					List<string> list = (from loc in instance.m_locations
						where loc.m_prefab.IsValid && loc.m_prefab.Name != "Blueprint"
						select loc.m_prefab.Name + ": " + GetLocationItems(loc)).ToList();
					ZLog.Log((object)string.Join("\n", list));
					args.Context.AddString($"Logged {list.Count} locations to the log file.");
				}
			}, true, false, false, false, false, (ConsoleOptionsFetcher)null, false, false, false);
			object obj5 = <>c.<>9__3_6;
			if (obj5 == null)
			{
				ConsoleEvent val5 = delegate(ConsoleEventArgs args)
				{
					//IL_0013: Unknown result type (might be due to invalid IL or missing references)
					//IL_0019: Expected O, but got Unknown
					if (Object.op_Implicit((Object)(object)ZoneSystem.instance))
					{
						GameObject val10 = new GameObject();
						DungeonGenerator dg = val10.AddComponent<DungeonGenerator>();
						List<string> list = DungeonObjects.Generators.Select<KeyValuePair<string, FakeDungeonGenerator>, string>(delegate(KeyValuePair<string, FakeDungeonGenerator> kvp)
						{
							Spawner.Override(dg, kvp.Key);
							dg.SetupAvailableRooms();
							IEnumerable<string> values = DungeonGenerator.m_availableRooms.Select((RoomData room) => room.m_prefab.Name);
							return kvp.Key + ": " + string.Join(", ", values);
						}).ToList();
						ZLog.Log((object)string.Join("\n", list));
						args.Context.AddString($"Logged {list.Count} dungeons to the log file.");
					}
				};
				<>c.<>9__3_6 = val5;
				obj5 = (object)val5;
			}
			new ConsoleCommand("ew_dungeons", "- Logs dungeons and their available rooms.", (ConsoleEvent)obj5, true, false, false, false, false, (ConsoleOptionsFetcher)null, false, false, false);
			ConsoleEvent val6 = delegate(ConsoleEventArgs args)
			{
				//IL_0092: Unknown result type (might be due to invalid IL or missing references)
				//IL_009c: Expected O, but got Unknown
				//IL_0122: 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_012c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0166: Unknown result type (might be due to invalid IL or missing references)
				//IL_0186: Unknown result type (might be due to invalid IL or missing references)
				//IL_01a6: Unknown result type (might be due to invalid IL or missing references)
				//IL_01c4: Unknown result type (might be due to invalid IL or missing references)
				//IL_0237: Unknown result type (might be due to invalid IL or missing references)
				//IL_023c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0241: Unknown result type (might be due to invalid IL or missing references)
				string name = "";
				if (args.Length < 2)
				{
					name = GetHovered(Player.m_localPlayer);
				}
				else
				{
					name = args.Args[1];
				}
				if (name == "")
				{
					args.Context.AddString("No object specified.");
				}
				else
				{
					Room[] source = Object.FindObjectsByType<Room>((FindObjectsInactive)0, (FindObjectsSortMode)0);
					Player player = Player.m_localPlayer;
					if (Object.op_Implicit((Object)(object)player))
					{
						if ((Object)(object)goCollider == (Object)null)
						{
							goCollider = Object.Instantiate<GameObject>(new GameObject("Collider"));
							goCollider.AddComponent<BoxCollider>();
						}
						BoxCollider collider = goCollider.GetComponent<BoxCollider>();
						Room room = (from val10 in source.Where(delegate(Room val10)
							{
								//IL_002a: 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_005d: 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)
								collider.size = new Vector3((float)((Vector3Int)(ref val10.m_size)).x, (float)((Vector3Int)(ref val10.m_size)).y, (float)((Vector3Int)(ref val10.m_size)).z);
								Transform transform = ((Component)val10).transform;
								((Component)collider).transform.position = transform.position;
								((Component)collider).transform.rotation = transform.rotation;
								return Contains((Collider)(object)collider, ((Component)player).transform.position);
							})
							orderby Utils.DistanceXZ(((Component)val10).transform.position, ((Component)player).transform.position)
							select val10).FirstOrDefault();
						if (!Object.op_Implicit((Object)(object)room))
						{
							args.Context.AddString("No room found.");
						}
						else if (Object.op_Implicit((Object)(object)DungeonDB.instance))
						{
							Vector2i zone = ZoneSystem.GetZone(((Component)room).transform.position);
							collider.size = new Vector3((float)((Vector3Int)(ref room.m_size)).x, (float)((Vector3Int)(ref room.m_size)).y, (float)((Vector3Int)(ref room.m_size)).z);
							((Component)collider).transform.position = ((Component)room).transform.position;
							((Component)collider).transform.rotation = ((Component)room).transform.rotation;
							ZNetScene.instance.m_tempCurrentObjects.Clear();
							ZDOMan.instance.FindSectorObjects(zone, 1, 0, ZNetScene.instance.m_tempCurrentObjects, (List<ZDO>)null);
							int prefab = StringExtensionMethods.GetStableHashCode(name);
							List<ZDO> list = (from zdo in ZNetScene.instance.m_tempCurrentObjects
								where zdo.GetPrefab() == prefab
								where Contains((Collider)(object)collider, zdo.GetPosition())
								orderby Utils.DistanceXZ(zdo.GetPosition(), ((Component)room).transform.position)
								select zdo).ToList();
							Quaternion roomRot = Quaternion.Inverse(((Component)room).transform.rotation);
							GUIUtility.systemCopyBuffer = string.Join("\n", list.Select(delegate(ZDO zdo)
							{
								//IL_0001: 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_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_0021: 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_0028: 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_0038: 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_006b: Unknown result type (might be due to invalid IL or missing references)
								Vector3 vec = roomRot * (zdo.GetPosition() - ((Component)room).transform.position);
								Quaternion quat = roomRot * zdo.GetRotation();
								return "  - " + name + ", " + Helper.Print(vec) + ", " + Helper.Print(quat);
							}));
							args.Context.AddString($"{list.Count} objects copied for room {((Object)room).name}");
						}
					}
				}
			};
			object obj6 = <>c.<>9__3_8;
			if (obj6 == null)
			{
				ConsoleOptionsFetcher val7 = () => ZNetScene.instance.m_namedPrefabs.Select((KeyValuePair<int, GameObject> prefab) => ((Object)prefab.Value).name).ToList();
				<>c.<>9__3_8 = val7;
				obj6 = (object)val7;
			}
			new ConsoleCommand("ew_copy_room", "[object] - Saves objects of current room.", val6, true, false, false, false, false, (ConsoleOptionsFetcher)obj6, false, false, false);
			object obj7 = <>c.<>9__3_9;
			if (obj7 == null)
			{
				ConsoleEvent val8 = delegate(ConsoleEventArgs args)
				{
					//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
					//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
					//IL_00f1: 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_0179: Unknown result type (might be due to invalid IL or missing references)
					//IL_017e: Unknown result type (might be due to invalid IL or missing references)
					//IL_0183: Unknown result type (might be due to invalid IL or missing references)
					string name = "";
					if (args.Length < 2)
					{
						name = GetHovered(Player.m_localPlayer);
					}
					else
					{
						name = args.Args[1];
					}
					if (name == "")
					{
						args.Context.AddString("No object specified.");
					}
					else
					{
						float distance = args.TryParameterFloat(2, 50f);
						LocationProxy[] source = Object.FindObjectsByType<LocationProxy>((FindObjectsInactive)0, (FindObjectsSortMode)0);
						Player player = Player.m_localPlayer;
						if (Object.op_Implicit((Object)(object)player))
						{
							LocationProxy loc = (from val10 in source
								where Utils.DistanceXZ(((Component)val10).transform.position, ((Component)player).transform.position) < distance
								orderby Utils.DistanceXZ(((Component)val10).transform.position, ((Component)player).transform.position)
								select val10).FirstOrDefault();
							if (!Object.op_Implicit((Object)(object)loc))
							{
								args.Context.AddString("No location found.");
							}
							else
							{
								Vector2i zone = ZoneSystem.GetZone(((Component)loc).transform.position);
								ZNetScene.instance.m_tempCurrentObjects.Clear();
								ZDOMan.instance.FindSectorObjects(zone, 1, 0, ZNetScene.instance.m_tempCurrentObjects, (List<ZDO>)null);
								int prefab = StringExtensionMethods.GetStableHashCode(name);
								List<ZDO> list = (from zdo in ZNetScene.instance.m_tempCurrentObjects
									where zdo.GetPrefab() == prefab
									where Utils.DistanceXZ(zdo.GetPosition(), ((Component)loc).transform.position) < distance
									orderby Utils.DistanceXZ(zdo.GetPosition(), ((Component)loc).transform.position)
									select zdo).ToList();
								Quaternion locRot = Quaternion.Inverse(((Component)loc).transform.rotation);
								GUIUtility.systemCopyBuffer = string.Join("\n", list.Select(delegate(ZDO zdo)
								{
									//IL_0001: 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_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_0021: 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_0028: 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_0038: 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_006b: Unknown result type (might be due to invalid IL or missing references)
									Vector3 vec = locRot * (zdo.GetPosition() - ((Component)loc).transform.position);
									Quaternion quat = locRot * zdo.GetRotation();
									return "  - " + name + ", " + Helper.Print(vec) + ", " + Helper.Print(quat);
								}));
								args.Context.AddString($"{list.Count} objects copied for room {((Object)loc.m_instance).name}");
							}
						}
					}
				};
				<>c.<>9__3_9 = val8;
				obj7 = (object)val8;
			}
			object obj8 = <>c.<>9__3_10;
			if (obj8 == null)
			{
				ConsoleOptionsFetcher val9 = () => ZNetScene.instance.m_namedPrefabs.Select((KeyValuePair<int, GameObject> prefab) => ((Object)prefab.Value).name).ToList();
				<>c.<>9__3_10 = val9;
				obj8 = (object)val9;
			}
			new ConsoleCommand("ew_copy_location", "[object] [distance=50] - Saves objects of current location.", (ConsoleEvent)obj7, true, false, false, false, false, (ConsoleOptionsFetcher)obj8, false, false, false);
		}

		private static bool Contains(Collider collider, Vector3 worldPosition)
		{
			//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_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			Bounds bounds = collider.bounds;
			Vector3 val = ((Bounds)(ref bounds)).center - worldPosition;
			Ray val2 = default(Ray);
			((Ray)(ref val2))..ctor(worldPosition, val);
			RaycastHit val3 = default(RaycastHit);
			return collider.Raycast(val2, ref val3, ((Vector3)(ref val)).magnitude);
		}

		private static string GetHovered(Player obj)
		{
			//IL_0077: 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_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: 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_00d5: Unknown result type (might be due to invalid IL or missing references)
			float num = 50f;
			int mask = LayerMask.GetMask(new string[11]
			{
				"item", "piece", "piece_nonsolid", "Default", "static_solid", "Default_small", "character", "character_net", "terrain", "vehicle",
				"character_trigger"
			});
			RaycastHit[] array = Physics.RaycastAll(((Component)GameCamera.instance).transform.position, ((Component)GameCamera.instance).transform.forward, num, mask);
			Array.Sort(array, (RaycastHit x, RaycastHit y) => ((RaycastHit)(ref x)).distance.CompareTo(((RaycastHit)(ref y)).distance));
			RaycastHit[] array2 = array;
			for (int num2 = 0; num2 < array2.Length; num2++)
			{
				RaycastHit val = array2[num2];
				if (!(Vector3.Distance(((RaycastHit)(ref val)).point, ((Character)obj).m_eye.position) >= 50f))
				{
					ZNetView componentInParent = ((Component)((RaycastHit)(ref val)).collider).GetComponentInParent<ZNetView>();
					if (Object.op_Implicit((Object)(object)componentInParent) && !Object.op_Implicit((Object)(object)((Component)((RaycastHit)(ref val)).collider).GetComponent<EffectArea>()) && !((Object)(object)((Component)componentInParent).GetComponentInChildren<Player>() == (Object)(object)obj))
					{
						return ((Object)ZNetScene.instance.m_namedPrefabs[componentInParent.GetZDO().GetPrefab()]).name;
					}
				}
			}
			return "";
		}
	}
	public class DungeonDoorYaml
	{
		public string prefab = "";

		public string connectionType = "";

		public float chance;
	}
	public class DungeonYaml
	{
		public string name = "";

		public string algorithm = "";

		public int maxRooms = 1;

		public int minRooms = 1;

		public int minRequiredRooms = 1;

		[DefaultValue("")]
		public string requiredRooms = "";

		[DefaultValue("")]
		public string excludedRooms = "";

		[DefaultValue(false)]
		public bool alternative;

		[DefaultValue(false)]
		public bool roomWeights;

		[DefaultValue(false)]
		public bool randomSeed;

		[DefaultValue("")]
		public string themes = "";

		public DungeonDoorYaml[] doorTypes = Array.Empty<DungeonDoorYaml>();

		public float doorChance;

		[DefaultValue(90f)]
		public float maxTilt = 90f;

		public float tileWidth;

		[DefaultValue(1f)]
		public float spawnChance = 1f;

		public float campRadiusMin;

		public float campRadiusMax;

		public float minAltitude;

		public int gridSize;

		public int perimeterSections;

		public float perimeterBuffer;

		[DefaultValue(false)]
		public bool interiorTransform;

		[DefaultValue("")]
		public string bounds = "";

		[DefaultValue(null)]
		public string[]? objectData;

		[DefaultValue(null)]
		public string[]? objectSwap;
	}
	public class FakeDungeonGenerator
	{
		public string name = "";

		public Algorithm m_algorithm;

		public Vector3 m_zoneSize = new Vector3(64f, 64f, 64f);

		public int m_maxRooms = 1;

		public int m_minRooms = 1;

		public int m_minRequiredRooms = 1;

		public HashSet<string> m_excludedRooms = new HashSet<string>();

		public List<string> m_requiredRooms = new List<string>();

		public bool m_alternativeFunctionality;

		public List<string> m_themes = new List<string>();

		public List<DoorDef> m_doorTypes = new List<DoorDef>();

		public float m_doorChance;

		public float m_maxTilt;

		public float m_tileWidth;

		public float m_spawnChance;

		public float m_campRadiusMin;

		public float m_campRadiusMax;

		public float m_minAltitude;

		public int m_gridSize;

		public int m_perimeterSections;

		public float m_perimeterBuffer;

		public bool m_useCustomInteriorTransform;

		public Dictionary<string, List<Tuple<float, string>>> m_objectSwaps = new Dictionary<string, List<Tuple<float, string>>>();

		public Dictionary<string, List<Tuple<float, DataEntry?>>> m_objectData = new Dictionary<string, List<Tuple<float, DataEntry>>>();

		public bool m_randomSeed;
	}
	public class RoomConnectionYaml
	{
		public string position = "";

		[DefaultValue("")]
		public string type = "";

		[DefaultValue(false)]
		public bool entrance;

		[DefaultValue(false)]
		public bool exitOnly;

		[DefaultValue("true")]
		public string door = "true";
	}
	public class RoomYaml
	{
		public string name = "";

		public string theme = "";

		[DefaultValue(true)]
		public bool enabled = true;

		[DefaultValue(false)]
		public bool entrance;

		[DefaultValue(false)]
		public bool endCap;

		[DefaultValue(false)]
		public bool divider;

		[DefaultValue(0)]
		public int endCapPriority;

		[DefaultValue(0)]
		public int minPlaceOrder;

		[DefaultValue(1f)]
		public float weight = 1f;

		[DefaultValue(false)]
		public bool faceCenter;

		[DefaultValue(false)]
		public bool perimeter;

		public string size = "";

		public RoomConnectionYaml[] connections = Array.Empty<RoomConnectionYaml>();

		[DefaultValue(null)]
		public string[]? objectSwap;

		[DefaultValue(null)]
		public string[]? objectData;

		[DefaultValue(null)]
		public string[]? objects;
	}
	public class RoomLoading
	{
		public static string FileName = "expand_rooms.yaml";

		public static string FilePath = Path.Combine(Yaml.BaseDirectory, FileName);

		public static string Pattern = "expand_rooms*.yaml";

		private static readonly List<RoomYaml> ExtraRoomYamls = new List<RoomYaml>();

		private static List<RoomData> DefaultEntries = new List<RoomData>();

		private static Dictionary<string, string> RoomNames = new Dictionary<string, string>();

		private static readonly Dictionary<string, Theme> DefaultNameToTheme = new Dictionary<string, Theme>
		{
			{
				"Crypt",
				(Theme)1
			},
			{
				"SunkenCrypt",
				(Theme)2
			},
			{
				"Cave",
				(Theme)4
			},
			{
				"ForestCrypt",
				(Theme)8
			},
			{
				"GoblinCamp",
				(Theme)16
			},
			{
				"MeadowsVillage",
				(Theme)32
			},
			{
				"MeadowsFarm",
				(Theme)64
			},
			{
				"DvergerTown",
				(Theme)128
			},
			{
				"DvergerBoss",
				(Theme)256
			},
			{
				"ForestCryptHildir",
				(Theme)512
			},
			{
				"CaveHildir",
				(Theme)1024
			},
			{
				"PlainsFortHildir",
				(Theme)2048
			},
			{
				"AshlandRuins",
				(Theme)4096
			},
			{
				"FortressRuins",
				(Theme)8192
			}
		};

		public static Dictionary<string, Theme> NameToTheme = DefaultNameToTheme.ToDictionary<KeyValuePair<string, Theme>, string, Theme>((KeyValuePair<string, Theme> kvp) => kvp.Key.ToLowerInvariant(), (KeyValuePair<string, Theme> kvp) => kvp.Value);

		public static Dictionary<Theme, string> ThemeToName = DefaultNameToTheme.ToDictionary<KeyValuePair<string, Theme>, Theme, string>((KeyValuePair<string, Theme> kvp) => kvp.Value, (KeyValuePair<string, Theme> kvp) => kvp.Key);

		private static readonly List<GameObject> CreatedObjects = new List<GameObject>();

		public static void AddRoom(RoomYaml yaml)
		{
			ExtraRoomYamls.Add(yaml);
		}

		public static List<string> ParseRooms(string names)
		{
			string value;
			return (from s in DataManager.ToList(names)
				select (!RoomNames.TryGetValue(s, out value)) ? s : value).ToList();
		}

		public static void Initialize()
		{
			DefaultEntries.Clear();
			RoomSpawning.Prefabs.Clear();
			RoomSpawning.RoomSizes.Clear();
			if (Helper.IsServer())
			{
				SetDefaultEntries();
			}
			Load();
		}

		private static void ToFile()
		{
			List<RoomYaml> list = (from d in DefaultEntries.Select(ToData)
				where d != null
				select d).ToList();
			if (ExtraRoomYamls.Count > 0)
			{
				list.AddRange(ExtraRoomYamls);
			}
			Save(list, log: false);
		}

		public static bool TryGetTheme(string name, out Theme theme)
		{
			return NameToTheme.TryGetValue(name.ToLowerInvariant(), out theme);
		}

		public static void Load()
		{
			RoomSpawning.Data.Clear();
			RoomSpawning.Blueprints.Clear();
			DungeonObjects.Objects.Clear();
			DungeonObjects.ObjectSwaps.Clear();
			DungeonObjects.ObjectData.Clear();
			CreatedObjects.ForEach((Action<GameObject>)Object.Destroy);
			CreatedObjects.Clear();
			NameToTheme = DefaultNameToTheme.ToDictionary<KeyValuePair<string, Theme>, string, Theme>((KeyValuePair<string, Theme> kvp) => kvp.Key.ToLowerInvariant(), (KeyValuePair<string, Theme> kvp) => kvp.Value);
			ThemeToName = DefaultNameToTheme.ToDictionary<KeyValuePair<string, Theme>, Theme, string>((KeyValuePair<string, Theme> kvp) => kvp.Value, (KeyValuePair<string, Theme> kvp) => kvp.Key);
			if (Helper.IsClient())
			{
				return;
			}
			if (!Configuration.DataRooms)
			{
				Log.Info($"Reloading default room data ({DefaultEntries.Count} entries).");
				return;
			}
			if (!File.Exists(FilePath))
			{
				ToFile();
				return;
			}
			List<RoomData> list = FromFile();
			if (list.Count == 0)
			{
				Log.Warning("Failed to load any room data.");
				Log.Info($"Reloading default room data ({DefaultEntries.Count} entries).");
			}
			else if (!Configuration.DataMigration || !AddMissingEntries(list))
			{
				Log.Info($"Reloading room themes ({NameToTheme.Count} entries).");
				Log.Info($"Reloading room data ({list.Count} entries).");
				RoomNames = Helper.ToDict(list, (RoomData item) => item.m_prefab.Name.ToLowerInvariant(), (RoomData item) => item.m_prefab.Name);
				DungeonDB.instance.m_rooms = list;
			}
		}

		public static RoomData CreateRoomData(string name, string[] snapPieces)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0132: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_0159: 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)
			RoomData val = new RoomData();
			Room room = new GameObject(name).AddComponent<Room>();
			CreatedObjects.Add(((Component)room).gameObject);
			val.m_loadedRoom = room;
			string text = Parse.Name(name);
			if (RoomSpawning.Prefabs.TryGetValue(text, out RoomData value))
			{
				val.m_prefab = value.m_prefab;
				if ((Object)(object)Helper.SafeLoad(value) == (Object)null)
				{
					return val;
				}
				room.m_musicPrefab = value.RoomInPrefab.m_musicPrefab;
				RoomConnection[] connections = value.RoomInPrefab.GetConnections();
				if (connections.Length != snapPieces.Length)
				{
					Log.Warning($"Room {name} has {snapPieces.Length} connections, but base room {value.m_prefab.Name} has {connections.Length} connections.");
				}
				Room obj = room;
				List<RoomConnection> list = new List<RoomConnection>();
				list.AddRange(connections.Select(delegate(RoomConnection c)
				{
					//IL_0006: 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_0059: Unknown result type (might be due to invalid IL or missing references)
					RoomConnection val2 = new GameObject(((Object)c).name).AddComponent<RoomConnection>();
					CreatedObjects.Add(((Component)val2).gameObject);
					((Component)val2).transform.parent = ((Component)room).transform;
					((Component)val2).transform.localPosition = ((Component)c).transform.localPosition;
					((Component)val2).transform.localRotation = ((Component)c).transform.localRotation;
					val2.m_type = c.m_type;
					val2.m_entrance = c.m_entrance;
					val2.m_allowDoor = c.m_allowDoor;
					val2.m_doorOnlyIfOtherAlsoAllowsDoor = c.m_doorOnlyIfOtherAlsoAllowsDoor;
					return val2;
				}));
				obj.m_roomConnections = list.ToArray();
				value.m_prefab.Release();
			}
			else if (BlueprintManager.Load(text, snapPieces))
			{
				RoomSpawning.Blueprints[val] = text;
				SoftReference<GameObject> prefab = default(SoftReference<GameObject>);
				prefab..ctor(default(AssetID));
				prefab.m_name = name;
				prefab.m_loadedAsset = ((Component)room).gameObject;
				val.m_prefab = prefab;
				Room obj2 = room;
				List<RoomConnection> list2 = new List<RoomConnection>();
				list2.AddRange(((IEnumerable<string>)snapPieces).Select((Func<string, RoomConnection>)delegate
				{
					//IL_0005: Unknown result type (might be due to invalid IL or missing references)
					RoomConnection val2 = new GameObject("").AddComponent<RoomConnection>();
					CreatedObjects.Add(((Component)val2).gameObject);
					((Component)val2).transform.parent = ((Component)room).transform;
					return val2;
				}));
				obj2.m_roomConnections = list2.ToArray();
			}
			return val;
		}

		private static void UpdateConnections(Room room, RoomConnectionYaml[] data)
		{
			//IL_001c: 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_011d: Unknown result type (might be due to invalid IL or missing references)
			for (int i = 0; i < data.Length; i++)
			{
				RoomConnectionYaml roomConnectionYaml = data[i];
				if (i >= room.m_roomConnections.Length)
				{
					RoomConnection val = new GameObject(roomConnectionYaml.type).AddComponent<RoomConnection>();
					CreatedObjects.Add(((Component)val).gameObject);
					((Component)val).transform.parent = ((Component)room).transform;
					room.m_roomConnections = room.m_roomConnections.Append(val).ToArray();
				}
				RoomConnection val2 = room.m_roomConnections[i];
				if (((Object)val2).name == "")
				{
					((Object)val2).name = roomConnectionYaml.type;
				}
				val2.m_type = (roomConnectionYaml.exitOnly ? (">" + roomConnectionYaml.type) : roomConnectionYaml.type);
				val2.m_entrance = roomConnectionYaml.entrance;
				val2.m_allowDoor = roomConnectionYaml.door == "true";
				val2.m_doorOnlyIfOtherAlsoAllowsDoor = roomConnectionYaml.door == "other";
				string[] array = Parse.Split(roomConnectionYaml.position);
				if (array.Length > 2)
				{
					((Component)val2).transform.localPosition = Parse.VectorXZY(array, 0);
				}
				if (array.Length > 3)
				{
					((Component)val2).transform.localRotation = Parse.AngleYXZ(array, 3);
				}
			}
		}

		private static RoomData FromData(RoomYaml data, string fileName)
		{
			//IL_009e: 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_00a4: 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_00be: 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_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			//IL_012f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0136: 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_0144: Unknown result type (might be due to invalid IL or missing references)
			//IL_0149: Unknown result type (might be due to invalid IL or missing references)
			//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)
			string[] snapPieces = data.connections.Select((RoomConnectionYaml c) => c.position).ToArray();
			RoomData val = CreateRoomData(data.name, snapPieces);
			RoomSpawning.Data[val] = data;
			Room roomInPrefab = val.RoomInPrefab;
			string[] array = (from s in DataManager.ToList(data.theme)
				where !NameToTheme.ContainsKey(s.ToLowerInvariant())
				select s).ToArray();
			foreach (string text in array)
			{
				Theme val2 = (Theme)(2 * NameToTheme.Values.Max());
				NameToTheme[text.ToLowerInvariant()] = val2;
				ThemeToName[val2] = text;
			}
			roomInPrefab.m_theme = DataManager.ToEnum<Theme>(data.theme);
			roomInPrefab.m_entrance = data.entrance;
			roomInPrefab.m_endCap = data.endCap;
			roomInPrefab.m_divider = data.divider;
			roomInPrefab.m_enabled = data.enabled;
			Vector3 val3 = Parse.VectorXZY(data.size);
			RoomSpawning.RoomSizes[roomInPrefab] = val3;
			roomInPrefab.m_size = new Vector3Int((int)val3.x, (int)val3.y, (int)val3.z);
			roomInPrefab.m_minPlaceOrder = data.minPlaceOrder;
			roomInPrefab.m_weight = data.weight;
			roomInPrefab.m_faceCenter = data.faceCenter;
			roomInPrefab.m_perimeter = data.perimeter;
			roomInPrefab.m_endCapPrio = data.endCapPriority;
			val.m_theme = roomInPrefab.m_theme;
			val.m_enabled = roomInPrefab.m_enabled;
			UpdateConnections(roomInPrefab, data.connections);
			if (data.objects != null)
			{
				DungeonObjects.Objects[val] = Helper.ParseObjects(data.objects, fileName);
			}
			if (data.objectSwap != null)
			{
				DungeonObjects.ObjectSwaps[val] = Spawn.LoadSwaps(data.objectSwap);
			}
			if (data.objectData != null)
			{
				DungeonObjects.ObjectData[val] = Spawn.LoadData(data.objectData, fileName);
			}
			return val;
		}

		private static RoomYaml ToData(RoomData roomData)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)Helper.SafeLoad(roomData) == (Object)null)
			{
				return null;
			}
			Room roomInPrefab = roomData.RoomInPrefab;
			RoomYaml result = new RoomYaml
			{
				name = ((Object)((Component)roomInPrefab).gameObject).name,
				theme = DataManager.FromEnum<Theme>(roomInPrefab.m_theme),
				entrance = roomInPrefab.m_entrance,
				endCap = roomInPrefab.m_endCap,
				divider = roomInPrefab.m_divider,
				enabled = roomInPrefab.m_enabled,
				size = $"{((Vector3Int)(ref roomInPrefab.m_size)).x},{((Vector3Int)(ref roomInPrefab.m_size)).z},{((Vector3Int)(ref roomInPrefab.m_size)).y}",
				minPlaceOrder = roomInPrefab.m_minPlaceOrder,
				weight = roomInPrefab.m_weight,
				faceCenter = roomInPrefab.m_faceCenter,
				perimeter = roomInPrefab.m_perimeter,
				endCapPriority = roomInPrefab.m_endCapPrio,
				connections = (from connection in roomInPrefab.GetConnections()
					select new RoomConnectionYaml
					{
						position = Helper.Print(((Component)connection).transform.localPosition) + "," + Helper.Print(((Component)connection).transform.localRotation),
						type = connection.m_type,
						entrance = connection.m_entrance,
						door = (connection.m_allowDoor ? "true" : (connection.m_doorOnlyIfOtherAlsoAllowsDoor ? "other" : "false"))
					}).ToArray()
			};
			roomData.m_prefab.Release();
			return result;
		}

		private static List<RoomData> FromFile()
		{
			try
			{
				return DataManager.ReadData<RoomYaml, RoomData>(Pattern, FromData).Where(delegate(RoomData room)
				{
					//IL_0004: Unknown result type (might be due to invalid IL or missing references)
					if (room != null)
					{
						_ = room.m_prefab;
						return !string.IsNullOrWhiteSpace(room.m_prefab.m_name);
					}
					return false;
				}).ToList();
			}
			catch (Exception ex)
			{
				Log.Error(ex.Message);
				Log.Error(ex.StackTrace);
			}
			return new List<RoomData>();
		}

		private static void SetDefaultEntries()
		{
			DefaultEntries = DungeonDB.instance.m_rooms.Where((RoomData room) => room.m_prefab.IsValid).ToList();
			RoomSpawning.Prefabs = DefaultEntries.ToDictionary((RoomData entry) => entry.m_prefab.Name, (RoomData entry) => entry);
		}

		private static bool AddMissingEntries(List<RoomData> entries)
		{
			HashSet<string> missingKeys = DefaultEntries.Select((RoomData entry) => entry.m_prefab.Name).Distinct().ToHashSet();
			foreach (RoomData entry in entries)
			{
				missingKeys.Remove(entry.m_prefab.Name);
			}
			if (missingKeys.Count == 0)
			{
				return false;
			}
			List<RoomYaml> list = (from d in DefaultEntries.Where((RoomData entry) => missingKeys.Contains(entry.m_prefab.Name)).Select(ToData)
				where d != null
				select d).ToList();
			Log.Warning($"Adding {list.Count} missing rooms to the expand_rooms.yaml file.");
			Save(list, log: true);
			return true;
		}

		private static void Save(List<RoomYaml> data, bool log)
		{
			Dictionary<string, List<RoomYaml>> dictionary = new Dictionary<string, List<RoomYaml>>();
			foreach (RoomYaml datum in data)
			{
				string modFromPrefab = AssetTracker.GetModFromPrefab(datum.name);
				string key = (Configuration.SplitDataPerMod ? AssetTracker.GetFileNameFromMod(modFromPrefab) : "");
				if (!dictionary.ContainsKey(key))
				{
					dictionary[key] = new List<RoomYaml>();
				}
				dictionary[key].Add(datum);
				if (log)
				{
					Log.Warning(modFromPrefab + ": " + datum.name);
				}
			}
			foreach (KeyValuePair<string, List<RoomYaml>> item in dictionary)
			{
				string path = Path.Combine(Yaml.BaseDirectory, "expand_rooms" + item.Key + ".yaml");
				string text = (File.Exists(path) ? (File.ReadAllText(path) + "\n") : "");
				text += Yaml.Serializer().Serialize((object)item.Value);
				File.WriteAllText(path, text);
			}
		}

		public static void SetupWatcher()
		{
			Yaml.SetupWatcher(Pattern, Load);
		}
	}
	[HarmonyPatch(typeof(DungeonGenerator))]
	public class RoomSpawning
	{
		public static Dictionary<string, RoomData> Prefabs = new Dictionary<string, RoomData>();

		public static Dictionary<Room, Vector3> RoomSizes = new Dictionary<Room, Vector3>();

		public static Dictionary<RoomData, RoomYaml> Data = new Dictionary<RoomData, RoomYaml>();

		public static Dictionary<RoomData, string> Blueprints = new Dictionary<RoomData, string>();

		private static bool IsBaseRoom(RoomData room)
		{
			string key = Parse.Name(room.m_prefab.Name);
			return Prefabs.ContainsKey(key);
		}

		[HarmonyPatch("SetupAvailableRooms")]
		[HarmonyPostfix]
		private static void SetupAvailableRooms()
		{
			//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)
			//IL_00cb: 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)
			if (Helper.IsClient())
			{
				return;
			}
			foreach (RoomData availableRoom in DungeonGenerator.m_availableRooms)
			{
				if (!Blueprints.TryGetValue(availableRoom, out string value))
				{
					continue;
				}
				Room roomInPrefab = availableRoom.RoomInPrefab;
				if (BlueprintManager.TryGet(value, out Blueprint bp))
				{
					if (Data.TryGetValue(availableRoom, out RoomYaml value2) && value2.size == "")
					{
						roomInPrefab.m_size = new Vector3Int((int)Mathf.Ceil(bp.Size.x), (int)Mathf.Ceil(bp.Size.y), (int)Mathf.Ceil(bp.Size.z));
					}
					for (int i = 0; i < bp.SnapPoints.Count && i < roomInPrefab.m_roomConnections.Length; i++)
					{
						RoomConnection obj = roomInPrefab.m_roomConnections[i];
						((Component)obj).transform.localPosition = bp.SnapPoints[i].Pos;
						((Component)obj).transform.localRotation = bp.SnapPoints[i].Rot;
					}
				}
			}
		}

		[HarmonyPatch("Save")]
		[HarmonyPrefix]
		private static void CleanRoomsForSaving()
		{
			if (Prefabs.Count == 0 || Helper.IsClient())
			{
				return;
			}
			foreach (Room placedRoom in DungeonGenerator.m_placedRooms)
			{
				((Object)placedRoom).name = Parse.Name(((Object)placedRoom).name);
			}
			DungeonGenerator.m_placedRooms = DungeonGenerator.m_placedRooms.Where((Room r) => DungeonDB.instance.GetRoom(r.GetHash()) != null).ToList();
		}

		[HarmonyPatch("TestCollision")]
		[HarmonyPrefix]
		private static bool TestCollisionCustom(DungeonGenerator __instance, Room room, Vector3 pos, Quaternion rot, ref bool __result)
		{
			//IL_0014: 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_0016: Unknown result type (might be due to invalid IL or missing references)
			if (!RoomSizes.TryGetValue(room, out var value))
			{
				return true;
			}
			__result = TestCollision(__instance, pos, rot, value);
			return false;
		}

		private static bool TestCollision(DungeonGenerator dg, Vector3 pos, Quaternion rot, Vector3 size)
		{
			//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)
			//IL_0003: 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_001f: 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_0037: 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_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: 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_0085: 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_009d: Unknown result type (might be due to invalid IL or missing references)
			if (!IsInsideDungeon(dg, pos, rot, size))
			{
				return true;
			}
			dg.m_colliderA.size = new Vector3(size.x - 0.1f, size.y - 0.1f, size.z - 0.1f);
			Vector3 val = default(Vector3);
			float num = default(float);
			foreach (Room placedRoom in DungeonGenerator.m_placedRooms)
			{
				dg.m_colliderB.size = (RoomSizes.TryGetValue(placedRoom, out var value) ? value : Vector3Int.op_Implicit(placedRoom.m_size));
				if (Physics.ComputePenetration((Collider)(object)dg.m_colliderA, pos, rot, (Collider)(object)dg.m_colliderB, ((Component)placedRoom).transform.position, ((Component)placedRoom).transform.rotation, ref val, ref num))
				{
					return true;
				}
			}
			return false;
		}

		private static bool IsInsideDungeon(DungeonGenerator dg, Vector3 pos, Quaternion rot, Vector3 size)
		{
			//IL_0003: 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_0013: 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_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: 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_0037: 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_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_0053: 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_0061: 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_0072: 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_0085: 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_0091: 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_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: 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_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: 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_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: 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_00e2: 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_00e4: 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_00f1: 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_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: 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_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: Unknown result type (might be due to invalid IL or missing references)
			//IL_012f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_0142: 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)
			//IL_0144: 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_0151: 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_0161: Unknown result type (might be due to invalid IL or missing references)
			//IL_016f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0170: Unknown result type (might be due to invalid IL or missing references)
			//IL_0171: Unknown result type (might be due to invalid IL or missing references)
			//IL_0178: 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_0185: 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_018f: Unknown result type (might be due to invalid IL or missing references)
			Bounds val = default(Bounds);
			((Bounds)(ref val))..ctor(dg.m_zoneCenter, dg.m_zoneSize);
			size *= 0.5f;
			if (((Bounds)(ref val)).Contains(pos + rot * new Vector3(size.x, size.y, 0f - size.z)) && ((Bounds)(ref val)).Contains(pos + rot * new Vector3(0f - size.x, size.y, 0f - size.z)) && ((Bounds)(ref val)).Contains(pos + rot * new Vector3(size.x, size.y, size.z)) && ((Bounds)(ref val)).Contains(pos + rot * new Vector3(0f - size.x, size.y, size.z)) && ((Bounds)(ref val)).Contains(pos + rot * new Vector3(size.x, 0f - size.y, 0f - size.z)) && ((Bounds)(ref val)).Contains(pos + rot * new Vector3(0f - size.x, 0f - size.y, 0f - size.z)) && ((Bounds)(ref val)).Contains(pos + rot * new Vector3(size.x, 0f - size.y, size.z)))
			{
				return ((Bounds)(ref val)).Contains(pos + rot * new Vector3(0f - size.x, 0f - size.y, size.z));
			}
			return false;
		}
	}
	[BepInPlugin("expand_world_data", "Expand World Data", "1.68")]
	public class EWD : BaseUnityPlugin
	{
		public const string GUID = "expand_world_data";

		public const string NAME = "Expand World Data";

		public const string VERSION = "1.68";

		public static EWD Instance;

		public static Harmony Harmony;

		public static ConfigSync ConfigSync = new ConfigSync("expand_world_data", sendBiomes: true)
		{
			DisplayName = "Expand World Data",
			CurrentVersion = "1.68",
			ModRequired = true,
			IsLocked = true
		};

		public void InvokeRegenerate()
		{
			WorldGenerator instance = WorldGenerator.instance;
			if (instance != null && instance.m_world?.m_menu == false)
			{
				((MonoBehaviour)this).CancelInvoke("Regenerate");
				((MonoBehaviour)this).Invoke("Regenerate", 1f);
			}
		}

		public void Regenerate()
		{
			WorldInfo.AutomaticRegenerate(Harmony);
		}

		public void Awake()
		{
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Expected O, but got Unknown
			Instance = this;
			Log.Init(((BaseUnityPlugin)this).Logger);
			Yaml.Init();
			BiomeManager.SetupBiomeArrays();
			Configuration.Init(new ConfigWrapper("expand_config", ((BaseUnityPlugin)this).Config, ConfigSync, InvokeRegenerate));
			Harmony = new Harmony("expand_world_data");
			Harmony.PatchAll();
			try
			{
				if (!Directory.Exists(Yaml.BaseDirectory))
				{
					Directory.CreateDirectory(Yaml.BaseDirectory);
				}
				if (Configuration.DataReload)
				{
					Yaml.SetupWatcher(((BaseUnityPlugin)this).Config);
					DataLoading.SetupWatcher();
					BiomeManager.SetupWatcher();
					TerritoryManager.SetupWatcher();
					LocationLoading.SetupWatcher();
					VegetationLoading.SetupWatcher();
					WorldManager.SetupWatcher();
					ClutterManager.SetupWatcher();
					EnvironmentManager.SetupWatcher();
					Loader.SetupWatcher();
					RoomLoading.SetupWatcher();
					BlueprintManager.SetupBlueprintWatcher();
				}
			}
			catch (Exception ex)
			{
				Log.Error(ex.StackTrace);
			}
		}

		public void Start()
		{
			BiomeManager.NamesFromFile();
			new DebugCommands();
		}

		public void LateUpdate()
		{
			WaterColor.Transition(Time.deltaTime);
		}

		private void OnDestroy()
		{
			((BaseUnityPlugin)this).Config.Save();
		}
	}
	[HarmonyPatch]
	public class BiomeHeat
	{
		[HarmonyPatch(typeof(Character), "UpdateLava")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> UpdateLava(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0007: 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: Expected O, but got Unknown
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Expected O, but got Unknown
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Expected O, but got Unknown
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Expected O, but got Unknown
			return new CodeMatcher(PatchBiomeHeat(instructions), (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Call, (object)AccessTools.Method(typeof(WorldGenerator), "IsAshlands", (Type[])null, (Type[])null), (string)null)
			}).Advance(2).InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
			{
				new CodeInstruction(OpCodes.Ldarg_0, (object)null)
			})
				.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
				{
					new CodeInstruction(OpCodes.Ldc_R4, (object)0f)
				})
				.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
				{
					new CodeInstruction(OpCodes.Stfld, (object)AccessTools.Field(typeof(Character), "m_lavaHeatLevel"))
				})
				.InstructionEnumeration();
		}

		[HarmonyPatch(typeof(Heightmap), "GetLava")]
		[HarmonyPrefix]
		private static bool GetLava(Heightmap __instance, Vector3 worldPos, ref float __result)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			__result = GetLava(__instance, worldPos);
			return false;
		}

		[HarmonyPatch(typeof(Heightmap), "IsLava")]
		[HarmonyPrefix]
		private static bool IsLava(Heightmap __instance, Vector3 worldPos, float lavaValue, ref bool __result)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			__result = GetLava(__instance, worldPos) > lavaValue;
			return false;
		}

		private static float GetLava(Heightmap hm, Vector3 pos)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: 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_001c: 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_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: 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)
			//IL_0074: 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_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: 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_00c7: Unknown result type (might be due to invalid IL or missing references)
			Biome biome = hm.GetBiome(pos, 0.02f, false);
			if (!HasLava(biome))
			{
				return 0f;
			}
			if (HasFullLava(biome) && !hm.IsBiomeEdge())
			{
				return hm.GetVegetationMask(pos);
			}
			int num = default(int);
			int num2 = default(int);
			hm.WorldToVertexMask(pos, ref num, ref num2);
			int num3 = num2 + num * (hm.m_width + 1);
			Color32[] colors = hm.m_renderMesh.colors32;
			if (num3 < 0 || num3 >= colors.Length)
			{
				return hm.GetVegetationMask(pos);
			}
			Color32 val = colors[num3];
			if (val.r < 237 || val.a < 237)
			{
				return 0f;
			}
			float num4 = ((val.a == byte.MaxValue) ? 1f : (0.5f + (float)((val.a - 237) / 36)));
			return hm.GetVegetationMask(pos) * num4;
		}

		[HarmonyPatch(typeof(Heightmap), "GetHeightOffset")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> GetHeightOffset(IEnumerable<CodeInstruction> instructions)
		{
			return PatchBiomeHeat(instructions);
		}

		[HarmonyPatch(typeof(AudioMan), "ScanForLava")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> ScanForLava(IEnumerable<CodeInstruction> instructions)
		{
			return PatchBiomeHeat(instructions);
		}

		[HarmonyPatch(typeof(AudioMan), "UpdateLavaAmbient")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> UpdateLavaAmbient(IEnumerable<CodeInstruction> instructions)
		{
			return PatchBiomeHeat(instructions);
		}

		[HarmonyPatch(typeof(AudioMan), "UpdateLavaAmbientLoops")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> UpdateLavaAmbientLoops(IEnumerable<CodeInstruction> instructions)
		{
			return PatchBiomeHeat(instructions);
		}

		private static IEnumerable<CodeInstruction> PatchBiomeHeat(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0002: 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_0028: Expected O, but got Unknown
			return new CodeMatcher(instructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Ldc_I4_S, (object)(sbyte)32, (string)null)
			}).SetAndAdvance(OpCodes.Call, Transpilers.EmitDelegate<Func<Biome, bool>>((Func<Biome, bool>)HasLava).operand).SetOpcodeAndAdvance(OpCodes.Brfalse)
				.InstructionEnumeration();
		}

		[HarmonyPatch(typeof(ZoneSystem), "IsLavaPreHeightmap")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> IsLavaPreHeightmap(IEnumerable<CodeInstruction> instructions)
		{
			return PatchBiomeHeat2(instructions);
		}

		private static IEnumerable<CodeInstruction> PatchBiomeHeat2(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0002: 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_0028: Expected O, but got Unknown
			return new CodeMatcher(instructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Ldc_I4_S, (object)(sbyte)32, (string)null)
			}).SetAndAdvance(OpCodes.Call, Transpilers.EmitDelegate<Func<Biome, bool>>((Func<Biome, bool>)HasLava).operand).SetOpcodeAndAdvance(OpCodes.Brtrue)
				.InstructionEnumeration();
		}

		private static bool HasLava(Biome biome)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//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_0008: Invalid comparison between Unknown and I4
			return (biome & BiomeManager.LavaBiomes) > 0;
		}

		private static bool HasFullLava(Biome biome)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//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_0008: Invalid comparison between Unknown and I4
			return (biome & BiomeManager.FullLavaBiomes) > 0;
		}

		[HarmonyPatch(typeof(WorldGenerator), "IsAshlands")]
		[HarmonyPrefix]
		private static bool IsAshlands(float x, float y, ref bool __result)
		{
			WorldGenerator instance = WorldGenerator.instance;
			if (instance == null || instance.m_world.m_menu)
			{
				return true;
			}
			if (!Configuration.DataWorld)
			{
				return true;
			}
			float boiling = BiomeCalculator.GetBoiling(instance, x, y);
			__result = boiling > 0f;
			return false;
		}
	}
	[HarmonyPatch(typeof(Beehive), "CheckBiome")]
	public class BeehiveCheckBiome
	{
		private static void Prefix()
		{
			HeightmapFindBiome.Nature = true;
		}

		private static void Finalizer()
		{
			HeightmapFindBiome.Nature = false;
		}
	}
	[HarmonyPatch(typeof(Player), "UpdatePlacementGhost")]
	public class PlayerUpdatePlacementGhost
	{
		private static void Prefix()
		{
			HeightmapFindBiome.Nature = true;
		}

		private static void Finalizer()
		{
			HeightmapFindBiome.Nature = false;
		}
	}
	[HarmonyPatch(typeof(Plant), "UpdateHealth")]
	public class PlantUpdateHealth
	{
		private static void Prefix()
		{
			GetBiomeHM.Nature = true;
		}

		private static void Finalizer()
		{
			GetBiomeHM.Nature = false;
		}
	}
	[HarmonyPatch(typeof(Heightmap), "GetGroundMaterial")]
	public class HeightmapGetGroundMaterial
	{
		private static void Prefix()
		{
			GetBiomeHM.Nature = true;
		}

		private static void Finalizer()
		{
			GetBiomeHM.Nature = false;
		}
	}
	[HarmonyPatch(typeof(WorldGenerator), "WorldAngle")]
	public class WorldAngle
	{
		private static bool Prefix(float wx, float wy, ref float __result)
		{
			__result = Mathf.Sin(Mathf.Atan2(wx, wy) * Configuration.WiggleFrequency);
			return false;
		}
	}
	[HarmonyPatch(typeof(Minimap), "GetPixelColor")]
	public class GetMapColor
	{
		private static bool Prefix(Biome biome, ref Color __result)
		{
			//IL_0033: 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_0044: Unknown result type (might be due to invalid IL or missing references)
			//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)
			TerritoryData territory = BiomeCalculator.GetTerritory(BiomeHeight.LastX, BiomeHeight.LastY);
			if (territory != null && territory.colorMap.HasValue)
			{
				__result = territory.colorMap.Value;
				return false;
			}
			if (BiomeManager.TryGetData(biome, out BiomeData data))
			{
				__result = data.colorMap;
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(Heightmap), "GetBiome")]
	public class GetBiomeHM
	{
		public static bool Nature;

		private static Biome Postfix(Biome biome)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			if (Nature)
			{
				return BiomeManager.GetNature(biome);
			}
			return biome;
		}
	}
	[HarmonyPatch(typeof(Heightmap), "FindBiome")]
	public class HeightmapFindBiome
	{
		public static bool Nature;

		private static Biome Postfix(Biome biome)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			if (Nature)
			{
				return BiomeManager.GetNature(biome);
			}
			return biome;
		}
	}
	[HarmonyPatch(typeof(WorldGenerator), "Initialize")]
	public class ResetBiomeOffsets
	{
		private static void Prefix()
		{
			BiomeCalculator.Offsets.Clear();
		}
	}
	[HarmonyPatch(typeof(Minimap), "GetMaskColor")]
	public class GetMaskColor
	{
		private static void Prefix(ref Biome biome)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Expected I4, but got Unknown
			biome = (Biome)(int)BiomeManager.GetTerrain(biome);
		}
	}
	[HarmonyPatch(typeof(Minimap), "GenerateWorldMap")]
	public class GenerateWorldMapHeight
	{
		private static float ModifyHeight(float height, Biome biome)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return Api.GetMinimapHeight(height, biome);
		}

		private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0002: 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_0037: Expected O, but got Unknown
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Expected O, but got Unknown
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Expected O, but got Unknown
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: 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
			return new CodeMatcher(instructions, (ILGenerator)null).MatchForward(true, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Call, (object)AccessTools.Method(typeof(Minimap), "GetMaskColor", (Type[])null, (Type[])null), (string)null)
			}).InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
			{
				new CodeInstruction(OpCodes.Ldloc_S, (object)14)
			}).InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
			{
				new CodeInstruction(OpCodes.Ldloc_S, (object)13)
			})
				.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
				{
					new CodeInstruction(OpCodes.Call, Transpilers.EmitDelegate<Func<float, Biome, float>>((Func<float, Biome, float>)ModifyHeight).operand)
				})
				.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
				{
					new CodeInstruction(OpCodes.Stloc_S, (object)14)
				})
				.InstructionEnumeration();
		}
	}
	[HarmonyPatch(typeof(WorldGenerator), "Pregenerate")]
	public class SetBiomeOffsets
	{
		[HarmonyPriority(700)]
		private static void Prefix(WorldGenerator __instance)
		{
			if (BiomeCalculator.Offsets.Count <= 0)
			{
				BiomeCalculator.Offsets[(Biome)2] = __instance.m_offset0;
				BiomeCalculator.Offsets[(Biome)16] = __instance.m_offset1;
				BiomeCalculator.Offsets[(Biome)8] = __instance.m_offset2;
				BiomeCalculator.Offsets[(Biome)1] = __instance.m_offset3;
				BiomeCalculator.Offsets[(Biome)512] = __instance.m_offset4;
				BiomeCalculator.Offsets[(Biome)32] = Random.Range(-10000, 10000);
				BiomeCalculator.Offsets[(Biome)64] = Random.Range(-10000, 10000);
				BiomeCalculator.Offsets[(Biome)4] = Random.Range(-10000, 10000);
				BiomeCalculator.Offsets[(Biome)256] = Random.Range(-10000, 10000);
			}
		}
	}
	[HarmonyPatch(typeof(WorldGenerator), "GetBiome", new Type[]
	{
		typeof(float),
		typeof(float),
		typeof(float),
		typeof(bool)
	})]
	public class GetBiomeWG
	{
		private static bool Prefix(WorldGenerator __instance, float wx, float wy, float oceanLevel, bool waterAlwaysOcean, ref Biome __result)
		{
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Expected I4, but got Unknown
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Expected I4, but got Unknown
			if (__instance.m_world.m_menu)
			{
				return true;
			}
			if (!Configuration.DataWorld)
			{
				return true;
			}
			if (waterAlwaysOcean && __instance.GetHeight(wx, wy) <= oceanLevel)
			{
				__result = (Biome)256;
				return false;
			}
			if (Configuration.LegacyGeneration)
			{
				__result = (Biome)(int)BiomeCalculator.GetLegacy(__instance, wx, wy);
			}
			else
			{
				__result = (Biome)(int)BiomeCalculator.Get(__instance, wx, wy);
			}
			return false;
		}
	}
	[HarmonyPatch(typeof(WorldGenerator), "GetAshlandsOceanGradient", new Type[]
	{
		typeof(float),
		typeof(float)
	})]
	public class GetAshlandsOceanGradient
	{
		private static bool Prefix(float x, float y, ref float __result)
		{
			WorldGenerator instance = WorldGenerator.instance;
			if (instance.m_world.m_menu)
			{
				return true;
			}
			if (!Configuration.DataWorld)
			{
				return true;
			}
			__result = BiomeCalculator.GetBoiling(instance, x, y);
			return false;
		}
	}
	public class BiomeCalculator
	{
		public static List<WorldEntry>? BiomeData = null;

		public static List<WorldEntry>? TerritoryData = null;

		public static bool CheckAngles = false;

		public static Dictionary<Biome, float> Offsets = new Dictionary<Biome, float>();

		public static List<WorldEntry> GetBiomeData()
		{
			return BiomeData ?? WorldManager.DefaultEntries;
		}

		public static void SetData(List<WorldEntry> data)
		{
			List<WorldEntry> list = new List<WorldEntry>();
			list.AddRange(data.Where((WorldEntry item) => (int)item.biome > 0));
			BiomeData = list;
			List<WorldEntry> list2 = new List<WorldEntry>();
			list2.AddRange(data.Where((WorldEntry item) => item.territory != ""));
			TerritoryData = list2;
		}

		private static float GetOffset(WorldGenerator obj, Biome biome)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			if (Offsets.TryGetValue(biome, out var value))
			{
				return value;
			}
			return obj.m_offset0;
		}

		public static Biome Get(WorldGenerator obj, float wx, float wy)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			float worldAngle = Mathf.Atan2(wx, wy);
			return (Biome)(((??)GetEntry(obj, GetBiomeData(), wx, wy, worldAngle)?.biome) ?? 256);
		}

		public static WorldEntry? GetTerritoryEntry(WorldGenerator wg, float wx, float wy)
		{
			if (TerritoryData == null || TerritoryData.Count == 0)
			{
				return null;
			}
			float worldAngle = Mathf.Atan2(wx, wy);
			return GetEntry(wg, TerritoryData, wx, wy, worldAngle);
		}

		public static TerritoryData? GetTerritory(float wx, float wy)
		{
			WorldGenerator instance = WorldGenerator.instance;
			if (instance == null || instance.m_world.m_menu)
			{
				return null;
			}
			WorldEntry territoryEntry = GetTerritoryEntry(instance, wx, wy);
			if (territoryEntry == null)
			{
				return null;
			}
			if (!TerritoryManager.TryGetData(territoryEntry.territory, out TerritoryData data))
			{
				return null;
			}
			return data;
		}

		public static Biome GetLegacy(WorldGenerator obj, float wx, float wy)
		{
			//IL_0020: 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_0145: 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_0234: Unknown result type (might be due to invalid IL or missing references)
			//IL_0294: Unknown result type (might be due to invalid IL or missing references)
			//IL_0299: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bf: Unknown result type (might be due to invalid IL or missing references)
			float num = Mathf.Atan2(wx, wy);
			List<WorldEntry> biomeData = GetBiomeData();
			float num2 = wx * WorldInfo.Stretch;
			float num3 = wy * WorldInfo.Stretch;
			Vector2 val = new Vector2(num2, num3);
			float magnitude = ((Vector2)(ref val)).magnitude;
			if (!(magnitude > WorldInfo.TotalRadius))
			{
				float num4 = Helper.BaseHeightToAltitude(obj.GetBaseHeight(wx, wy, false));
				float num5 = 0f;
				if (CheckAngles)
				{
					num5 = (num + (float)Math.PI) / 2f / (float)Math.PI;
				}
				float radius = WorldInfo.Radius;
				float num6 = wx / WorldInfo.BiomeStretch;
				float num7 = wy / WorldInfo.BiomeStretch;
				foreach (WorldEntry item in biomeData)
				{
					if (item.minAltitude > num4 || item.maxAltitude < num4)
					{
						continue;
					}
					float num8 = magnitude;
					float num9 = item.minDistance;
					if (num9 > 0f && item.wiggleDistanceWidth > 0f)
					{
						num9 += Mathf.Sin(num * item.wiggleDistanceLength) * item.wiggleDistanceWidth;
					}
					else if (num9 == 0f)
					{
						num9 = -0.1f;
					}
					float maxDistance = item.maxDistance;
					if (item.centerX != 0f || item.centerY != 0f)
					{
						val = new Vector2(num2 - item.centerX, num3 - item.centerY);
						num8 = ((Vector2)(ref val)).magnitude;
					}
					if (!(num8 > num9) || (!(maxDistance >= radius) && !(num8 <= maxDistance)))
					{
						continue;
					}
					if (CheckAngles)
					{
						num9 = item.minSector;
						maxDistance = item.maxSector;
						if (num9 != 0f || maxDistance != 1f)
						{
							float num10 = num5;
							if (item.wiggleSectorWidth > 0f)
							{
								num10 += Mathf.Sin(magnitude / item.wiggleSectorLength) * item.wiggleSectorWidth;
							}
							if (num10 < 0f)
							{
								num10 += 1f;
							}
							if (num10 >= 1f)
							{
								num10 -= 1f;
							}
							bool num11;
							if (!(num9 > maxDistance))
							{
								if (!(num10 >= num9))
								{
									continue;
								}
								num11 = num10 < maxDistance;
							}
							else
							{
								if (num10 >= num9)
								{
									goto IL_021f;
								}
								num11 = num10 < maxDistance;
							}
							if (!num11)
							{
								continue;
							}
						}
					}
					goto IL_021f;
					IL_021f:
					float num12 = ((float?)item.seed) ?? GetOffset(obj, item.biomeSeed);
					if (!(item.amount < 1f) || !(Mathf.PerlinNoise((num12 + num6 / item.stretch) * 0.001f, (num12 + num7 / item.stretch) * 0.001f) < 1f - item.amount))
					{
						return item.biome;
					}
				}
				return (Biome)256;
			}
			return (Biome)256;
		}

		public static float GetBoiling(WorldGenerator obj, float wx, float wy)
		{
			float num = Mathf.Atan2(wx, wy);
			WorldEntry entry = GetEntry(obj, GetBiomeData(), wx, wy, num);
			if (entry == null || entry.boiling <= 0f)
			{
				return -1f;
			}
			float num2 = wx * WorldInfo.Stretch;
			float num3 = wy * WorldInfo.Stretch;
			float num4 = DUtils.Length(num2 - entry.centerX, num3 - entry.centerY);
			float num5 = entry.minDistance;
			if (num5 > 0f && entry.wiggleDistanceWidth > 0f)
			{
				num5 += Mathf.Sin(num * entry.wiggleDistanceLength) * entry.wiggleDistanceWidth;
			}
			else if (num5 == 0f)
			{
				num5 = -0.1f;
			}
			return entry.boiling * (num4 - num5) / 300f;
		}

		private static WorldEntry? GetEntry(WorldGenerator obj, List<WorldEntry> data, float wx, float wy, float worldAngle)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0211: Unknown result type (might be due to invalid IL or missing references)
			float num = wx * WorldInfo.Stretch;
			float num2 = wy * WorldInfo.Stretch;
			Vector2 val = new Vector2(num, num2);
			float magnitude = ((Vector2)(ref val)).magnitude;
			if (magnitude > WorldInfo.TotalRadius)
			{
				return null;
			}
			float num3 = Helper.BaseHeightToAltitude(obj.GetBaseHeight(wx, wy, false));
			float num4 = 0f;
			if (CheckAngles)
			{
				num4 = (worldAngle + (float)Math.PI) / 2f / (float)Math.PI;
			}
			float radius = WorldInfo.Radius;
			float num5 = wx / WorldInfo.BiomeStretch;
			float num6 = wy / WorldInfo.BiomeStretch;
			foreach (WorldEntry datum in data)
			{
				if (datum.minAltitude >= num3 || datum.maxAltitude <= num3)
				{
					continue;
				}
				float num7 = magnitude;
				float num8 = datum.minDistance;
				if (num8 > 0f && datum.wiggleDistanceWidth > 0f)
				{
					num8 += Mathf.Sin(worldAngle * datum.wiggleDistanceLength) * datum.wiggleDistanceWidth;
				}
				else if (num8 == 0f)
				{
					num8 = -0.1f;
				}
				float maxDistance = datum.maxDistance;
				if (datum.centerX != 0f || datum.centerY != 0f)
				{
					num7 = DUtils.Length(num - datum.centerX, num2 - datum.centerY);
				}
				if (!(num7 > num8) || (!(maxDistance >= radius) && !(num7 < maxDistance)))
				{
					continue;
				}
				if (CheckAngles)
				{
					num8 = datum.minSector;
					maxDistance = datum.maxSector;
					if (num8 != 0f || maxDistance != 1f)
					{
						float num9 = num4;
						if (datum.wiggleSectorWidth > 0f)
						{
							num9 += Mathf.Sin(magnitude / datum.wiggleSectorLength) * datum.wiggleSectorWidth;
						}
						if (num9 < 0f)
						{
							num9 += 1f;
						}
						if (num9 >= 1f)
						{
							num9 -= 1f;
						}
						bool num10;
						if (!(num8 > maxDistance))
						{
							if (!(num9 >= num8))
							{
								continue;
							}
							num10 = num9 < maxDistance;
						}
						else
						{
							if (num9 >= num8)
							{
								goto IL_01fc;
							}
							num10 = num9 < maxDistance;
						}
						if (!num10)
						{
							continue;
						}
					}
				}
				goto IL_01fc;
				IL_01fc:
				float num11 = ((float?)datum.seed) ?? GetOffset(obj, datum.biomeSeed);
				if (!(datum.amount < 1f) || !(Mathf.PerlinNoise((num11 + num5 / datum.stretch) * 0.001f, (num11 + num6 / datum.stretch) * 0.001f) <= 1f - datum.amount))
				{
					return datum;
				}
			}
			return null;
		}
	}
	[HarmonyPatch(typeof(WorldGenerator), "GetBiomeHeight")]
	public class BiomeHeight
	{
		[ThreadStatic]
		public static float LastX;

		[ThreadStatic]
		public static float LastY;

		private static float ApplyHeight(float height, BiomeData data)
		{
			height *= data.altitudeMultiplier;
			height += data.altitudeDelta;
			if (height < 0f)
			{
				height *= data.waterDepthMultiplier;
			}
			if (height > data.maximumAltitude)
			{
				height = data.maximumAltitude + data.excessSign * Mathf.Pow(height - data.maximumAltitude, data.excessFactor);
			}
			if (height < data.minimumAltitude)
			{
				height = data.minimumAltitude - data.excessSign * Mathf.Pow(data.minimumAltitude - height, data.excessFactor);
			}
			return height;
		}

		private static float ApplyHeight(float height, TerritoryData data)
		{
			height *= data.altitudeMultiplier;
			height += data.altitudeDelta;
			if (height < 0f)
			{
				height *= data.waterDepthMultiplier;
			}
			if (height > data.maximumAltitude)
			{
				height = data.maximumAltitude + data.excessSign * Mathf.Pow(height - data.maximumAltitude, data.excessFactor);
			}
			if (height < data.minimumAltitude)
			{
				height = data.minimumAltitude - data.excessSign * Mathf.Pow(data.minimumAltitude - height, data.excessFactor);
			}
			return height;
		}

		private static void Prefix(WorldGenerator __instance, ref Biome biome, ref Biome __state)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected I4, but got Unknown
			if (!__instance.m_world.m_menu)
			{
				__state = biome;
				biome = (Biome)(int)BiomeManager.GetTerrain(biome);
			}
		}

		private static void Postfix(WorldGenerator __instance, Biome __state, Biome biome, float wx, float wy, ref Color mask, ref float __result)
		{
			//IL_001b: 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_0032: Invalid comparison between Unknown and I4
			//IL_0027: 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)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Invalid comparison between Unknown and I4
			//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_005f: 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_0050: 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_0103: 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)
			LastX = wx;
			LastY = wy;
			if (__instance.m_world.m_menu)
			{
				return;
			}
			if (BiomeManager.TryGetColor(__state, out var color))
			{
				mask = color;
			}
			else if ((int)__state == 32 && __state != biome)
			{
				__instance.GetAshlandsHeight(wx, wy, ref mask, false);
			}
			else if ((int)__state == 512 && __state != biome)
			{
				__instance.GetMistlandsHeight(wx, wy, ref mask);
			}
			if (BiomeManager.TryGetData(__state, out BiomeData data) && data.lavaAmount != 1f)
			{
				float lavaSeed = data.GetLavaSeed();
				float num = Mathf.PerlinNoise(lavaSeed + wx * data.lavaStretch, lavaSeed + wy * data.lavaStretch);
				if (num > data.lavaAmount)
				{
					mask.a = 0f;
				}
				else
				{
					mask.a = num / data.lavaAmount;
				}
				__result -= mask.a;
			}
			WorldEntry territoryEntry = BiomeCalculator.GetTerritoryEntry(__instance, wx, wy);
			if (territoryEntry != null && TerritoryManager.TryGetData(territoryEntry.territory, out TerritoryData data2) && data2.colorTerrain.HasValue)
			{
				mask = data2.colorTerrain.Value;
			}
			__result -= WorldInfo.WaterLevel;
			if (BiomeManager.TryGetData(__state, out data))
			{
				__result = ApplyHeight(__result, data);
			}
			if (territoryEntry != null && TerritoryManager.TryGetData(territoryEntry.territory, out TerritoryData data3))
			{
				__result = ApplyHeight(__result, data3);
			}
			__result += WorldInfo.WaterLevel;
		}
	}
	public class GetAshlandsHeight
	{
		private static readonly double DefaultWidthRestriction = 7500.0;

		private static double WidthRestriction = DefaultWidthRestriction;

		private static readonly double DefaultLengthRestriction = 1000.0;

		private static double LengthRestriction = DefaultLengthRestriction;

		public static void Patch(Harmony harmony, double widthRestriction, double lengthRestriction)
		{
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Expected O, but got Unknown
			if (WidthRestriction != widthRestriction || LengthRestriction != lengthRestriction)
			{
				MethodInfo methodInfo = AccessTools.Method(typeof(WorldGenerator), "GetAshlandsHeight", (Type[])null, (Type[])null);
				MethodInfo methodInfo2 = AccessTools.Method(typeof(GetAshlandsHeight), "Transpiler", (Type[])null, (Type[])null);
				WidthRestriction = widthRestriction;
				LengthRestriction = lengthRestriction;
				harmony.Unpatch((MethodBase)methodInfo, methodInfo2);
				if (WidthRestriction != DefaultWidthRestriction || LengthRestriction != DefaultLengthRestriction)
				{
					harmony.Patch((MethodBase)methodInfo, (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(methodInfo2), (HarmonyMethod)null, (HarmonyMethod)null);
				}
			}
		}

		private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0002: 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_002f: Expected O, but got Unknown
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Expected O, but got Unknown
			return new CodeMatcher(instructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Ldc_R8, (object)1000.0, (string)null)
			}).SetOperandAndAdvance((object)LengthRestriction).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Ldc_R8, (object)7500.0, (string)null)
			})
				.SetOperandAndAdvance((object)WidthRestriction)
				.InstructionEnumeration();
		}
	}
	public class CreateAshlandsGap
	{
		private static bool IsPatched;

		public static void Patch(Harmony harmony, bool doPatch)
		{
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Expected O, but got Unknown
			if (IsPatched != doPatch)
			{
				MethodInfo methodInfo = AccessTools.Method(typeof(WorldGenerator), "CreateAshlandsGap", (Type[])null, (Type[])null);
				MethodInfo methodInfo2 = AccessTools.Method(typeof(CreateAshlandsGap), "DisableGap", (Type[])null, (Type[])null);
				IsPatched = doPatch;
				if (doPatch)
				{
					harmony.Patch((MethodBase)methodInfo, new HarmonyMethod(methodInfo2), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				}
				else
				{
					harmony.Unpatch((MethodBase)methodInfo, methodInfo2);
				}
			}
		}

		private static bool DisableGap(ref double __result)
		{
			__result = 1.0;
			return false;
		}
	}
	public class CreateDeepNorthGap
	{
		private static bool IsPatched;

		public static void Patch(Harmony harmony, bool doPatch)
		{
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Expected O, but got Unknown
			if (IsPatched != doPatch)
			{
				MethodInfo methodInfo = AccessTools.Method(typeof(WorldGenerator), "CreateDeepNorthGap", (Type[])null, (Type[])null);
				MethodInfo methodInfo2 = AccessTools.Method(typeof(CreateAshlandsGap), "DisableGap", (Type[])null, (Type[])null);
				IsPatched = doPatch;
				if (doPatch)
				{
					harmony.Patch((MethodBase)methodInfo, new HarmonyMethod(methodInfo2), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				}
				else
				{
					harmony.Unpatch((MethodBase)methodInfo, methodInfo2);
				}
			}
		}

		private static bool DisableGap(ref double __result)
		{
			__result = 1.0;
			return false;
		}
	}
	[HarmonyPatch(typeof(Heightmap))]
	public class HeightmapPatches
	{
		private static readonly Dictionary<Heightmap, Color32[]> cornerColors = new Dictionary<Heightmap, Color32[]>();

		private static Color32[] InitCornerColors(Heightmap __instance)
		{
			//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_0018: 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_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: 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_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: 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_00af: 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_00be: 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_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: 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_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: 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_016a: 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_0161: Unknown result type (might be due to invalid IL or missing references)
			//IL_016f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0171: Unknown result type (might be due to invalid IL or missing references)
			//IL_0172: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bc: 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_01c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c9: 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_01d5: 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_01db: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e2: 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_01e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_017a: Unknown result type (might be due to invalid IL or missing references)
			//IL_017b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0183: 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_019b: Unknown result type (might be due to invalid IL or missing references)
			//IL_019c: 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)
			Vector3 position = ((Component)__instance).transform.position;
			Color val = (Color)(((??)BiomeCalculator.GetTerritory(position.x - 32f, position.z - 32f)?.colorMap) ?? Color32.op_Implicit(Heightmap.GetBiomeColor(__instance.m_cornerBiomes[0])));
			Color val2 = (Color)(((??)BiomeCalculator.GetTerritory(position.x + 32f, position.z - 32f)?.colorMap) ?? Color32.op_Implicit(Heightmap.GetBiomeColor(__instance.m_cornerBiomes[1])));
			Color val3 = (Color)(((??)BiomeCalculator.GetTerritory(position.x - 32f, position.z + 32f)?.colorMap) ?? Color32.op_Implicit(Heightmap.GetBiomeColor(__instance.m_cornerBiomes[2])));
			Color val4 = (Color)(((??)BiomeCalculator.GetTerritory(position.x + 32f, position.z + 32f)?.colorMap) ?? Color32.op_Implicit(Heightmap.GetBiomeColor(__instance.m_cornerBiomes[3])));
			if (val == val2 && val == val3 && val == val4)
			{
				cornerColors[__instance] = (Color32[])(object)new Color32[1] { Color32.op_Implicit(val) };
			}
			else
			{
				cornerColors[__instance] = (Color32[])(object)new Color32[4]
				{
					Color32.op_Implicit(val),
					Color32.op_Implicit(val2),
					Color32.op_Implicit(val3),
					Color32.op_Implicit(val4)
				};
			}
			return cornerColors[__instance];
		}

		[HarmonyPatch(typeof(Heightmap), "OnDestroy")]
		[HarmonyPostfix]
		private static void RemoveCornerTerritories(Heightmap __instance)
		{
			cornerColors.Remove(__instance);
		}

		private static Vector3 CalcWorld(Heightmap __instance, float ix, float iy)
		{
			//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_003b: Unknown result type (might be due to invalid IL or missing references)
			Vector3 position = ((Component)__instance).transform.position;
			float num = position.x + (ix - 0.5f) * 64f;
			float num2 = position.z + (iy - 0.5f) * 64f;
			return new Vector3(num, 0f, num2);
		}

		[HarmonyPatch(typeof(Heightmap), "GetBiomeColor", new Type[]
		{
			typeof(float),
			typeof(float)
		})]
		[HarmonyPrefix]
		private static bool CustomGetBiomeColor(Heightmap __instance, float ix, float iy, ref Color __result)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: 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_0039: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = CalcWorld(__instance, ix, iy);
			TerritoryData territory = BiomeCalculator.GetTerritory(val.x, val.z);
			if (territory == null || !territory.colorTerrain.HasValue)
			{
				return true;
			}
			__result = territory.colorTerrain.Value;
			return false;
		}

		private static Color GetBiomeColorFunc(Heightmap hm, float ix, float iy)
		{
			//IL_002b: 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_0038: 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_0046: 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_0051: 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_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			if (!cornerColors.TryGetValue(hm, out Color32[] value))
			{
				value = InitCornerColors(hm);
			}
			if (value.Length == 1)
			{
				return Color32.op_Implicit(value[0]);
			}
			Color32 val = Color32.Lerp(value[0], value[1], ix);
			Color32 val2 = Color32.Lerp(value[2], value[3], ix);
			return Color32.op_Implicit(Color32.Lerp(val, val2, iy));
		}

		[HarmonyPatch(typeof(Heightmap), "GetBiomeColor", new Type[] { typeof(Biome) })]
		[HarmonyPrefix]
		private static bool GetBiomeColor(Biome biome, ref Color32 __result)
		{
			//IL_0000: 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_0018: Unknown result type (might be due to invalid IL or missing references)
			if (!BiomeManager.TryGetData(biome, out BiomeData data))
			{
				return true;
			}
			__result = Color32.op_Implicit(data.colorTerrain);
			return false;
		}
	}
	[HarmonyPatch(typeof(LoadingIndicator), "SetShowProgress")]
	public class GuaranteeLocations
	{
		private static void GuaranteeStartLocation(ZoneSystem zs)
		{
			//IL_0078: 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_0083: 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)
			ZoneLocation val = ((IEnumerable<ZoneLocation>)zs.m_locations).FirstOrDefault((Func<ZoneLocation, bool>)((ZoneLocation loc) => loc.m_prefab.Name == Game.instance.m_StartLocation));
			if (val.m_enable && val.m_quantity != 0 && Count(zs, val) == 0)
			{
				Log.Info("Forcefully placing " + val.m_prefab.Name + " location at the center.");
				float num = Mathf.Max(val.m_exteriorRadius, val.m_interiorRadius);
				Vector3 randomPointInZone = ZoneSystem.GetRandomPointInZone(new Vector2i(0, 0), num);
				zs.RegisterLocation(val, randomPointInZone, false);
			}
		}

		private static int Count(ZoneSystem zs, ZoneLocation location)
		{
			return zs.m_locationInstances.Values.Count((LocationInstance loc) => loc.m_location.m_prefab.Name == location.m_prefab.Name);
		}

		private static void Finalizer(bool show)
		{
			if (!show)
			{
				GuaranteeStartLocation(ZoneSystem.instance);
				CreateLocalZones.LocationsPregenerated = false;
			}
		}
	}
	[HarmonyPatch(typeof(ZoneSystem), "PlaceZoneCtrl")]
	public class PlaceZoneCtrl
	{
		private static bool Prefix()
		{
			return Configuration.ZoneSpawners;
		}
	}
	[HarmonyPatch(typeof(ZoneSystem), "PlaceVegetation")]
	public class ClearAreasFromAdjacentZones
	{
		private static void Prefix(ZoneSystem __instance, Vector2i zoneID, List<ClearArea> clearAreas)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: 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_0089: 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_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: 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_0056: 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_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)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Expected O, but got Unknown
			for (int i = zoneID.x - 1; i <= zoneID.x + 1; i++)
			{
				for (int j = zoneID.y - 1; j <= zoneID.y + 1; j++)
				{
					if ((i != zoneID.x || j != zoneID.y) && __instance.m_locationInstances.TryGetValue(new Vector2i(i, j), out var value) && value.m_location != null && value.m_location.m_clearArea && !(value.m_location.m_exteriorRadius < 32f))
					{
						clearAreas.Add(new ClearArea(value.m_position, value.m_location.m_exteriorRadius));
					}
				}
			}
		}
	}
	[HarmonyPatch(typeof(ZoneSystem), "GetRandomPointInZone", new Type[]
	{
		typeof(Vector2i),
		typeof(float)
	})]
	public class FixGetRandomPointInZone
	{
		private static Vector3 Postfix(Vector3 result, Vector2i zone, float locationRadius)
		{
			//IL_000a: 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_0008: Unknown result type (might be due to invalid IL or missing references)
			if (locationRadius < 32f)
			{
				return result;
			}
			return ZoneSystem.GetZonePos(zone);
		}
	}
	[HarmonyPatch(typeof(Player), "AddKnownBiome")]
	public class StartColorTransition
	{
		public static void Postfix(Biome biome)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			if (Configuration.CustomWaterColor)
			{
				WaterColor.StartTransition(biome);
			}
		}
	}
	[HarmonyPatch(typeof(Player), "OnSpawned")]
	public class ResetColorTransition
	{
		public static void Postfix()
		{
			WaterColor.StopTransition();
		}
	}
	public class WaterColor
	{
		private static float TransitionProgress;

		private static bool Transitioning;

		public static Color CurrentSurfaceColor;

		public static Color CurrentTopColor;

		public static Color CurrentBottomColor;

		public static Color CurrentShallowColor;

		public static Color TargetSurfaceColor;

		public static Color TargetTopColor;

		public static Color TargetBottomColor;

		public static Color TargetShallowColor;

		private static bool InitDone;

		private static Color WaterSurface;

		private static Color AshlandsSurface;

		private static Color WaterTop;

		private static Color AshlandsTop;

		private static Color WaterBottom;

		private static Color AshlandsBottom;

		private static Color WaterShallow;

		private static Color AshlandsShallow;

		public static void Transition(float time)
		{
			if (Transitioning)
			{
				TransitionProgress += 0.1f * time;
				if (TransitionProgress >= 1f)
				{
					StopTransition();
				}
				UpdateTransitions();
			}
		}

		public static void StartTransition(Biome targetBiome)
		{
			//IL_0011: 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_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_001d: 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_0023: 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)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Invalid comparison between Unknown and I4
			//IL_0036: 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_003b: 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_0043: Invalid comparison between Unknown and I4
			//IL_004c: 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_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Invalid comparison between Unknown and I4
			//IL_0062: 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_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_006f: Invalid comparison between Unknown and I4
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: 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_0082: 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_01c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: 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_00a1: 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_01d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d4: Unknown result type (might be due to invalid IL or missing references)
			//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_0203: Unknown result type (might be due to invalid IL or missing references)
			//IL_0208: Unknown result type (might be due to invalid IL or missing references)
			//IL_020e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0213: Unknown result type (might be due to invalid IL or missing references)
			//IL_0218: 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_0223: Unknown result type (might be due to invalid IL or missing references)
			//IL_0228: Unknown result type (might be due to invalid IL or missing references)
			//IL_022d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0232: 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_0242: 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_024e: 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_01e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e1: 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)
			//IL_0164: Unknown result type (might be due to invalid IL or missing references)
			//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_01ed: 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_017e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0183: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: 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_01a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bc: 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)
			bool flag = !InitDone;
			if (flag)
			{
				UpdateTransitions();
			}
			Color targetTopColor = TargetTopColor;
			Color targetBottomColor = TargetBottomColor;
			Color targetShallowColor = TargetShallowColor;
			Color targetSurfaceColor = TargetSurfaceColor;
			TargetTopColor = (((int)targetBiome == 32) ? AshlandsTop : WaterTop);
			TargetBottomColor = (((int)targetBiome == 32) ? AshlandsBottom : WaterBottom);
			TargetShallowColor = (((int)targetBiome == 32) ? AshlandsShallow : WaterShallow);
			TargetSurfaceColor = (((int)targetBiome == 32) ? AshlandsSurface : WaterSurface);
			if (BiomeManager.TryGetData(targetBiome, out BiomeData data))
			{
				if (data.colorWaterTop.HasValue)
				{
					TargetTopColor = data.colorWaterTop.Value;
				}
				if (data.colorWaterBottom.HasValue)
				{
					TargetBottomColor = data.colorWaterBottom.Value;
				}
				if (data.colorWaterShallow.HasValue)
				{
					TargetShallowColor = data.colorWaterShallow.Value;
				}
				if (data.colorWaterSurface.HasValue)
				{
					TargetSurfaceColor = data.colorWaterSurface.Value;
				}
			}
			if (Object.op_Implicit((Object)(object)Player.m_localPlayer))
			{
				TerritoryData territory = BiomeCalculator.GetTerritory(((Component)Player.m_localPlayer).transform.position.x, ((Component)Player.m_localPlayer).transform.position.z);
				if (territory != null)
				{
					if (territory.colorWaterTop.HasValue)
					{
						TargetTopColor = territory.colorWaterTop.Value;
					}
					if (territory.colorWaterBottom.HasValue)
					{
						TargetBottomColor = territory.colorWaterBottom.Value;
					}
					if (territory.colorWaterShallow.HasValue)
					{
						TargetShallowColor = territory.colorWaterShallow.Value;
					}
					if (territory.colorWaterSurface.HasValue)
					{
						TargetSurfaceColor = territory.colorWaterSurface.Value;
					}
				}
			}
			if (!(targetBottomColor == TargetBottomColor) || !(targetTopColor == TargetTopColor) || !(targetShallowColor == TargetShallowColor) || !(targetSurfaceColor == TargetSurfaceColor))
			{
				if (Transitioning)
				{
					CurrentTopColor = Color.Lerp(CurrentTopColor, targetTopColor, TransitionProgress);
					CurrentBottomColor = Color.Lerp(CurrentBottomColor, targetBottomColor, TransitionProgress);
					CurrentShallowColor = Color.Lerp(CurrentShallowColor, targetShallowColor, TransitionProgress);
					CurrentSurfaceColor = Color.Lerp(CurrentSurfaceColor, targetSurfaceColor, TransitionProgress);
				}
				TransitionProgress = (flag ? 1f : 0f);
				Transitioning = true;
			}
		}

		public static void StopTransition()
		{
			//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_0022: Unknown result type (might be due to invalid IL or missing references)
			//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_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			if (Transitioning)
			{
				Transitioning = false;
				TransitionProgress = 1f;
				CurrentTopColor = TargetTopColor;
				CurrentBottomColor = TargetBottomColor;
				CurrentShallowColor = TargetShallowColor;
				CurrentSurfaceColor = TargetSurfaceColor;
			}
		}

		private static void UpdateTransitions()
		{
			foreach (WaterVolume instance2 in WaterVolume.Instances)
			{
				UpdateTransition(((Renderer)instance2.m_waterSurface).sharedMaterial);
			}
			EnvMan instance = EnvMan.instance;
			Transform val = ((instance != null) ? ((Component)instance).transform.Find("WaterPlane").Find("watersurface") : null);
			if ((Object)(object)val != (Object)null)
			{
				UpdateTransition(((Renderer)((Component)val).GetComponent<MeshRenderer>()).sharedMaterial);
			}
		}

		private static void UpdateTransition(Material mat)
		{
			//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_0015: 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_0020: 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_002f: 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_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: 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_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: 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)
			InitColors(mat);
			Color surface = Color.Lerp(CurrentSurfaceColor, TargetSurfaceColor, TransitionProgress);
			Color top = Color.Lerp(CurrentTopColor, TargetTopColor, TransitionProgress);
			Color bottom = Color.Lerp(CurrentBottomColor, TargetBottomColor, TransitionProgress);
			Color shallow = Color.Lerp(CurrentShallowColor, TargetShallowColor, TransitionProgress);
			UpdateColors(mat, surface, top, bottom, shallow);
		}

		public static void FixColors(Material mat)
		{
			InitColors(mat);
			UpdateTransition(mat);
		}

		public static void Regenerate()
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)Player.m_localPlayer))
			{
				StartTransition(Player.m_localPlayer.GetCurrentBiome());
			}
			StopTransition();
			UpdateTransitions();
		}

		private static void UpdateColors(Material mat, Color surface, Color top, Color bottom, Color shallow)
		{
			//IL_0006: 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_001e: 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_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			mat.SetColor("_SurfaceColor", surface);
			mat.SetColor("_AshlandsSurfaceColor", surface);
			mat.SetColor("_ColorTop", top);
			mat.SetColor("_AshlandsColorTop", top);
			mat.SetColor("_ColorBottom", bottom);
			mat.SetColor("_AshlandsColorBottom", bottom);
			mat.SetColor("_ColorBottomShallow", shallow);
			mat.SetColor("_AshlandsColorBottomShallow", shallow);
		}

		private static void InitColors(Material mat)
		{
			//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_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_0034: 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_0044: 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_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0074: 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_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)
			if (!InitDone)
			{
				InitDone = true;
				WaterSurface = mat.GetColor("_SurfaceColor");
				AshlandsSurface = mat.GetColor("_AshlandsSurfaceColor");
				WaterTop = mat.GetColor("_ColorTop");
				AshlandsTop = mat.GetColor("_AshlandsColorTop");
				WaterBottom = mat.GetColor("_ColorBottom");
				AshlandsBottom = mat.GetColor("_AshlandsColorBottom");
				WaterShallow = mat.GetColor("_ColorBottomShallow");
				AshlandsShallow = mat.GetColor("_AshlandsColorBottomShallow");
			}
		}
	}
	public static class Helper
	{
		public static GameObject? SafeLoad(RoomData room)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				room.m_prefab.Load();
				return room.m_prefab.Asset;
			}
			catch
			{
				Log.Warning("Failed to load room " + room.m_prefab.Name + ". This is most likely issue with the mod adding the room.");
				room.m_prefab.Release();
				return null;
			}
		}

		public static GameObject? SafeLoad(ZoneLocation loc)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				loc.m_prefab.Load();
				return loc.m_prefab.Asset;
			}
			catch
			{
				Log.Warning("Failed to load location " + loc.m_prefab.Name + ". This is most likely issue with the mod adding the location.");
				loc.m_prefab.Release();
				return null;
			}
		}

		public static List<BlueprintObject> ParseObjects(string[] args, string fileName)
		{
			return (from s in args
				select Parse.Split(s) into split
				select new BlueprintObject(split[0], Parse.VectorXZY(split, 1), Parse.AngleYXZ(split, 4), Parse.VectorXZY(split, 7, Vector3.one), DataHelper.Get((split.Length > 11) ? split[11] : "", fileName), Parse.Float(split, 10, 1f), split.Length > 3 && split[3].ToLowerInvariant() == "snap")).ToList();
		}

		public static float HeightToBaseHeight(float altitude)
		{
			return altitude / 200f;
		}

		public static float AltitudeToHeight(float altitude)
		{
			return WorldInfo.WaterLevel + altitude;
		}

		public static float AltitudeToBaseHeight(float altitude)
		{
			return HeightToBaseHeight(AltitudeToHeight(altitude));
		}

		public static float BaseHeightToAltitude(float baseHeight)
		{
			return baseHeight * 200f - WorldInfo.WaterLevel;
		}

		public static bool IsServer()
		{
			if (Object.op_Implicit((Object)(object)ZNet.instance))
			{
				return ZNet.instance.IsServer();
			}
			return false;
		}

		public static bool IsClient()
		{
			return !IsServer();
		}

		public static Vector3 RandomValue(Range<Vector3> range)
		{
			//IL_00e1: 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)
			if (range.Uniform)
			{
				float num = Random.Range(0f, 1f);
				return new Vector3(range.Min.x + (range.Max.x - range.Min.x) * num, range.Min.y + (range.Max.y - range.Min.y) * num, range.Min.z + (range.Max.z - range.Min.z) * num);
			}
			return new Vector3(Random.Range(range.Min.x, range.Max.x), Random.Range(range.Min.y, range.Max.y), Random.Range(range.Min.z, range.Max.z));
		}

		public static bool IsMultiAxis(Range<Vector3> range)
		{
			//IL_0001: 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_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_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			if (range.Min == range.Max)
			{
				return false;
			}
			if (!range.Uniform)
			{
				return true;
			}
			if (!(((Vector3)(ref range.Min)).normalized != Vector3.one))
			{
				return ((Vector3)(ref range.Max)).normalized != Vector3.one;
			}
			return true;
		}

		public static string Print(float value)
		{
			return value.ToString("0.#####", NumberFormatInfo.InvariantInfo);
		}

		public static string Print(Vector3 vec)
		{
			//IL_0008: 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_0034: Unknown result type (might be due to invalid IL or missing references)
			return Print(vec.x) + "," + Print(vec.z) + "," + Print(vec.y);
		}

		public static string Print(Quaternion quat)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: 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_0062: 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_0022: Unknown result type (might be due to invalid IL or missing references)
			Vector3 eulerAngles = ((Quaternion)(ref quat)).eulerAngles;
			if (eulerAngles.x == 0f && eulerAngles.z == 0f)
			{
				return Print(eulerAngles.y);
			}
			return Print(eulerAngles.y) + "," + Print(eulerAngles.x) + "," + Print(eulerAngles.z);
		}

		public static Dictionary<K, V> ToDict<T, K, V>(IEnumerable<T> items, Func<T, K> key, Func<T, V> value)
		{
			return items.ToLookup(key, value).ToDictionary((IGrouping<K, V> kvp) => kvp.Key, (IGrouping<K, V> kvp) => kvp.First());
		}

		public static HashSet<K> ToSet<T, K>(IEnumerable<T> items, Func<T, K> key)
		{
			return items.Select(key).Distinct().ToHashSet();
		}

		public static bool HasAnyGlobalKey(List<string> keys)
		{
			return keys.Any(ZoneSystem.instance.m_globalKeys.Contains);
		}

		public static bool HasEveryGlobalKey(List<string> keys)
		{
			return keys.All(ZoneSystem.instance.m_globalKeys.Contains);
		}

		public static bool IsZero(float a)
		{
			return Mathf.Abs(a) < 0.001f;
		}

		public static bool Approx(float a, float b)
		{
			return Mathf.Abs(a - b) < 0.001f;
		}

		public static bool ApproxBetween(float a, float min, float max)
		{
			if (min - 0.001f <= a)
			{
				return a <= max + 0.001f;
			}
			return false;
		}
	}
	public class LocationYaml
	{
		public string prefab = "";

		public bool enabled = true;

		[DefaultValue("")]
		public string dungeon = "";

		[DefaultValue("")]
		public string biome = "";

		[DefaultValue("")]
		public string biomeArea = "";

		public int quantity;

		[DefaultValue(0f)]
		public float minDistance;

		[DefaultValue(0f)]
		public float maxDistance;

		[DefaultValue(-1000f)]
		public float minAltitude = -1000f;

		[DefaultValue(10000f)]
		public float maxAltitude = 10000f;

		[DefaultValue(false)]
		public bool prioritized;

		[DefaultValue(false)]
		public bool centerFirst;

		[DefaultValue(false)]
		public bool unique;

		[DefaultValue(false)]
		public bool randomSeed;

		[DefaultValue(false)]
		public bool pregenerate;

		[DefaultValue("")]
		public string group = "";

		[DefaultValue("")]
		public string groups = "";

		[DefaultValue("")]
		public string groupMax = "";

		[DefaultValue(null)]
		public string[]? awayFrom;

		[DefaultValue(null)]
		public string[]? closeTo;

		[DefaultValue(0f)]
		public float minDistanceFromSimilar;

		[DefaultValue(0f)]
		public float maxDistanceFromSimilar;

		[DefaultValue("")]
		public string discoverLabel = "";

		[DefaultValue("")]
		public string iconAlways = "";

		[DefaultValue("")]
		public string iconPlaced = "";

		[DefaultValue(false)]
		public bool randomRotation;

		[DefaultValue(false)]
		public bool slopeRotation;

		[DefaultValue(false)]
		public bool snapToWater;

		[DefaultValue(0f)]
		public float minTerrainDelta;

		[DefaultValue(10f)]
		public float maxTerrainDelta = 10f;

		[DefaultValue(false)]
		public bool inForest;

		[DefaultValue(0f)]
		public float forestTresholdMin;

		[DefaultValue(1f)]
		public float forestTresholdMax = 1f;

		[DefaultValue(null)]
		public float? offset;

		[DefaultValue(0f)]
		public float groundOffset;

		[DefaultValue("")]
		public string data = "";

		[DefaultValue(null)]
		public string[]? objectData;

		[DefaultValue(null)]
		public string[]? objectSwap;

		[DefaultValue(null)]
		public string[]? dungeonObjectData;

		[DefaultValue(null)]
		public string[]? dungeonObjectSwap;

		[DefaultValue(null)]
		public string[]? locationObjectData;

		[DefaultValue(null)]
		public string[]? locationObjectSwap;

		[DefaultValue(null)]
		public string[]? objects;

		[DefaultValue(null)]
		public string[]? commands;

		[DefaultValue(0f)]
		public float exteriorRadius;

		[DefaultValue(false)]
		public bool clearArea;

		[DefaultValue("")]
		public string randomDamage = "";

		[DefaultValue("")]
		public string noBuild = "";

		[DefaultValue("")]
		public string noBuildDungeon = "";

		[DefaultValue("")]
		public string levelArea = "";

		[DefaultValue(0f)]
		public float levelRadius;

		[DefaultValue(0f)]
		public float levelBorder;

		[DefaultValue("")]
		public string paint = "";

		[DefaultValue(null)]
		public float? paintRadius;

		[DefaultValue(null)]
		public float? paintBorder;

		[DefaultValue("1")]
		public string scaleMin = "1";

		[DefaultValue("1")]
		public string scaleMax = "1";

		[DefaultValue(true)]
		public bool scaleUniform = true;

		[DefaultValue(0f)]
		public float minVegetation;

		[DefaultValue(1f)]
		public float maxVegetation = 1f;

		[DefaultValue(false)]
		public bool surroundCheckVegetation;

		[DefaultValue(20f)]
		public float surroundCheckDistance = 20f;

		[DefaultValue(2)]
		public int surroundCheckLayers = 2;

		[DefaultValue(0f)]
		public float surroundBetterThanAverage;

		[DefaultValue(false)]
		public bool relaxableunique;

		[DefaultValue(false)]
		public bool relaxable;

		[DefaultValue(0.5)]
		public float relaxableamount = 0.5f;
	}
	public class LocationExtra
	{
		public static Dictionary<ZoneLocation, LocationExtraInfo> ExtraInfo = new Dictionary<ZoneLocation, LocationExtraInfo>();

		public static Dictionary<string, List<Tuple<string, float>>> ExtraInfoByVirtualId = new Dictionary<string, List<Tuple<string, float>>>();

		public static void AddInfo(ZoneLocation loc, LocationYaml data, string fileName)
		{
			LocationExtraInfo locationExtraInfo = new LocationExtraInfo(data, fileName);
			loc.m_minDistanceFromSimilar = data.minDistanceFromSimilar;
			loc.m_maxDistanceFromSimilar = data.maxDistanceFromSimilar;
			loc.m_group = data.group;
			loc.m_groupMax = data.groupMax;
			ExtraInfo[loc] = locationExtraInfo;
			AddVirtualRules(loc.m_group, locationExtraInfo.AwayFrom);
			AddVirtualRules(loc.m_groupMax, locationExtraInfo.CloseTo);
		}

		private static void AddVirtualRules(string group, List<Tuple<string, float>>? rules)
		{
			if (IsVirtualGroupId(group) && rules != null && rules.Count != 0)
			{
				ExtraInfoByVirtualId[group] = rules;
			}
		}

		public static void ClearInfo()
		{
			ExtraInfo.Clear();
			ExtraInfoByVirtualId.Clear();
		}

		public static HashSet<ZoneLocation> GetNoBuilds()
		{
			return (from kvp in ExtraInfo
				where !string.IsNullOrEmpty(kvp.Value.Data.noBuild) || !string.IsNullOrEmpty(kvp.Value.Data.noBuildDungeon)
				select kvp.Key).ToHashSet();
		}

		public static bool IsVirtualGroupId(string group)
		{
			if (group.Length < 2)
			{
				return false;
			}
			if (group[0] != '_')
			{
				return false;
			}
			int result;
			return int.TryParse(group.Substring(1), out result);
		}

		public static List<Tuple<string, float>>? GetDistanceRules(string group)
		{
			if (string.IsNullOrEmpty(group))
			{
				return null;
			}
			if (!ExtraInfoByVirtualId.TryGetValue(group, out List<Tuple<string, float>> value))
			{
				return null;
			}
			return value;
		}

		public static bool MatchesTarget(ZoneLocation? location, string target)
		{
			if (location == null)
			{
				return false;
			}
			if (location.m_prefab.Name == target)
			{
				return true;
			}
			if (!TryGet(location, out LocationExtraInfo extra))
			{
				return false;
			}
			if (extra.Groups == null)
			{
				return false;
			}
			return extra.Groups.Contains(target);
		}

		public static bool MatchesTarget(ZoneLocation? location, string prefabName, string group)
		{
			if (location == null)
			{
				return false;
			}
			if (location.m_prefab.Name == prefabName)
			{
				return true;
			}
			if (!TryGet(location, out LocationExtraInfo extra))
			{
				return false;
			}
			if (extra.Groups == null)
			{
				return false;
			}
			return extra.Groups.Contains(group);
		}

		private static DataEntry? ResolveData(LocationExtraInfo extra, string prefab, bool dungeon)
		{
			Dictionary<string, List<Tuple<float, DataEntry>>> dictionary = (dungeon ? extra.DungeonObjectData : extra.ObjectData);
			if (dictionary == null)
			{
				return null;
			}
			return Spawn.GetData(dictionary, prefab);
		}

		private static string ResolvePrefabOverride(LocationExtraInfo extra, string prefab, bool dungeon)
		{
			Dictionary<string, List<Tuple<float, string>>> dictionary = (dungeon ? extra.DungeonObjectSwaps : extra.ObjectSwaps);
			if (dictionary == null)
			{
				return prefab;
			}
			if (!dictionary.TryGetValue(prefab, out var value))
			{
				return prefab;
			}
			return Spawn.RandomizeSwap(value);
		}

		private static void ExecuteCommands(LocationExtraInfo extra, Vector3 pos, Quaternion rot)
		{
			//IL_000f: 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)
			if (extra.Commands != null)
			{
				CommandManager.Run(extra.Commands, pos, ((Quaternion)(ref rot)).eulerAngles);
			}
		}

		private static Vector3 ResolveScale(LocationExtraInfo extra)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			if (extra.Scale == null)
			{
				return Vector3.one;
			}
			return Helper.RandomValue(extra.Scale);
		}

		public static bool TryGet(ZoneLocation? location, out LocationExtraInfo extra)
		{
			if (location == null)
			{
				extra = null;
				return false;
			}
			return ExtraInfo.TryGetValue(location, out extra);
		}

		public static DataEntry? MergeData(ZoneLocation? location, DataEntry? pkg, string prefab, bool dungeon = false)
		{
			if (!TryGet(location, out LocationExtraInfo extra))
			{
				return pkg;
			}
			return DataHelper.Merge(ResolveData(extra, prefab, dungeon), pkg);
		}

		public static DataEntry? GetData(ZoneLocation? location, string prefab, bool dungeon = false)
		{
			if (!TryGet(location, out LocationExtraInfo extra))
			{
				return null;
			}
			return ResolveData(extra, prefab, dungeon);
		}

		public static string GetPrefabOverride(ZoneLocation? location, string prefab, bool dungeon = false)
		{
			if (!TryGet(location, out LocationExtraInfo extra))
			{
				return prefab;
			}
			return ResolvePrefabOverride(extra, prefab, dungeon);
		}

		public static void RunCommand(ZoneLocation? location, Vector3 pos, Quaternion rot)
		{
			//IL_000c: 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 (TryGet(location, out LocationExtraInfo extra))
			{
				ExecuteCommands(extra, pos, rot);
			}
		}

		public static Vector3 GetScale(ZoneLocation? location)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			if (!TryGet(location, out LocationExtraInfo extra))
			{
				return Vector3.one;
			}
			return ResolveScale(extra);
		}

		public static string GetDungeonName(ZoneLocation? location, DungeonGenerator dg)
		{
			string result = Utils.GetPrefabName(((Component)dg).gameObject) ?? "";
			if (!TryGet(location, out LocationExtraInfo extra))
			{
				return result;
			}
			if (extra.Dungeon == null || extra.Dungeon == "")
			{
				return result;
			}
			return extra.Dungeon;
		}

		public static bool TryGetData(ZoneLocation? location, out LocationYaml data)
		{
			if (!TryGet(location, out LocationExtraInfo extra))
			{
				data = new LocationYaml();
				return false;
			}
			data = extra.Data;
			return true;
		}
	}
	public class LocationExtraInfo
	{
		private static int VirtualGroupId;

		public string? ZDOData;

		public string? Dungeon;

		public HashSet<string> Groups;

		public List<Tuple<string, float>>? AwayFrom;

		public List<Tuple<string, float>>? CloseTo;

		public Dictionary<string, List<Tuple<float, string>>>? ObjectSwaps;

		public Dictionary<string, List<Tuple<float, string>>>? DungeonObjectSwaps;

		public Dictionary<string, List<Tuple<float, DataEntry?>>>? ObjectData;

		public Dictionary<string, List<Tuple<float, DataEntry?>>>? DungeonObjectData;

		public List<BlueprintObject>? Objects;

		public Range<Vector3>? Scale;

		public string[]? Commands;

		public LocationYaml Data;

		public LocationExtraInfo(LocationYaml data, string fileName)
		{
			//IL_00ed: 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_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			Data = data;
			Groups = ParseMembership(data.groups);
			if (data.group != "")
			{
				Groups.Add(data.group);
			}
			if (data.groupMax != "")
			{
				Groups.Add(data.groupMax);
			}
			LoadDistanceRules(data, fileName);
			if (data.data != "")
			{
				ZDOData = data.data;
			}
			if (data.dungeon != "")
			{
				Dungeon = data.dungeon;
			}
			LoadObjectData(data, fileName);
			LoadObjectSwaps(data);
			if (data.objects != null)
			{
				Objects = Helper.ParseObjects(data.objects, fileName);
			}
			if (data.commands != null)
			{
				Commands = data.commands;
			}
			Range<Vector3> range = new Range<Vector3>(Parse.Scale(data.scaleMin), Parse.Scale(data.scaleMax))
			{
				Uniform = data.scaleUniform
			};
			if (range.Min != range.Max)
			{
				Scale = range;
			}
		}

		private static List<Tuple<string, float>>? ParseDistanceRules(string[]? rules, string fieldName, string fileName)
		{
			if (rules == null)
			{
				return null;
			}
			List<Tuple<string, float>> list = new List<Tuple<string, float>>();
			foreach (string text in rules)
			{
				KeyValuePair<string, string> keyValuePair = Parse.Kvp(text);
				string text2 = keyValuePair.Key.Trim();
				if (!(text2 == ""))
				{
					float result;
					if (keyValuePair.Value == "")
					{
						Log.Warning(fileName + ": Invalid " + fieldName + " value '" + text + "', expected 'target,distance'.");
					}
					else if (!Parse.TryFloat(keyValuePair.Value, out result))
					{
						Log.Warning(fileName + ": Invalid " + fieldName + " distance '" + keyValuePair.Value + "' in value '" + text + "'.");
					}
					else
					{
						list.Add(new Tuple<string, float>(text2, result));
					}
				}
			}
			if (list.Count == 0)
			{
				return null;
			}
			return list;
		}

		private static HashSet<string> ParseMembership(string groups)
		{
			if (groups == "")
			{
				return new HashSet<string>();
			}
			HashSet<string> hashSet = new HashSet<string>();
			foreach (string item in from @group in Parse.Split(groups)
				where @group != ""
				select @group)
			{
				hashSet.Add(item);
			}
			return hashSet;
		}

		private static string CreateVirtualGroupName()
		{
			VirtualGroupId++;
			return $"_{VirtualGroupId}";
		}

		private void LoadDistanceRules(LocationYaml data, string fileName)
		{
			List<Tuple<string, float>> list = ParseDistanceRules(data.awayFrom, "awayFrom", fileName);
			List<Tuple<string, float>> list2 = ParseDistanceRules(data.closeTo, "closeTo", fileName);
			if (list != null)
			{
				data.group = CreateVirtualGroupName();
				data.minDistanceFromSimilar = 1f;
				AwayFrom = list;
			}
			if (list2 != null)
			{
				data.groupMax = CreateVirtualGroupName();
				data.maxDistanceFromSimilar = 1f;
				CloseTo = list2;
			}
		}

		private void LoadObjectData(LocationYaml data, string fileName)
		{
			Dictionary<string, List<Tuple<float, DataEntry>>> dictionary = null;
			Dictionary<string, List<Tuple<float, DataEntry>>> dictionary2 = null;
			if (data.objectData != null)
			{
				dictionary = Spawn.LoadData(data.objectData, fileName);
				dictionary2 = Spawn.LoadData(data.objectData, fileName);
			}
			if (data.locationObjectData != null)
			{
				Dictionary<string, List<Tuple<float, DataEntry>>> dictionary3 = Spawn.LoadData(data.locationObjectData, fileName);
				if (dictionary == null)
				{
					dictionary = dictionary3;
				}
				else
				{
					foreach (KeyValuePair<string, List<Tuple<float, DataEntry>>> item in dictionary3)
					{
						dictionary[item.Key] = item.Value;
					}
				}
			}
			if (data.dungeonObjectData != null)
			{
				Dictionary<string, List<Tuple<float, DataEntry>>> dictionary4 = Spawn.LoadData(data.dungeonObjectData, fileName);
				if (dictionary2 == null)
				{
					dictionary2 = dictionary4;
				}
				else
				{
					foreach (KeyValuePair<string, List<Tuple<float, DataEntry>>> item2 in dictionary4)
					{
						dictionary2[item2.Key] = item2.Value;
					}
				}
			}
			if (dictionary2 != null)
			{
				DungeonObjectData = dictionary2;
			}
			if (dictionary != null)
			{
				ObjectData = dictionary;
			}
		}

		private void LoadObjectSwaps(LocationYaml data)
		{
			Dictionary<string, List<Tuple<float, string>>> dictionary = null;
			Dictionary<string, List<Tuple<float, string>>> dictionary2 = null;
			if (data.objectSwap != null)
			{
				dictionary = Spawn.LoadSwaps(data.objectSwap);
				dictionary2 = Spawn.LoadSwaps(data.objectSwap);
			}
			if (data.locationObjectSwap != null)
			{
				Dictionary<string, List<Tuple<float, string>>> dictionary3 = Spawn.LoadSwaps(data.locationObjectSwap);
				if (dictionary == null)
				{
					dictionary = dictionary3;
				}
				else
				{
					foreach (KeyValuePair<string, List<Tuple<float, string>>> item in dictionary3)
					{
						dictionary[item.Key] = item.Value;
					}
				}
			}
			if (data.dungeonObjectSwap != null)
			{
				Dictionary<string, List<Tuple<float, string>>> dictionary4 = Spawn.LoadSwaps(data.dungeonObjectSwap);
				if (dictionary2 == null)
				{
					dictionary2 = dictionary4;
				}
				else
				{
					foreach (KeyValuePair<string, List<Tuple<float, string>>> item2 in dictionary4)
					{
						dictionary2[item2.Key] = item2.Value;
					}
				}
			}
			if (dictionary2 != null)
			{
				DungeonObjectSwaps = dictionary2;
			}
			if (dictionary != null)
			{
				ObjectSwaps = dictionary;
			}
		}
	}
	public class LocationLoading
	{
		public static string FileName = "expand_locations.yaml";

		public static string FilePath = Path.Combine(Yaml.BaseDirectory, FileName);

		public static string Pattern = "expand_locations*.yaml";

		private static readonly List<LocationYaml> ExtraLocationYamls = new List<LocationYaml>();

		private static List<ZoneLocation> DefaultEntries = new List<ZoneLocation>();

		private static Dictionary<string, ZoneLocation> Locations = new Dictionary<string, ZoneLocation>();

		public static void AddLocation(LocationYaml yaml)
		{
			ExtraLocationYamls.Add(yaml);
		}

		public static ZoneLocation FromData(LocationYaml data, string fileName)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: 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_002f: 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_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: 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_0059: 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_0071: 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_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: 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_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: 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_0133: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: 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_0161: 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)
			//IL_0185: 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_019d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a9: 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_01c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01da: Expected O, but got Unknown
			ZoneLocation val = new ZoneLocation
			{
				m_prefabName = data.prefab,
				m_enable = data.enabled,
				m_biome = DataManager.ToBiomes(data.biome, fileName),
				m_biomeArea = DataManager.ToBiomeAreas(data.biomeArea, fileName),
				m_quantity = data.quantity,
				m_prioritized = data.prioritized,
				m_centerFirst = data.centerFirst,
				m_unique = data.unique,
				m_group = data.group,
				m_minDistanceFromSimilar = data.minDistanceFromSimilar,
				m_iconAlways = (data.iconAlways != "" && data.iconAlways != "false"),
				m_iconPlaced = (data.iconPlaced != "" && data.iconPlaced != "false"),
				m_randomRotation = data.randomRotation,
				m_slopeRotation = data.slopeRotation,
				m_snapToWater = data.snapToWater,
				m_minTerrainDelta = data.minTerrainDelta,
				m_maxTerrainDelta = data.maxTerrainDelta,
				m_inForest = data.inForest,
				m_forestTresholdMin = data.forestTresholdMin,
				m_forestTresholdMax = data.forestTresholdMax,
				m_minDistance = WorldEntry.ConvertDist(data.minDistance),
				m_maxDistance = WorldEntry.ConvertDist(data.maxDistance),
				m_minAltitude = data.minAltitude,
				m_maxAltitude = data.maxAltitude,
				m_groupMax = data.groupMax,
				m_maxDistanceFromSimilar = data.maxDistanceFromSimilar,
				m_minimumVegetation = data.minVegetation,
				m_maximumVegetation = data.maxVegetation,
				m_surroundCheckVegetation = data.surroundCheckVegetation,
				m_surroundCheckDistance = data.surroundCheckDistance,
				m_surroundCheckLayers = data.surroundCheckLayers,
				m_surroundBetterThanAverage = data.surroundBetterThanAverage
			};
			LocationExtra.AddInfo(val, data, fileName);
			Setup(data.prefab, val, fileName);
			return val;
		}

		public static LocationYaml ToData(ZoneLocation loc)
		{
			//IL_0099: 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)
			LocationYaml locationYaml = new LocationYaml();
			if (LocationExtra.TryGetData(loc, out LocationYaml data))
			{
				locationYaml = data;
			}
			if (loc.m_minDistanceFromCenter != 0f && (loc.m_minDistance == 0f || loc.m_minDistanceFromCenter > loc.m_minDistance))
			{
				loc.m_minDistance = loc.m_minDistanceFromCenter;
			}
			if (loc.m_maxDistanceFromCenter != 0f && (loc.m_maxDistance == 0f || loc.m_maxDistanceFromCenter < loc.m_maxDistance))
			{
				loc.m_maxDistance = loc.m_maxDistanceFromCenter;
			}
			locationYaml.prefab = loc.m_prefab.Name;
			locationYaml.enabled = loc.m_enable;
			locationYaml.biome = DataManager.FromBiomes(loc.m_biome);
			locationYaml.biomeArea = DataManager.FromBiomeAreas(loc.m_biomeArea);
			locationYaml.quantity = loc.m_quantity;
			locationYaml.prioritized = loc.m_prioritized;
			locationYaml.centerFirst = loc.m_centerFirst;
			locationYaml.unique = loc.m_unique;
			locationYaml.group = loc.m_group;
			locationYaml.minDistanceFromSimilar = loc.m_minDistanceFromSimilar;
			locationYaml.iconAlways = (loc.m_iconAlways ? loc.m_prefab.Name : "");
			locationYaml.iconPlaced = (loc.m_iconPlaced ? loc.m_prefab.Name : "");
			locationYaml.randomRotation = loc.m_randomRotation;
			locationYaml.slopeRotation = loc.m_slopeRotation;
			locationYaml.snapToWater = loc.m_snapToWater;
			locationYaml.maxTerrainDelta = loc.m_maxTerrainDelta;
			locationYaml.minTerrainDelta = loc.m_minTerrainDelta;
			locationYaml.inForest = loc.m_inForest;
			locationYaml.forestTresholdMin = loc.m_forestTresholdMin;
			locationYaml.forestTresholdMax = loc.m_forestTresholdMax;
			locationYaml.minDistance = loc.m_minDistance / 10000f;
			locationYaml.maxDistance = loc.m_maxDistance / 10000f;
			locationYaml.minAltitude = loc.m_minAltitude;
			locationYaml.groupMax = loc.m_groupMax;
			locationYaml.maxDistanceFromSimilar = loc.m_maxDistanceFromSimilar;
			locationYaml.minVegetation = loc.m_minimumVegetation;
			locationYaml.maxVegetation = loc.m_maximumVegetation;
			locationYaml.surroundCheckVegetation = loc.m_surroundCheckVegetation;
			locationYaml.surroundCheckDistance = loc.m_surroundCheckDistance;
			locationYaml.surroundCheckLayers = loc.m_surroundCheckLayers;
			locationYaml.surroundBetterThanAverage = loc.m_surroundBetterThanAverage;
			if (loc.m_maxAltitude == 1000f)
			{
				locationYaml.maxAltitude = 10000f;
			}
			else
			{
				locationYaml.maxAltitude = loc.m_maxAltitude;
			}
			GameObject val = Helper.SafeLoad(loc);
			if ((Object)(object)val == (Object)null)
			{
				return locationYaml;
			}
			Location component = val.GetComponent<Location>();
			if (Object.op_Implicit((Object)(object)component))
			{
				locationYaml.randomDamage = (component.m_applyRandomDamage ? "true" : "");
				locationYaml.exteriorRadius = component.m_exteriorRadius;
				locationYaml.clearArea = component.m_clearArea;
				locationYaml.discoverLabel = component.m_discoverLabel;
				locationYaml.noBuild = (component.m_noBuild ? "true" : "");
				if (component.m_noBuild && component.m_noBuildRadiusOverride > 0f)
				{
					locationYaml.noBuild = component.m_noBuildRadiusOverride.ToString(NumberFormatInfo.InvariantInfo);
				}
			}
			loc.m_prefab.Release();
			return locationYaml;
		}

		public static bool IsValid(ZoneLocation loc)
		{
			return loc.m_prefab.IsValid;
		}

		private static void ToFile()
		{
			if (!File.Exists(FilePath))
			{
				List<LocationYaml> list = ZoneSystem.instance.m_locations.Where(IsValid).Select(ToData).ToList();
				if (ExtraLocationYamls.Count > 0)
				{
					list.AddRange(ExtraLocationYamls);
				}
				Save(list, log: false);
			}
		}

		public static void Initialize()
		{
			ZoneSystem instance = ZoneSystem.instance;
			List<ZoneLocation> list = new List<ZoneLocation>();
			list.AddRange(ZoneSystem.instance.m_locations.Where((ZoneLocation loc) => loc.m_prefab.IsValid));
			instance.m_locations = list;
			DefaultEntries.Clear();
			Locations.Clear();
			if (Helper.IsServer())
			{
				DefaultEntries = ZoneSystem.instance.m_locations;
				Locations = Helper.ToDict(DefaultEntries, (ZoneLocation l) => l.m_prefab.Name, (ZoneLocation l) => l);
			}
		}

		public static void CreateConfigs()
		{
			if (!Helper.IsClient() && Configuration.DataLocation && !File.Exists(FilePath))
			{
				ToFile();
			}
		}

		public static void ReadConfigs()
		{
			CleanUp();
			if (!Helper.IsClient())
			{
				if (!Configuration.DataLocation)
				{
					Apply(DefaultEntries);
				}
				else if (!File.Exists(FilePath))
				{
					ToFile();
				}
				else
				{
					Apply(FromFile());
				}
			}
		}

		public static void CleanUp()
		{
			LocationExtra.ClearInfo();
		}

		private static void Apply(List<ZoneLocation> data)
		{
			ZoneSystem.instance.m_locations = DefaultEntries;
			if (Configuration.DataLocation)
			{
				if (data.Count == 0)
				{
					Log.Warning("Failed to load any location data.");
					Log.Info($"Reloading default location data ({DefaultEntries.Count} entries).");
				}
				else
				{
					if (Configuration.DataMigration && AddMissingEntries(data))
					{
						return;
					}
					ZoneSystem.instance.m_locations = data;
					Log.Info($"Reloading location data ({data.Count} entries).");
				}
			}
			else
			{
				Log.Info($"Reloading default location data ({DefaultEntries.Count} entries).");
			}
			UpdateHashes();
			UpdateInstances();
			CreateLocalZones.LocationsPregenerated = false;
			NoBuildManager.UpdateData();
			MinimapIcon.Clear();
			ZoneSystem.instance.SendLocationIcons(ZRoutedRpc.Everybody);
			IdManager.SendLocationIds();
		}

		private static void UpdateHashes()
		{
			ZoneSystem instance = ZoneSystem.instance;
			instance.m_locationsByHash = Helper.ToDict(instance.m_locations, (ZoneLocation loc) => StringExtensionMethods.GetStableHashCode(loc.m_prefab.Name), (ZoneLocation loc) => loc);
		}

		private static void UpdateInstances()
		{
			//IL_001f: 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_0027: 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_002e: 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_0057: 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)
			ZoneSystem instance = ZoneSystem.m_instance;
			Dictionary<Vector2i, LocationInstance> locationInstances = instance.m_locationInstances;
			Vector2i[] array = locationInstances.Keys.ToArray();
			foreach (Vector2i key in array)
			{
				LocationInstance val = locationInstances[key];
				ZoneLocation location = instance.GetLocation(val.m_location.m_prefab.Name);
				if (location != null)
				{
					val.m_location = location;
					locationInstances[key] = val;
				}
			}
		}

		private static bool AddMissingEntries(List<ZoneLocation> items)
		{
			HashSet<string> missingKeys = Locations.Keys.ToHashSet();
			foreach (ZoneLocation item in items)
			{
				missingKeys.Remove(item.m_prefab.Name);
			}
			if (missingKeys.Count == 0)
			{
				return false;
			}
			List<LocationYaml> list = DefaultEntries.Where((ZoneLocation loc) => missingKeys.Contains(loc.m_prefab.Name)).Select(ToData).ToList();
			Log.Warning($"Adding {list.Count} missing locations to the expand_locations.yaml file.");
			Save(list, log: true);
			return true;
		}

		private static void Save(List<LocationYaml> data, bool log)
		{
			Dictionary<string, List<LocationYaml>> dictionary = new Dictionary<string, List<LocationYaml>>();
			foreach (LocationYaml datum in data)
			{
				string modFromPrefab = AssetTracker.GetModFromPrefab(datum.prefab);
				string key = (Configuration.SplitDataPerMod ? AssetTracker.GetFileNameFromMod(modFromPrefab) : "");
				if (!dictionary.ContainsKey(key))
				{
					dictionary[key] = new List<LocationYaml>();
				}
				dictionary[key].Add(datum);
				if (log)
				{
					Log.Warning(modFromPrefab + ": " + datum.prefab);
				}
			}
			foreach (KeyValuePair<string, List<LocationYaml>> item in dictionary)
			{
				string path = Path.Combine(Yaml.BaseDirectory, "expand_locations" + item.Key + ".yaml");
				string text = (File.Exists(path) ? (File.ReadAllText(path) + "\n") : "");
				text += Yaml.Serializer().Serialize((object)item.Value);
				File.WriteAllText(path, text);
			}
		}

		private static List<ZoneLocation> FromFile()
		{
			try
			{
				return (from loc in DataManager.ReadData<LocationYaml, ZoneLocation>(Pattern, FromData)
					where !string.IsNullOrWhiteSpace(loc.m_prefab.Name)
					select loc).ToList();
			}
			catch (Exception ex)
			{
				Log.Error(ex.Message);
				Log.Error(ex.StackTrace);
			}
			return new List<ZoneLocation>();
		}

		private static void ApplyLocationData(ZoneLocation item, float? radius = null)
		{
			if (LocationExtra.TryGetData(item, out LocationYaml data) && (data.exteriorRadius != 0f || radius.HasValue))
			{
				item.m_exteriorRadius = data.exteriorRadius;
				if (radius.HasValue && item.m_exteriorRadius == 0f)
				{
					item.m_exteriorRadius = radius.Value;
				}
				item.m_clearArea = data.clearArea;
			}
		}

		private static bool SetupBlueprint(string name, ZoneLocation location)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: 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_0026: Unknown result type (might be due to invalid IL or missing references)
			if (!BlueprintManager.TryGet(name, out Blueprint bp))
			{
				return false;
			}
			SoftReference<GameObject> prefab = default(SoftReference<GameObject>);
			prefab..ctor(default(AssetID));
			prefab.m_name = name;
			location.m_prefab = prefab;
			ApplyLocationData(location, bp.Radius + 5f);
			return true;
		}

		private static void Setup(string name, ZoneLocation item, string fileName)
		{
			//IL_004d: 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)
			string text = Parse.Name(name);
			if (!Locations.TryGetValue(text, out ZoneLocation value) || !value.m_prefab.IsValid)
			{
				if (!SetupBlueprint(name, item))
				{
					Log.Warning(fileName + ": Location prefab " + text + " not found!");
				}
				return;
			}
			SoftReference<GameObject> prefab = default(SoftReference<GameObject>);
			prefab..ctor(value.m_prefab.m_assetID);
			prefab.m_name = name;
			item.m_prefab = prefab;
			item.m_interiorRadius = value.m_interiorRadius;
			item.m_exteriorRadius = value.m_exteriorRadius;
			ApplyLocationData(item);
		}

		public static void SetupWatcher()
		{
			Yaml.SetupWatcher(Pattern, ReadConfigs);
		}
	}
	[HarmonyPatch(typeof(ZoneSystem))]
	public static class ZoneSystemPatches
	{
		[HarmonyPatch("GetLocationIcon")]
		[HarmonyPrefix]
		private static bool GetLocationIcon(ZoneSystem __instance, string name, ref Vector3 pos, ref bool __result)
		{
			//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_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			if (!ZNet.instance.IsServer())
			{
				return true;
			}
			__instance.tempIconList.Clear();
			__instance.GetLocationIcons(__instance.tempIconList);
			foreach (KeyValuePair<Vector3, string> tempIcon in __instance.tempIconList)
			{
				if (!(tempIcon.Value != name))
				{
					pos = tempIcon.Key;
					__result = true;
					return false;
				}
			}
			pos = Vector3.zero;
			__result = false;
			return false;
		}

		[HarmonyPatch("GetLocationIcons")]
		[HarmonyPrefix]
		private static bool GetLocationIcons(ZoneSystem __instance, Dictionary<Vector3, string> icons)
		{
			//IL_0032: 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_0044: 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_0155: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: 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_00bd: 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)
			if (!Configuration.DataLocation)
			{
				return true;
			}
			if (!ZNet.instance.IsServer())
			{
				return true;
			}
			foreach (KeyValuePair<Vector2i, LocationInstance> locationInstance in __instance.m_locationInstances)
			{
				ZoneLocation location = locationInstance.Value.m_location;
				Vector3 position = locationInstance.Value.m_position;
				if (location == null)
				{
					continue;
				}
				if (LocationExtra.TryGetData(location, out LocationYaml data))
				{
					string text = ((data.iconPlaced == "true") ? location.m_prefab.Name : ((data.iconPlaced == "false") ? "" : data.iconPlaced));
					if (locationInstance.Value.m_placed && text != "")
					{
						icons[position] = text;
						continue;
					}
					position.y += 1E-05f;
					string text2 = ((data.iconAlways == "true") ? location.m_prefab.Name : ((data.iconAlways == "false") ? "" : data.iconAlways));
					if (text2 != "")
					{
						icons[position] = text2;
					}
				}
				else if (location.m_iconAlways || (location.m_iconPlaced && locationInstance.Value.m_placed))
				{
					icons[position] = location.m_prefab.Name;
				}
			}
			return false;
		}

		[HarmonyPatch("GetLocation", new Type[] { typeof(string) })]
		[HarmonyPrefix]
		private static bool GetLocation(ZoneSystem __instance, string name, ref ZoneLocation __result)
		{
			foreach (ZoneLocation location in __instance.m_locations)
			{
				if (location.m_prefab.Name == name)
				{
					__result = location;
					return false;
				}
			}
			__result = null;
			return false;
		}
	}
	public class LocationSpawning
	{
		public static ZoneLocation? CurrentLocation = null;

		private static readonly string DummyObj = "vfx_auto_pickup";

		public static GameObject DummySpawn => Object.Instantiate<GameObject>(ZNetScene.instance.GetPrefab(DummyObj), Vector3.zero, Quaternion.identity);

		public static DataEntry? DataOverride(DataEntry? pkg, string prefab)
		{
			return LocationExtra.MergeData(CurrentLocation, pkg, prefab);
		}

		public static DataEntry? DungeonDataOverride(string prefab)
		{
			return LocationExtra.GetData(CurrentLocation, prefab, dungeon: true);
		}

		public static string PrefabOverride(string prefab)
		{
			return LocationExtra.GetPrefabOverride(CurrentLocation, prefab);
		}

		public static string DungeonPrefabOverride(string prefab)
		{
			return LocationExtra.GetPrefabOverride(CurrentLocation, prefab, dungeon: true);
		}

		public static GameObject Object(GameObject prefab, Vector3 pos, Quaternion rot, int seed, List<GameObject> spawnedGhostObjects)
		{
			//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_000e: Unknown result type (might be due to invalid IL or missing references)
			return Spawn.BPO(new BlueprintObject(Utils.GetPrefabName(prefab), pos, rot, prefab.transform.localScale, null, 1f), seed, DataOverride, PrefabOverride, spawnedGhostObjects) ?? DummySpawn;
		}

		public static void CustomObjects(ZoneLocation location, Vector3 pos, Quaternion rot, Vector3 scale, int seed, List<GameObject> spawnedGhostObjects)
		{
			//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_004c: Unknown result type (might be due to invalid IL or missing references)
			if (!LocationExtra.TryGet(location, out LocationExtraInfo extra) || extra?.Objects == null)
			{
				return;
			}
			foreach (BlueprintObject @object in extra.Objects)
			{
				if (!(@object.Chance < 1f) || !(Random.value > @object.Chance))
				{
					Spawn.BPO(@object, pos, rot, scale, seed, DataOverride, PrefabOverride, spawnedGhostObjects);
				}
			}
		}
	}
	[HarmonyPatch(typeof(ZoneSystem), "CreateLocationProxy")]
	public class LocationZDO
	{
		private static void Prefix(ZoneSystem __instance, ZoneLocation location, Vector3 pos, Quaternion rotation)
		{
			//IL_0036: 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)
			if (!LocationExtra.TryGet(location, out LocationExtraInfo extra))
			{
				return;
			}
			string zDOData = extra.ZDOData;
			if (!string.IsNullOrEmpty(zDOData))
			{
				DataEntry dataEntry = DataHelper.Get(zDOData, location.m_prefab.Name);
				if (dataEntry != null)
				{
					DataHelper.Init(__instance.m_locationProxyPrefab, pos, rotation, null, dataEntry);
				}
			}
		}
	}
	[HarmonyPatch(typeof(LocationProxy), "SetLocation")]
	public class FixGhostInit
	{
		public static readonly int ReferenceHash = StringExtensionMethods.GetStableHashCode("locationreference");

		private static void Prefix(LocationProxy __instance, ref string location, ref bool spawnNow)
		{
			int stableHashCode = StringExtensionMethods.GetStableHashCode(location);
			__instance.m_nview.GetZDO().Set(ReferenceHash, stableHashCode, false);
			location = Parse.Name(location);
			if (ZNetView.m_ghostInit)
			{
				spawnNow = false;
				DataManager.CleanGhostInit(__instance.m_nview);
			}
		}
	}
	[HarmonyPatch(typeof(ZoneSystem), "SpawnLocation")]
	public class LocationObjectDataAndSwap
	{
		[HarmonyPatch(typeof(ZoneSystem), "PokeCanSpawnLocation")]
		public class PokeCanSpawnLocation
		{
			private static bool Prefix(ZoneLocation location, ref bool __result)
			{
				if (BlueprintManager.Has(location.m_prefab.Name))
				{
					__result = true;
					return false;
				}
				return true;
			}
		}

		private static bool Prefix(ZoneLocation location, SpawnMode mode, ref Vector3 pos, ref int seed, List<GameObject> spawnedGhostObjects)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Invalid comparison between Unknown and I4
			//IL_0089: 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)
			if ((int)mode != 1)
			{
				LocationSpawning.CurrentLocation = location;
				if (LocationExtra.TryGetData(location, out LocationYaml data))
				{
					Spawn.IgnoreHealth = data.randomDamage == "all";
					pos.y += data.offset ?? data.groundOffset;
					if (Configuration.RandomLocations || data.randomSeed)
					{
						seed = DateTime.Now.Ticks.GetHashCode();
					}
				}
			}
			if (location.m_prefab.IsValid)
			{
				return true;
			}
			CreateBlueprintProxy(location, pos, mode, spawnedGhostObjects);
			return false;
		}

		private static void CreateBlueprintProxy(ZoneLocation location, Vector3 pos, SpawnMode mode, List<GameObject> spawnedGhostObjects)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Invalid comparison between Unknown and I4
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Invalid comparison between Unknown and I4
			//IL_0018: 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_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Invalid comparison between Unknown and I4
			if ((int)mode != 1)
			{
				if ((int)mode == 2)
				{
					ZNetView.StartGhostInit();
				}
				GameObject val = Object.Instantiate<GameObject>(ZoneSystem.instance.m_locationProxyPrefab, pos, Quaternion.identity);
				LocationProxy component = val.GetComponent<LocationProxy>();
				ZNetView nview = component.m_nview;
				int stableHashCode = StringExtensionMethods.GetStableHashCode(location.m_prefab.Name);
				nview.GetZDO().Set(FixGhostInit.ReferenceHash, stableHashCode, false);
				if ((int)mode == 0)
				{
					component.SpawnLocation();
				}
				if ((int)mode == 2)
				{
					spawnedGhostObjects.Add(val);
					ZNetView.FinishGhostInit();
				}
			}
		}

		private static void Customize(ZoneLocation location)
		{
			if (LocationExtra.TryGetData(location, out LocationYaml data))
			{
				WearNTear.m_randomInitialDamage = data.randomDamage == "true" || data.randomDamage == "all";
			}
		}

		private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0049: 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_007c: Expected O, but got Unknown
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Expected O, but got Unknown
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Expected O, but got Unknown
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Expected O, but got Unknown
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Expected O, but got Unknown
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Expected O, but got Unknown
			MethodInfo methodInfo = AccessTools.FirstMethod(typeof(Object), (Func<MethodInfo, bool>)((MethodInfo info) => info.Name == "Instantiate" && info.IsGenericMethodDefinition && info.GetParameters().Length == 3 && info.GetParameters()[1].ParameterType == typeof(Vector3) && info.GetParameters()[2].ParameterType == typeof(Quaternion))).MakeGenericMethod(typeof(GameObject));
			return new CodeMatcher(instructions, (ILGenerator)null).MatchForward(true, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Stsfld, (object)AccessTools.Field(typeof(WearNTear), "m_randomInitialDamage"), (string)null)
			}).InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
			{
				new CodeInstruction(OpCodes.Ldarg_1, (object)null)
			}).InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
			{
				new CodeInstruction(OpCodes.Call, Transpilers.EmitDelegate<Action<ZoneLocation>>((Action<ZoneLocation>)Customize).operand)
			})
				.MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
				{
					new CodeMatch((OpCode?)OpCodes.Call, (object)methodInfo, (string)null)
				})
				.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
				{
					new CodeInstruction(OpCodes.Ldarg_2, (object)null)
				})
				.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
				{
					new CodeInstruction(OpCodes.Ldarg_S, (object)6)
				})
				.Set(OpCodes.Call, Transpilers.EmitDelegate<Func<GameObject, Vector3, Quaternion, int, List<GameObject>, GameObject>>((Func<GameObject, Vector3, Quaternion, int, List<GameObject>, GameObject>)LocationSpawning.Object).operand)
				.InstructionEnumeration();
		}

		private static void Postfix(ZoneLocation location, int seed, Vector3 pos, Quaternion rot, SpawnMode mode, List<GameObject> spawnedGhostObjects)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Invalid comparison between Unknown and I4
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Invalid comparison between Unknown and I4
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: 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_0115: Invalid comparison between Unknown and I4
			//IL_004b: 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_0050: 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_0124: 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_00bb: 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_007c: Unknown result type (might be due to invalid IL or missing references)
			if ((int)mode != 1)
			{
				bool flag = BlueprintManager.Has(location.m_prefab.Name);
				if (LocationExtra.TryGetData(location, out LocationYaml data))
				{
					WearNTear.m_randomInitialDamage = data.randomDamage == "true" || data.randomDamage == "all";
					Vector3 pos2 = pos;
					pos2.y = pos.y - (data.offset ?? data.groundOffset);
					HandleTerrain(pos2, location.m_exteriorRadius, flag, data);
				}
				Random.InitState(seed);
				if ((int)mode == 2)
				{
					ZNetView.StartGhostInit();
				}
				Vector3 scale = LocationExtra.GetScale(location);
				if (flag && BlueprintManager.TryGet(location.m_prefab.Name, out Blueprint bp))
				{
					Spawn.Blueprint(bp, pos, rot, scale, seed, LocationSpawning.DataOverride, LocationSpawning.PrefabOverride, spawnedGhostObjects);
				}
				LocationSpawning.CustomObjects(location, pos, rot, scale, seed, spawnedGhostObjects);
				WearNTear.m_randomInitialDamage = false;
				SnapToGround.SnappAll();
				if ((int)mode == 2)
				{
					ZNetView.FinishGhostInit();
				}
				Spawn.IgnoreHealth = false;
				LocationExtra.RunCommand(location, pos, rot);
				LocationSpawning.CurrentLocation = null;
			}
		}

		private static void HandleTerrain(Vector3 pos, float radius, bool isBlueprint, LocationYaml data)
		{
			//IL_0015: 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_008a: Unknown result type (might be due to invalid IL or missing references)
			bool level = false;
			if (data.levelArea == "")
			{
				level = isBlueprint;
			}
			else if (data.levelArea == "false")
			{
				level = false;
			}
			else
			{
				level = true;
			}
			if (!level && data.paint == "")
			{
				return;
			}
			Terrain.ChangeTerrain(pos, delegate(Heightmap hm, TerrainFakeData terrain)
			{
				//IL_00b5: 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)
				if (level)
				{
					float num = data.levelRadius;
					float num2 = data.levelBorder;
					if (num == 0f && num2 == 0f)
					{
						float num3 = Parse.Float(data.levelArea, 0.5f);
						num = num3 * radius;
						num2 = (1f - num3) * radius;
					}
					Terrain.Level(hm, terrain, pos, num, num2);
				}
				if (data.paint != "")
				{
					float valueOrDefault = data.paintRadius.GetValueOrDefault(radius);
					float border = data.paintBorder ?? 5f;
					Terrain.Paint(hm, terrain, pos, data.paint, valueOrDefault, border);
				}
			});
		}
	}
	[HarmonyPatch(typeof(ZoneSystem), "GenerateLocationsTimeSliced", new Type[]
	{
		typeof(ZoneLocation),
		typeof(Stopwatch),
		typeof(ZPackage)
	})]
	[HarmonyPatch(/*Could not decode attribute arguments.*/)]
	public class ScaleLocationHeightRequirement
	{
		private static float ScaleHeight(float height, Biome biome)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			if (!Configuration.ScaleLocationAltitudeRequirement)
			{
				return height;
			}
			if (!BiomeManager.TryGetData(biome, out BiomeData data))
			{
				return height;
			}
			height *= data.altitudeMultiplier;
			height += data.altitudeDelta;
			if (height < 0f)
			{
				height *= data.waterDepthMultiplier;
			}
			return height;
		}

		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> TranspileMoveNext(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0002: 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_0035: Expected O, but got Unknown
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Expected O, but got Unknown
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Expected O, but got Unknown
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Expected O, but got Unknown
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Expected O, but got Unknown
			//IL_0126: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Expected O, but got Unknown
			return new CodeMatcher(instructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Ldfld, (object)AccessTools.Field(typeof(ZoneLocation), "m_minAltitude"), (string)null)
			}).Advance(1).InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
			{
				new CodeInstruction(OpCodes.Ldloc_S, (object)9)
			})
				.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
				{
					new CodeInstruction(OpCodes.Call, Transpilers.EmitDelegate<Func<float, Biome, float>>((Func<float, Biome, float>)ScaleHeight).operand)
				})
				.MatchForward(true, (CodeMatch[])(object)new CodeMatch[1]
				{
					new CodeMatch((OpCode?)OpCodes.Stfld, (object)AccessTools.Field(typeof(ZoneLocation), "m_maxAltitude"), (string)null)
				})
				.Advance(1)
				.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
				{
					new CodeInstruction(OpCodes.Ldloc_S, (object)9)
				})
				.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
				{
					new CodeInstruction(OpCodes.Call, Transpilers.EmitDelegate<Func<float, Biome, float>>((Func<float, Biome, float>)ScaleHeight).operand)
				})
				.InstructionEnumeration();
		}
	}
	[HarmonyPatch(typeof(ZoneSystem), "CreateLocalZones")]
	public class CreateLocalZones
	{
		public static bool LocationsPregenerated;

		private static bool Postfix(bool result, ZoneSystem __instance)
		{
			//IL_0026: 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_005d: Unknown result type (might be due to invalid IL or missing references)
			if (result)
			{
				return result;
			}
			if (LocationsPregenerated)
			{
				return result;
			}
			foreach (KeyValuePair<Vector2i, LocationInstance> locationInstance in __instance.m_locationInstances)
			{
				ZoneLocation location = locationInstance.Value.m_location;
				if (location != null && LocationExtra.TryGetData(location, out LocationYaml data) && data.pregenerate)
				{
					if (__instance.PokeLocalZone(locationInstance.Key))
					{
						return true;
					}
					if (!__instance.IsZoneGenerated(locationInstance.Key))
					{
						return false;
					}
				}
			}
			LocationsPregenerated = true;
			return result;
		}
	}
	[HarmonyPatch(typeof(ZoneSystem), "HaveLocationInRange")]
	public class HaveLocationInRange
	{
		private static bool Prefix(ref bool __result, ZoneSystem __instance, string prefabName, string group, Vector3 p, float radius)
		{
			//IL_001e: 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)
			if (LocationExtra.IsVirtualGroupId(group))
			{
				List<Tuple<string, float>> distanceRules = LocationExtra.GetDistanceRules(group);
				__result = InRange(__instance, p, distanceRules);
			}
			else
			{
				__result = InRange(__instance, p, prefabName, group, radius);
			}
			return false;
		}

		private static List<Tuple<string, float>> ParseLegacyRules(string prefabName, string group, float radius)
		{
			List<Tuple<string, float>> list = new List<Tuple<string, float>>(1)
			{
				new Tuple<string, float>(prefabName, radius)
			};
			if (!string.IsNullOrEmpty(group))
			{
				list.Add(new Tuple<string, float>(group, radius));
			}
			return list;
		}

		private static bool InRange(ZoneSystem zs, Vector3 p, List<Tuple<string, float>>? rules)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: 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)
			//IL_0053: 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_0059: Unknown result type (might be due to invalid IL or missing references)
			if (rules == null || rules.Count == 0)
			{
				return false;
			}
			foreach (LocationInstance value in zs.m_locationInstances.Values)
			{
				ZoneLocation location = value.m_location;
				if (location == null)
				{
					continue;
				}
				foreach (Tuple<string, float> rule in rules)
				{
					if (LocationExtra.MatchesTarget(location, rule.Item1) && Vector3.Distance(value.m_position, p) < rule.Item2)
					{
						return true;
					}
				}
			}
			return false;
		}

		private static bool InRange(ZoneSystem zs, Vector3 p, string prefabName, string group, float radius)
		{
			//IL_0015: 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_002f: 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)
			foreach (LocationInstance value in zs.m_locationInstances.Values)
			{
				ZoneLocation location = value.m_location;
				if (location != null && LocationExtra.MatchesTarget(location, prefabName, group) && Vector3.Distance(value.m_position, p) < radius)
				{
					return true;
				}
			}
			return false;
		}
	}
	[HarmonyPatch(typeof(Minimap))]
	public class MinimapIcon
	{
		private static readonly Dictionary<PinData, float> IconSizes = new Dictionary<PinData, float>();

		public static void Clear()
		{
			Minimap instance = Minimap.instance;
			if (!Object.op_Implicit((Object)(object)instance))
			{
				return;
			}
			foreach (KeyValuePair<Vector3, PinData> locationPin in instance.m_locationPins)
			{
				instance.RemovePin(locationPin.Value);
			}
			instance.m_locationPins.Clear();
			IconSizes.Clear();
		}

		[HarmonyPatch("GetLocationIcon")]
		[HarmonyPostfix]
		private static Sprite NewLocationIcons(Sprite result, string name)
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)result != (Object)null)
			{
				return result;
			}
			name = Parse.Split(name)[0];
			if (Enum.TryParse<PinType>(name, ignoreCase: true, out PinType result2))
			{
				return Minimap.instance.GetSprite(result2);
			}
			int stableHashCode = StringExtensionMethods.GetStableHashCode(name);
			if (ObjectDB.instance.m_itemByHash.TryGetValue(stableHashCode, out var value))
			{
				ItemDrop component = value.GetComponent<ItemDrop>();
				if (component == null)
				{
					return null;
				}
				ItemData itemData = component.m_itemData;
				if (itemData == null)
				{
					return null;
				}
				return itemData.GetIcon();
			}
			StatusEffect statusEffect = ObjectDB.instance.GetStatusEffect(stableHashCode);
			if (Object.op_Implicit((Object)(object)statusEffect))
			{
				return statusEffect.m_icon;
			}
			return null;
		}

		[HarmonyPatch("UpdateLocationPins")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> IconSizeSetup(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0002: 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
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Expected O, but got Unknown
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Expected O, but got Unknown
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Expected O, but got Unknown
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: Expected O, but got Unknown
			return new CodeMatcher(instructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Call, (object)AccessTools.Method(typeof(Minimap), "RemovePin", new Type[1] { typeof(PinData) }, (Type[])null), (string)null)
			}).Set(OpCodes.Call, Transpilers.EmitDelegate<Action<Minimap, PinData>>((Action<Minimap, PinData>)RemovePin).operand).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Stfld, (object)AccessTools.Field(typeof(PinData), "m_doubleSize"), (string)null)
			})
				.Advance(1)
				.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
				{
					new CodeInstruction(OpCodes.Ldloc_S, (object)5)
				})
				.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
				{
					new CodeInstruction(OpCodes.Ldloc_S, (object)7)
				})
				.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
				{
					new CodeInstruction(OpCodes.Call, Transpilers.EmitDelegate<Action<KeyValuePair<Vector3, string>, PinData>>((Action<KeyValuePair<Vector3, string>, PinData>)AddPin).operand)
				})
				.InstructionEnumeration();
		}

		private static void RemovePin(Minimap mm, PinData pin)
		{
			IconSizes.Remove(pin);
			mm.RemovePin(pin);
		}

		private static void AddPin(KeyValuePair<Vector3, string> kvp, PinData pin)
		{
			string[] array = Parse.Split(kvp.Value);
			if (array.Length < 2)
			{
				return;
			}
			float num = Parse.Float(array[1]);
			if (!(num <= 0f))
			{
				if (num >= 5f)
				{
					pin.m_worldSize = num;
				}
				else
				{
					IconSizes.Add(pin, num);
				}
				pin.m_animate = array.Length > 2;
			}
		}

		[HarmonyPatch("Awake")]
		[HarmonyPostfix]
		private static void ClearSizes()
		{
			IconSizes.Clear();
		}

		[HarmonyPatch("UpdatePins")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> ApplyIconSize(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0002: 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_002b: Expected O, but got Unknown
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Expected O, but got Unknown
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Expected O, but got Unknown
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Expected O, but got Unknown
			return new CodeMatcher(instructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Ldc_R4, (object)2f, (string)null)
			}).SetAndAdvance(OpCodes.Ldloc_S, (object)6).InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
			{
				new CodeInstruction(OpCodes.Call, Transpilers.EmitDelegate<Func<PinData, float>>((Func<PinData, float>)GetIconSize).operand)
			})
				.MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
				{
					new CodeMatch((OpCode?)OpCodes.Ldc_R4, (object)2f, (string)null)
				})
				.SetAndAdvance(OpCodes.Ldloc_S, (object)6)
				.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
				{
					new CodeInstruction(OpCodes.Call, Transpilers.EmitDelegate<Func<PinData, float>>((Func<PinData, float>)GetIconSize).operand)
				})
				.InstructionEnumeration();
		}

		private static float GetIconSize(PinData pin)
		{
			if (!IconSizes.TryGetValue(pin, out var value))
			{
				return 2f;
			}
			return 2f * value;
		}
	}
	public class Spawn
	{
		public static bool IgnoreHealth;

		public static void Blueprint(string name, Vector3 pos, Quaternion rot, Vector3 scale, int seed, Func<DataEntry?, string, DataEntry?> dataOverride, Func<string, string> prefabOverride, List<GameObject>? spawned)
		{
			//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_000d: Unknown result type (might be due to invalid IL or missing references)
			if (BlueprintManager.TryGet(name, out Blueprint bp))
			{
				Blueprint(bp, pos, rot, scale, seed, dataOverride, prefabOverride, spawned);
			}
		}

		public static void Blueprint(Blueprint bp, Vector3 pos, Quaternion rot, Vector3 scale, int seed, Func<DataEntry?, string, DataEntry?> dataOverride, Func<string, string> prefabOverride, List<GameObject>? spawned)
		{
			//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_0033: Unknown result type (might be due to invalid IL or missing references)
			foreach (BlueprintObject @object in bp.Objects)
			{
				if (!(@object.Chance < 1f) || !(Random.value > @object.Chance))
				{
					BPO(@object, pos, rot, scale, seed, dataOverride, prefabOverride, spawned);
				}
			}
		}

		private static void SetData(GameObject prefab, Vector3 position, Quaternion rotation, Vector3 scale, int seed, DataEntry? data = null)
		{
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			ZDO val = DataHelper.Init(prefab, position, rotation, scale, data);
			if (val != null)
			{
				val.RemoveLong(ZDOVars.s_creator);
			}
			if (IgnoreHealth && val != null)
			{
				val.RemoveFloat(ZDOVars.s_health);
			}
			if (((Object)prefab).name == "LocationProxy" && val != null)
			{
				val.Set(ZDOVars.s_seed, seed, false);
			}
		}

		public static void BPO(BlueprintObject obj, Vector3 pos, Quaternion rot, Vector3 scale, int seed, Func<DataEntry?, string, DataEntry?> dataOverride, Func<string, string> prefabOverride, List<GameObject>? spawned)
		{
			//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)
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = SharedBPO(obj, pos, rot, scale, seed, dataOverride, prefabOverride, spawned);
			DungeonGenerator val2 = default(DungeonGenerator);
			if ((Object)(object)val != (Object)null && val.TryGetComponent<DungeonGenerator>(ref val2))
			{
				val2.Generate((SpawnMode)(ZNetView.m_ghostInit ? 2 : 0));
			}
		}

		public static void BPO(BlueprintObject obj, Vector3 pos, Quaternion rot, Vector3 scale, Func<DataEntry?, string, DataEntry?> dataOverride, Func<string, string> prefabOverride, List<GameObject>? spawned)
		{
			//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)
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			BPO(obj, pos, rot, scale, 0, dataOverride, prefabOverride, spawned);
		}

		public static GameObject? BPO(BlueprintObject obj, int seed, Func<DataEntry?, string, DataEntry?> dataOverride, Func<string, string> prefabOverride, List<GameObject>? spawned)
		{
			//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_000b: Unknown result type (might be due to invalid IL or missing references)
			return SharedBPO(obj, Vector3.zero, Quaternion.identity, Vector3.one, seed, dataOverride, prefabOverride, spawned);
		}

		private static GameObject? SharedBPO(BlueprintObject obj, Vector3 pos, Quaternion rot, Vector3 scale, int seed, Func<DataEntry?, string, DataEntry?> dataOverride, Func<string, string> prefabOverride, List<GameObject>? spawned)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0053: 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_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_0061: 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_0021: 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_009a: 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_003d: 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_0137: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: 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)
			//IL_0144: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: 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)
			pos += rot * obj.Pos;
			if (obj.SnapToGround)
			{
				float y = default(float);
				if (ZoneSystem.instance.GetGroundHeight(pos, ref y))
				{
					pos.y = y;
				}
				else
				{
					pos.y = WorldGenerator.instance.GetHeight(pos.x, pos.z);
				}
			}
			rot *= obj.Rot;
			Vector3 scale2 = scale;
			if (obj.Scale.HasValue)
			{
				scale2.x *= obj.Scale.Value.x;
				scale2.y *= obj.Scale.Value.y;
				scale2.z *= obj.Scale.Value.z;
			}
			string text = prefabOverride(obj.Prefab);
			if (text == "")
			{
				return null;
			}
			GameObject prefab = ZNetScene.instance.GetPrefab(text);
			if (!Object.op_Implicit((Object)(object)prefab))
			{
				if (BlueprintManager.TryGet(text, out Blueprint bp))
				{
					Blueprint(bp, pos, rot, scale2, seed, dataOverride, prefabOverride, spawned);
					return null;
				}
				Log.Warning("Blueprint / object prefab " + text + " not found!");
				return null;
			}
			DataEntry data = dataOverride(obj.Data, text);
			SetData(prefab, pos, rot, scale2, seed, data);
			GameObject val = Object.Instantiate<GameObject>(prefab, pos, rot);
			DataManager.CleanGhostInit(val);
			if (ZNetView.m_ghostInit)
			{
				if (spawned != null)
				{
					spawned.Add(val);
				}
				else
				{
					Object.Destroy((Object)(object)val);
				}
			}
			return val;
		}

		private static List<Tuple<float, string>> ParseSwapItems(IEnumerable<string> items, float weight)
		{
			return (from s in items
				select Parse.Split(s, removeEmpty: false, ':') into s
				select Tuple.Create(Parse.Float(s, 1, 1f) * weight, s[0])).ToList();
		}

		public static Dictionary<string, List<Tuple<float, string>>> LoadSwaps(string[] objectSwap)
		{
			Dictionary<string, List<Tuple<float, string>>> dictionary = new Dictionary<string, List<Tuple<float, string>>>();
			foreach (List<string> item in (from s in objectSwap
				select DataManager.ToList(s, removeEmpty: false) into l
				where l.Count > 0
				select l).ToList())
			{
				string[] array = Parse.Split(item[0], removeEmpty: true, ':');
				List<string> list = DataHelper.ResolvePrefabs(array[0]);
				List<Tuple<float, string>> collection = ParseSwapItems(weight: Parse.Float(array, 1, 1f), items: item.Skip(1));
				foreach (string item2 in list)
				{
					if (!dictionary.ContainsKey(item2))
					{
						dictionary[item2] = new List<Tuple<float, string>>();
					}
					dictionary[item2].AddRange(collection);
				}
			}
			foreach (KeyValuePair<string, List<Tuple<float, string>>> item3 in dictionary)
			{
				float num = item3.Value.Sum((Tuple<float, string> t) => t.Item1);
				for (int num2 = 0; num2 < item3.Value.Count; num2++)
				{
					item3.Value[num2] = Tuple.Create(item3.Value[num2].Item1 / num, item3.Value[num2].Item2);
				}
				foreach (Tuple<float, string> item4 in item3.Value)
				{
					if (item4.Item2 != "")
					{
						BlueprintManager.Load(item4.Item2);
					}
				}
			}
			return dictionary;
		}

		private static List<Tuple<float, DataEntry?>> ParseDataItems(IEnumerable<string> items, float weight, string fileName)
		{
			return (from s in items
				select Parse.Split(s, removeEmpty: false, ':') into s
				select Tuple.Create(Parse.Float(s, 1, 1f) * weight, DataHelper.Get(s[0], fileName))).ToList();
		}

		public static Dictionary<string, List<Tuple<float, DataEntry?>>> LoadData(string[] objectData, string fileName)
		{
			Dictionary<string, List<Tuple<float, DataEntry>>> dictionary = new Dictionary<string, List<Tuple<float, DataEntry>>>();
			List<List<string>> list = (from s in objectData
				select DataManager.ToList(s, removeEmpty: false) into l
				where l.Count > 0
				select l).ToList();
			_ = ZNetScene.instance;
			foreach (List<string> item in list)
			{
				string[] array = Parse.Split(item[0], removeEmpty: true, ':');
				List<string> list2 = DataHelper.ResolvePrefabs(array[0]);
				_ = array[0];
				List<Tuple<float, DataEntry>> collection = ParseDataItems(weight: Parse.Float(array, 1, 1f), items: item.Skip(1), fileName: fileName);
				foreach (string item2 in list2)
				{
					if (!dictionary.ContainsKey(item2))
					{
						dictionary[item2] = new List<Tuple<float, DataEntry>>();
					}
					dictionary[item2].AddRange(collection);
				}
			}
			foreach (KeyValuePair<string, List<Tuple<float, DataEntry>>> item3 in dictionary)
			{
				float num = item3.Value.Sum((Tuple<float, DataEntry> t) => t.Item1);
				for (int num2 = 0; num2 < item3.Value.Count; num2++)
				{
					item3.Value[num2] = Tuple.Create(item3.Value[num2].Item1 / num, item3.Value[num2].Item2);
				}
			}
			return dictionary;
		}

		public static string RandomizeSwap(List<Tuple<float, string>> swaps)
		{
			if (swaps.Count == 0)
			{
				return "";
			}
			if (swaps.Count == 1)
			{
				return swaps[0].Item2;
			}
			float num = Random.value;
			foreach (Tuple<float, string> swap in swaps)
			{
				num -= swap.Item1;
				if (num <= 0f)
				{
					return swap.Item2;
				}
			}
			return swaps[swaps.Count - 1].Item2;
		}

		public static DataEntry? RandomizeData(List<Tuple<float, DataEntry?>> swaps)
		{
			if (swaps.Count == 0)
			{
				return null;
			}
			if (swaps.Count == 1)
			{
				return swaps[0].Item2;
			}
			float num = Random.value;
			foreach (Tuple<float, DataEntry> swap in swaps)
			{
				num -= swap.Item1;
				if (num <= 0f)
				{
					return swap.Item2;
				}
			}
			return swaps[swaps.Count - 1].Item2;
		}

		public static DataEntry? GetData(Dictionary<string, List<Tuple<float, DataEntry?>>> data, string prefab)
		{
			DataEntry dataEntry = null;
			if (data.TryGetValue("all", out List<Tuple<float, DataEntry>> value))
			{
				dataEntry = DataHelper.Merge(dataEntry, RandomizeData(value));
			}
			foreach (string defaultComponent in DataLoading.GetDefaultComponents(prefab))
			{
				if (data.TryGetValue(defaultComponent, out value))
				{
					dataEntry = DataHelper.Merge(dataEntry, RandomizeData(value));
				}
			}
			if (data.TryGetValue(prefab, out value))
			{
				dataEntry = DataHelper.Merge(dataEntry, RandomizeData(value));
			}
			return dataEntry;
		}
	}
	public class TerrainNode
	{
		public int Index;

		public float Distance;
	}
	public class Terrain
	{
		public static Dictionary<string, Color> Paints = new Dictionary<string, Color>
		{
			{
				"grass",
				Color.black
			},
			{
				"patches",
				new Color(0f, 0.75f, 0f)
			},
			{
				"grass_dark",
				new Color(0.6f, 0.5f, 0f)
			},
			{
				"dirt",
				Color.red
			},
			{
				"cultivated",
				Color.green
			},
			{
				"paved",
				Color.blue
			},
			{
				"paved_moss",
				new Color(0f, 0f, 0.5f)
			},
			{
				"paved_dirt",
				new Color(1f, 0f, 0.5f)
			},
			{
				"paved_dark",
				new Color(0f, 1f, 0.5f)
			}
		};

		private static readonly int TerrainHash = StringExtensionMethods.GetStableHashCode("_TerrainCompiler");

		public static Color ParsePaint(string paint)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			return ParsePaintColor(paint);
		}

		private static Color ParsePaintColor(string paint)
		{
			//IL_0051: 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)
			string[] array = Parse.Split(paint);
			if (array.Length < 3 && Paints.TryGetValue(paint, out var value))
			{
				return value;
			}
			return new Color(Parse.Float(array, 0), Parse.Float(array, 1), Parse.Float(array, 2), Parse.Float(array, 3, 1f));
		}

		private static float CalculateSmooth(float smooth, float distance)
		{
			if (!(1f - distance >= smooth))
			{
				return (1f - distance) / smooth;
			}
			return 1f;
		}

		private static void GetHeightNodes(List<TerrainNode> nodes, Heightmap hm, Vector3 centerPos, float radius)
		{
			//IL_001d: 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_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)
			if (radius == 0f)
			{
				return;
			}
			int num = hm.m_width + 1;
			for (int i = 1; i < num - 1; i++)
			{
				for (int j = 1; j < num - 1; j++)
				{
					Vector3 val = VertexToWorld(hm, i, j);
					float num2 = Utils.DistanceXZ(centerPos, val);
					if (!(num2 > radius))
					{
						nodes.Add(new TerrainNode
						{
							Index = j * num + i,
							Distance = num2 / radius
						});
					}
				}
			}
		}

		private static void GetPaintNodes(List<TerrainNode> nodes, Heightmap hm, Vector3 centerPos, float radius)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: 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)
			int width = hm.m_width;
			for (int i = 0; i < width; i++)
			{
				for (int j = 0; j < width; j++)
				{
					Vector3 val = VertexToWorld(hm, i, j);
					val.x += 0.5f;
					val.z += 0.5f;
					float num = Utils.DistanceXZ(centerPos, val);
					if (!(num > radius))
					{
						nodes.Add(new TerrainNode
						{
							Index = j * width + i,
							Distance = num / radius
						});
					}
				}
			}
		}

		private static Vector3 VertexToWorld(Heightmap hmap, int x, int y)
		{
			//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_0052: Unknown result type (might be due to invalid IL or missing references)
			Vector3 position = ((Component)hmap).transform.position;
			position.x += ((float)(x - hmap.m_width / 2) + 0.5f) * hmap.m_scale;
			position.z += ((float)(y - hmap.m_width / 2) + 0.5f) * hmap.m_scale;
			return position;
		}

		public static void ChangeTerrain(Vector3 pos, Action<Heightmap, TerrainFakeData> action)
		{
			//IL_0000: 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_002f: Unknown result type (might be due to invalid IL or missing references)
			Heightmap val = Heightmap.FindHeightmap(pos);
			if (!((Object)(object)val == (Object)null))
			{
				ZDO zdo = FindCompiler(val, pos);
				TerrainFakeData terrainFakeData = new TerrainFakeData(val, zdo);
				action(val, terrainFakeData);
				terrainFakeData.Save();
				TerrainComp obj = TerrainComp.FindTerrainCompiler(pos);
				if (obj != null)
				{
					obj.Load();
				}
				val.Poke(false);
			}
		}

		private static ZDO FindCompiler(Heightmap hm, Vector3 pos)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//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_000c: Unknown result type (might be due to invalid IL or missing references)
			Vector2i zone = ZoneSystem.GetZone(pos);
			int num = ZDOMan.instance.SectorToIndex(zone);
			if (num < 0 || num >= ZDOMan.instance.m_objectsBySector.Length)
			{
				return hm.GetAndCreateTerrainCompiler().m_nview.GetZDO();
			}
			ZDO val = ZDOMan.instance.m_objectsBySector[num]?.FirstOrDefault((Func<ZDO, bool>)((ZDO zdo) => zdo.GetPrefab() == TerrainHash));
			if (val == null)
			{
				return hm.GetAndCreateTerrainCompiler().m_nview.GetZDO();
			}
			return val;
		}

		public static void Level(Heightmap hm, TerrainFakeData data, Vector3 pos, float radius, float border)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: 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)
			radius += border;
			float smooth;
			if (radius != 0f)
			{
				smooth = border / radius;
				List<TerrainNode> nodes = new List<TerrainNode>();
				GetHeightNodes(nodes, hm, pos, radius);
				DoOperation(nodes, pos, radius, action);
			}
			void action(int index, float distance)
			{
				float num = CalculateSmooth(smooth, distance);
				data.SetHeight(index, num * (pos.y - hm.m_buildData.m_baseHeights[index]));
			}
		}

		public static void Paint(Heightmap hm, TerrainFakeData data, Vector3 pos, string paint, float radius, float border)
		{
			//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_003c: 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)
			radius += border;
			float smooth;
			Color color;
			if (radius != 0f)
			{
				smooth = border / radius;
				List<TerrainNode> nodes = new List<TerrainNode>();
				color = ParsePaint(paint);
				GetPaintNodes(nodes, hm, pos, radius);
				DoOperation(nodes, pos, radius, action);
			}
			void action(int index, float distance)
			{
				//IL_0015: Unknown result type (might be due to invalid IL or missing references)
				float multiplier = CalculateSmooth(smooth, distance);
				data.LerpColor(index, color, multiplier);
			}
		}

		private static void DoOperation(List<TerrainNode> nodes, Vector3 pos, float radius, Action<int, float> action)
		{
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			foreach (TerrainNode node in nodes)
			{
				action(node.Index, node.Distance);
			}
			ClutterSystem instance = ClutterSystem.instance;
			if (instance != null)
			{
				instance.ResetGrass(pos, radius);
			}
		}
	}
	public class TerrainFakeData
	{
		private struct HeightNode
		{
			public float LevelDelta;

			public float SmoothDelta;

			public HeightNode()
			{
				LevelDelta = 0f;
				SmoothDelta = 0f;
				LevelDelta = 0f;
				SmoothDelta = 0f;
			}
		}

		private readonly ZDO Zdo;

		private int Operations;

		private Vector3 LastOpPoint = Vector3.zero;

		private float LastOpRadius;

		private HeightNode[] HeightNodes = Array.Empty<HeightNode>();

		private Color[] PaintNodes = Array.Empty<Color>();

		public TerrainFakeData(Heightmap hm, ZDO zdo)
		{
			//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_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			int num = hm.m_width + 1;
			HeightNodes = new HeightNode[num * num];
			PaintNodes = (Color[])(object)new Color[hm.m_width * hm.m_width];
			for (int i = 0; i < PaintNodes.Length; i++)
			{
				PaintNodes[i] = Heightmap.m_paintMaskNothing;
			}
			Zdo = zdo;
			Load(zdo.GetByteArray(ZDOVars.s_TCData, (byte[])null));
		}

		public void SetHeight(int index, float value)
		{
			HeightNodes[index].LevelDelta = value;
			HeightNodes[index].SmoothDelta = 0f;
		}

		public void LerpColor(int index, Color color, float multiplier)
		{
			//IL_0007: 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: 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_0028: 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)
			Color val = Color.Lerp(PaintNodes[index], color, multiplier);
			val.a = color.a;
			PaintNodes[index] = val;
		}

		private void Load(byte[]? data)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Expected O, but got Unknown
			//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_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			if (data == null)
			{
				return;
			}
			ZPackage val = new ZPackage(Utils.Decompress(data));
			val.ReadInt();
			Operations = val.ReadInt();
			LastOpPoint = val.ReadVector3();
			LastOpRadius = val.ReadSingle();
			int num = val.ReadInt();
			HeightNodes = new HeightNode[num];
			for (int i = 0; i < num; i++)
			{
				if (val.ReadBool())
				{
					float levelDelta = val.ReadSingle();
					float smoothDelta = val.ReadSingle();
					HeightNodes[i] = new HeightNode
					{
						LevelDelta = levelDelta,
						SmoothDelta = smoothDelta
					};
				}
			}
			int num2 = val.ReadInt();
			PaintNodes = (Color[])(object)new Color[num2];
			for (int j = 0; j < num2; j++)
			{
				PaintNodes[j] = Heightmap.m_paintMaskNothing;
				if (val.ReadBool())
				{
					float num3 = val.ReadSingle();
					float num4 = val.ReadSingle();
					float num5 = val.ReadSingle();
					float num6 = val.ReadSingle();
					PaintNodes[j] = new Color(num3, num4, num5, num6);
				}
			}
		}

		public void Save()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Expected O, but got Unknown
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: 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_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: 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_0100: 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)
			ZPackage val = new ZPackage();
			val.Write(1);
			val.Write(Operations);
			val.Write(LastOpPoint);
			val.Write(LastOpRadius);
			val.Write(HeightNodes.Length);
			HeightNode[] heightNodes = HeightNodes;
			for (int i = 0; i < heightNodes.Length; i++)
			{
				HeightNode heightNode = heightNodes[i];
				bool flag = heightNode.LevelDelta != 0f || heightNode.SmoothDelta != 0f;
				val.Write(flag);
				if (flag)
				{
					val.Write(heightNode.LevelDelta);
					val.Write(heightNode.SmoothDelta);
				}
			}
			val.Write(PaintNodes.Length);
			Color[] paintNodes = PaintNodes;
			foreach (Color val2 in paintNodes)
			{
				bool flag2 = val2 != Heightmap.m_paintMaskNothing;
				val.Write(flag2);
				if (flag2)
				{
					val.Write(val2.r);
					val.Write(val2.g);
					val.Write(val2.b);
					val.Write(val2.a);
				}
			}
			byte[] array = Utils.Compress(val.GetArray());
			Zdo.Set(ZDOVars.s_TCData, array);
		}
	}
	public class VegetationYaml
	{
		public string prefab = "";

		public bool enabled = true;

		public float min = 1f;

		public float max = 1f;

		[DefaultValue(false)]
		public bool forcePlacement;

		[DefaultValue("1")]
		public string scaleMin = "1";

		[DefaultValue("1")]
		public string scaleMax = "1";

		[DefaultValue(true)]
		public bool scaleUniform = true;

		[DefaultValue(0f)]
		public float randTilt;

		[DefaultValue(0f)]
		public float chanceToUseGroundTilt;

		[DefaultValue("")]
		public string biome = "";

		[DefaultValue("")]
		public string biomeArea = "";

		[DefaultValue(true)]
		public bool blockCheck = true;

		[DefaultValue(0f)]
		public float minAltitude;

		[DefaultValue(10000f)]
		public float maxAltitude = 10000f;

		[DefaultValue(0f)]
		public float minOceanDepth;

		[DefaultValue(0f)]
		public float maxOceanDepth;

		[DefaultValue(0f)]
		public float minVegetation;

		[DefaultValue(0f)]
		public float maxVegetation;

		[DefaultValue(0f)]
		public float minTilt;

		[DefaultValue(90f)]
		public float maxTilt = 90f;

		[DefaultValue(0f)]
		public float terrainDeltaRadius;

		[DefaultValue(0f)]
		public float minTerrainDelta;

		[DefaultValue(10f)]
		public float maxTerrainDelta = 10f;

		[DefaultValue(false)]
		public bool snapToWater;

		[DefaultValue(false)]
		public bool snapToStaticSolid;

		[DefaultValue(0f)]
		public float groundOffset;

		[DefaultValue(1)]
		public int groupSizeMin = 1;

		[DefaultValue(1)]
		public int groupSizeMax = 1;

		[DefaultValue(0f)]
		public float groupRadius;

		[DefaultValue(false)]
		public bool inForest;

		[DefaultValue(0f)]
		public float forestTresholdMin;

		[DefaultValue(1f)]
		public float forestTresholdMax = 1f;

		[DefaultValue(false)]
		public bool clearArea;

		[DefaultValue(0f)]
		public float clearRadius;

		[DefaultValue("")]
		public string requiredGlobalKey = "";

		[DefaultValue("")]
		public string forbiddenGlobalKey = "";

		[DefaultValue("")]
		public string data = "";

		[DefaultValue(false)]
		public bool surroundCheckVegetation;

		[DefaultValue(20f)]
		public float surroundCheckDistance = 20f;

		[DefaultValue(2)]
		public int surroundCheckLayers = 2;

		[DefaultValue(0f)]
		public float surroundBetterThanAverage;

		[DefaultValue(0f)]
		public float minDistance;

		[DefaultValue(0f)]
		public float maxDistance;

		[DefaultValue(0f)]
		public float centerX;

		[DefaultValue(0f)]
		public float centerY;

		[DefaultValue("")]
		public string drops = "";
	}
	public class VegetationExtra
	{
		public List<string>? requiredGlobalKeys;

		public List<string>? forbiddenGlobalKeys;

		public DataEntry? data;

		public Range<Vector3>? scale;

		public float clearRadius;

		public bool clearArea;

		public Range<float>? distance;

		public Vector2? center;

		public bool IsDistanceOk(Vector3 pos)
		{
			//IL_000a: 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_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_002e: Unknown result type (might be due to invalid IL or missing references)
			if (distance == null)
			{
				return true;
			}
			float num = Vector3.Distance(pos, Vector2.op_Implicit((Vector2)(((??)center) ?? Vector2.op_Implicit(Vector3.zero))));
			if (distance.Max == 0f)
			{
				return distance.Min <= num;
			}
			if (distance.Min <= num)
			{
				return num <= distance.Max;
			}
			return false;
		}

		public bool IsValid()
		{
			if (requiredGlobalKeys == null && forbiddenGlobalKeys == null && data == null && scale == null && clearRadius == 0f && !clearArea && distance == null)
			{
				return center.HasValue;
			}
			return true;
		}
	}
	public class VegetationLoading
	{
		private static readonly string FileName = "expand_vegetation.yaml";

		private static readonly string FilePath = Path.Combine(Yaml.BaseDirectory, FileName);

		private static readonly string Pattern = "expand_vegetation*.yaml";

		public static readonly int HashDrop = StringExtensionMethods.GetStableHashCode("ews_drops");

		private static readonly List<VegetationYaml> ExtraVegetationYamls = new List<VegetationYaml>();

		private static List<ZoneVegetation> DefaultEntries = new List<ZoneVegetation>();

		private static HashSet<string> DefaultKeys = new HashSet<string>();

		public static void AddVegetation(VegetationYaml yaml)
		{
			ExtraVegetationYamls.Add(yaml);
		}

		public static void Initialize()
		{
			DefaultEntries.Clear();
			DefaultKeys.Clear();
			if (Helper.IsServer())
			{
				SetDefaultEntries();
			}
		}

		public static void CreateConfigs()
		{
			if (!Helper.IsClient() && Configuration.DataVegetation && !File.Exists(FilePath))
			{
				ToFile();
			}
		}

		public static void ReadConfigs()
		{
			CleanUp();
			if (!Helper.IsClient())
			{
				if (!Configuration.DataVegetation)
				{
					Apply(DefaultEntries);
				}
				else if (!File.Exists(FilePath))
				{
					ToFile();
				}
				else
				{
					Apply(FromFile());
				}
			}
		}

		public static void CleanUp()
		{
			VegetationSpawning.Extra.Clear();
			VegetationSpawning.Prefabs.Clear();
		}

		private static void Apply(List<ZoneVegetation> data)
		{
			ZoneSystem.instance.m_vegetation = DefaultEntries;
			if (!Configuration.DataVegetation)
			{
				Log.Info($"Reloading default vegetation data ({DefaultEntries.Count} entries).");
			}
			else if (data.Count == 0)
			{
				Log.Warning("Failed to load any vegetation data.");
				Log.Info($"Reloading default vegetation data ({DefaultEntries.Count} entries).");
			}
			else if (!Configuration.DataMigration || !AddMissingEntries(data))
			{
				Log.Info($"Reloading vegetation data ({data.Count} entries).");
				ZoneSystem.instance.m_vegetation = data;
				IdManager.SendVegetationIds();
			}
		}

		private static void ToFile()
		{
			List<VegetationYaml> list = DefaultEntries.Select(ToData).ToList();
			if (ExtraVegetationYamls.Count > 0)
			{
				list.AddRange(ExtraVegetationYamls);
			}
			Save(list, log: false);
		}

		private static List<ZoneVegetation> FromFile()
		{
			try
			{
				return (from veg in DataManager.ReadData<VegetationYaml, ZoneVegetation>(Pattern, FromData)
					where Object.op_Implicit((Object)(object)veg.m_prefab)
					select veg).ToList();
			}
			catch (Exception ex)
			{
				Log.Error(ex.Message);
				Log.Error(ex.StackTrace);
			}
			return new List<ZoneVegetation>();
		}

		private static void SetDefaultEntries()
		{
			ZoneSystem.instance.m_vegetation = (from veg in ZoneSystem.instance.m_vegetation
				where Object.op_Implicit((Object)(object)veg.m_prefab)
				where ZNetScene.instance.m_namedPrefabs.ContainsKey(StringExtensionMethods.GetStableHashCode(((Object)veg.m_prefab).name))
				where veg.m_enable && veg.m_max > 0f
				select veg).ToList();
			DefaultEntries = ZoneSystem.instance.m_vegetation;
			DefaultKeys = Helper.ToSet(DefaultEntries, (ZoneVegetation veg) => ((Object)veg.m_prefab).name);
		}

		private static bool AddMissingEntries(List<ZoneVegetation> entries)
		{
			HashSet<string> missingKeys = DefaultKeys.ToHashSet();
			foreach (ZoneVegetation entry in entries)
			{
				missingKeys.Remove(entry.m_name);
				if (!VegetationSpawning.Prefabs.TryGetValue(entry, out List<GameObject> prefabs))
				{
					continue;
				}
				missingKeys.RemoveWhere((string key) => prefabs.Any((GameObject prefab) => ((Object)prefab).name == key));
			}
			if (missingKeys.Count == 0)
			{
				return false;
			}
			List<VegetationYaml> list = DefaultEntries.Where((ZoneVegetation veg) => missingKeys.Contains(((Object)veg.m_prefab).name)).Select(ToData).ToList();
			Log.Warning($"Adding {list.Count} missing vegetation to the expand_vegetation.yaml file.");
			Save(list, log: true);
			return true;
		}

		private static void Save(List<VegetationYaml> data, bool log)
		{
			Dictionary<string, List<VegetationYaml>> dictionary = new Dictionary<string, List<VegetationYaml>>();
			foreach (VegetationYaml datum in data)
			{
				string modFromPrefab = AssetTracker.GetModFromPrefab(datum.prefab);
				string key = (Configuration.SplitDataPerMod ? AssetTracker.GetFileNameFromMod(modFromPrefab) : "");
				if (!dictionary.ContainsKey(key))
				{
					dictionary[key] = new List<VegetationYaml>();
				}
				dictionary[key].Add(datum);
				if (log)
				{
					Log.Warning(modFromPrefab + ": " + datum.prefab);
				}
			}
			foreach (KeyValuePair<string, List<VegetationYaml>> item in dictionary)
			{
				string path = Path.Combine(Yaml.BaseDirectory, "expand_vegetation" + item.Key + ".yaml");
				string text = (File.Exists(path) ? (File.ReadAllText(path) + "\n") : "");
				text += Yaml.Serializer().Serialize((object)item.Value);
				File.WriteAllText(path, text);
			}
		}

		public static ZoneVegetation FromData(VegetationYaml data, string fileName)
		{
			//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_007d: 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_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: 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_00cd: 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_00e8: 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_0108: 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_0126: Unknown result type (might be due to invalid IL or missing references)
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: 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_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_0158: 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_017a: Unknown result type (might be due to invalid IL or missing references)
			//IL_018b: Unknown result type (might be due to invalid IL or missing references)
			//IL_019c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_01be: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0202: Unknown result type (might be due to invalid IL or missing references)
			//IL_0213: Unknown result type (might be due to invalid IL or missing references)
			//IL_0224: Unknown result type (might be due to invalid IL or missing references)
			//IL_0235: 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_0257: Unknown result type (might be due to invalid IL or missing references)
			//IL_0268: Unknown result type (might be due to invalid IL or missing references)
			//IL_0279: Unknown result type (might be due to invalid IL or missing references)
			//IL_028a: Unknown result type (might be due to invalid IL or missing references)
			//IL_029b: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cf: Expected O, but got Unknown
			//IL_02da: 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_04ef: Unknown result type (might be due to invalid IL or missing references)
			if (data.minDistance > 0f)
			{
				data.minDistance = WorldEntry.ConvertDist(data.minDistance);
			}
			if (data.maxDistance > 0f)
			{
				data.maxDistance = WorldEntry.ConvertDist(data.maxDistance);
			}
			ZoneVegetation val = new ZoneVegetation
			{
				m_name = data.prefab,
				m_enable = data.enabled,
				m_min = data.min,
				m_max = data.max,
				m_forcePlacement = data.forcePlacement,
				m_scaleMin = Parse.Scale(data.scaleMin).x,
				m_scaleMax = Parse.Scale(data.scaleMax).x,
				m_randTilt = data.randTilt,
				m_chanceToUseGroundTilt = data.chanceToUseGroundTilt,
				m_biome = DataManager.ToBiomes(data.biome, fileName),
				m_biomeArea = DataManager.ToBiomeAreas(data.biomeArea, fileName),
				m_blockCheck = data.blockCheck,
				m_minAltitude = data.minAltitude,
				m_maxAltitude = data.maxAltitude,
				m_minOceanDepth = data.minOceanDepth,
				m_maxOceanDepth = data.maxOceanDepth,
				m_minVegetation = data.minVegetation,
				m_maxVegetation = data.maxVegetation,
				m_minTilt = data.minTilt,
				m_maxTilt = data.maxTilt,
				m_terrainDeltaRadius = data.terrainDeltaRadius,
				m_maxTerrainDelta = data.maxTerrainDelta,
				m_minTerrainDelta = data.minTerrainDelta,
				m_snapToWater = data.snapToWater,
				m_snapToStaticSolid = data.snapToStaticSolid,
				m_groundOffset = data.groundOffset,
				m_groupSizeMin = data.groupSizeMin,
				m_groupSizeMax = data.groupSizeMax,
				m_groupRadius = data.groupRadius,
				m_inForest = data.inForest,
				m_forestTresholdMin = data.forestTresholdMin,
				m_forestTresholdMax = data.forestTresholdMax,
				m_minDistanceFromCenter = data.minDistance,
				m_maxDistanceFromCenter = data.maxDistance
			};
			Range<Vector3> range = new Range<Vector3>(Parse.Scale(data.scaleMin), Parse.Scale(data.scaleMax))
			{
				Uniform = data.scaleUniform
			};
			VegetationExtra vegetationExtra = new VegetationExtra
			{
				clearRadius = data.clearRadius,
				clearArea = data.clearArea
			};
			if (Helper.IsMultiAxis(range))
			{
				vegetationExtra.scale = range;
			}
			if (data.data != "")
			{
				vegetationExtra.data = DataHelper.Get(data.data, fileName);
			}
			if (data.drops != "")
			{
				new DataEntry().Hashes = new Dictionary<int, IHashValue> { 
				{
					HashDrop,
					DataValue.Hash(data.drops)
				} };
			}
			List<GameObject> list = (from p in ((IEnumerable<string>)DataManager.ToList(data.prefab)).Select((Func<string, GameObject>)delegate(string p)
				{
					//IL_003a: Unknown result type (might be due to invalid IL or missing references)
					//IL_0040: Expected O, but got Unknown
					int stableHashCode = StringExtensionMethods.GetStableHashCode(p);
					if (ZNetScene.instance.m_namedPrefabs.TryGetValue(stableHashCode, out var value))
					{
						return value;
					}
					return BlueprintManager.Load(data.prefab) ? new GameObject(data.prefab) : ((GameObject)null);
				})
				where Object.op_Implicit((Object)(object)p)
				select p).ToList();
			if (list.Count > 0)
			{
				val.m_prefab = list[0];
			}
			if (list.Count > 1)
			{
				VegetationSpawning.Prefabs.Add(val, list);
			}
			if (val.m_enable)
			{
				if (data.requiredGlobalKey != "")
				{
					vegetationExtra.requiredGlobalKeys = DataManager.ToList(data.requiredGlobalKey);
				}
				if (data.forbiddenGlobalKey != "")
				{
					vegetationExtra.forbiddenGlobalKeys = DataManager.ToList(data.forbiddenGlobalKey);
				}
				if (data.centerX != 0f || data.centerY != 0f)
				{
					val.m_minDistanceFromCenter = 0f;
					val.m_maxDistanceFromCenter = 0f;
					vegetationExtra.center = new Vector2(WorldEntry.ConvertDist(data.centerX), WorldEntry.ConvertDist(data.centerY));
					if (data.minDistance != 0f || data.maxDistance != 0f)
					{
						vegetationExtra.distance = new Range<float>(data.minDistance, data.maxDistance);
					}
				}
			}
			if (vegetationExtra.IsValid())
			{
				VegetationSpawning.Extra.Add(val, vegetationExtra);
			}
			return val;
		}

		public static VegetationYaml ToData(ZoneVegetation veg)
		{
			//IL_008c: 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)
			return new VegetationYaml
			{
				enabled = veg.m_enable,
				prefab = ((Object)veg.m_prefab).name,
				min = veg.m_min,
				max = veg.m_max,
				forcePlacement = veg.m_forcePlacement,
				scaleMin = veg.m_scaleMin.ToString(NumberFormatInfo.InvariantInfo),
				scaleMax = veg.m_scaleMax.ToString(NumberFormatInfo.InvariantInfo),
				randTilt = veg.m_randTilt,
				chanceToUseGroundTilt = veg.m_chanceToUseGroundTilt,
				biome = DataManager.FromBiomes(veg.m_biome),
				biomeArea = DataManager.FromBiomeAreas(veg.m_biomeArea),
				blockCheck = veg.m_blockCheck,
				minAltitude = veg.m_minAltitude,
				maxAltitude = veg.m_maxAltitude,
				minOceanDepth = veg.m_minOceanDepth,
				maxOceanDepth = veg.m_maxOceanDepth,
				minVegetation = veg.m_minVegetation,
				maxVegetation = veg.m_maxVegetation,
				minTilt = veg.m_minTilt,
				maxTilt = veg.m_maxTilt,
				terrainDeltaRadius = veg.m_terrainDeltaRadius,
				maxTerrainDelta = veg.m_maxTerrainDelta,
				minTerrainDelta = veg.m_minTerrainDelta,
				snapToWater = veg.m_snapToWater,
				snapToStaticSolid = veg.m_snapToStaticSolid,
				groundOffset = veg.m_groundOffset,
				groupSizeMin = veg.m_groupSizeMin,
				groupSizeMax = veg.m_groupSizeMax,
				groupRadius = veg.m_groupRadius,
				inForest = veg.m_inForest,
				forestTresholdMin = veg.m_forestTresholdMin,
				forestTresholdMax = veg.m_forestTresholdMax,
				surroundCheckVegetation = veg.m_surroundCheckVegetation,
				surroundCheckDistance = veg.m_surroundCheckDistance,
				surroundCheckLayers = veg.m_surroundCheckLayers,
				surroundBetterThanAverage = veg.m_surroundBetterThanAverage,
				maxDistance = veg.m_maxDistanceFromCenter / 10000f,
				minDistance = veg.m_minDistanceFromCenter / 10000f
			};
		}

		public static void SetupWatcher()
		{
			Yaml.SetupWatcher(Pattern, ReadConfigs);
		}
	}
	[HarmonyPatch(typeof(ZoneSystem), "PlaceVegetation")]
	public class VegetationSpawning
	{
		public static Dictionary<ZoneVegetation, VegetationExtra> Extra = new Dictionary<ZoneVegetation, VegetationExtra>();

		public static Dictionary<ZoneVegetation, List<GameObject>> Prefabs = new Dictionary<ZoneVegetation, List<GameObject>>();

		private static ZoneVegetation CurrentVegetation = new ZoneVegetation();

		private static SpawnMode Mode = (SpawnMode)1;

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

		private static void Prefix(SpawnMode mode, List<GameObject> spawnedObjects)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			Mode = mode;
			SpawnedObjects = spawnedObjects;
		}

		private static ZoneVegetation SetVeg(ZoneVegetation veg)
		{
			CurrentVegetation = veg;
			return veg;
		}

		private static DataEntry? DataOverride(DataEntry? data, string prefab)
		{
			if (!Extra.TryGetValue(CurrentVegetation, out VegetationExtra value))
			{
				return data;
			}
			return DataHelper.Merge(value.data, data);
		}

		private static DataEntry? DataOverride()
		{
			if (!Extra.TryGetValue(CurrentVegetation, out VegetationExtra value))
			{
				return null;
			}
			return value.data;
		}

		private static string PrefabOverride(string prefab)
		{
			return prefab;
		}

		private static GameObject Instantiate(GameObject prefab, Vector3 pos, Quaternion rot, List<ClearArea> clearAreas)
		{
			//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_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Expected O, but got Unknown
			if (Extra.TryGetValue(CurrentVegetation, out VegetationExtra value) && value.clearArea)
			{
				clearAreas.Add(new ClearArea(pos, value.clearRadius));
			}
			if (Prefabs.TryGetValue(CurrentVegetation, out List<GameObject> value2))
			{
				prefab = value2[Random.Range(0, value2.Count)];
			}
			return DataManager.Instantiate(prefab, pos, rot, DataOverride());
		}

		private static GameObject InstantiateBlueprint(GameObject prefab, Vector3 position, Quaternion rotation, List<ClearArea> clearAreas)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Invalid comparison between Unknown and I4
			//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_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: 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_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Invalid comparison between Unknown and I4
			//IL_0092: 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)
			if ((int)Mode == 2)
			{
				ZNetView.StartGhostInit();
			}
			Vector3 scale = Vector3.one;
			if (Extra.TryGetValue(CurrentVegetation, out VegetationExtra value) && value.scale != null)
			{
				scale = Helper.RandomValue(value.scale);
			}
			Spawn.Blueprint(((Object)prefab).name, position, rotation, scale, 0, DataOverride, PrefabOverride, SpawnedObjects);
			if ((int)Mode == 2)
			{
				ZNetView.FinishGhostInit();
			}
			return Object.Instantiate<GameObject>(prefab, position, rotation);
		}

		private static void SetScale(ZNetView view, Vector3 scale)
		{
			//IL_0029: 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_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: 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_0026: Unknown result type (might be due to invalid IL or missing references)
			if (Extra.TryGetValue(CurrentVegetation, out VegetationExtra value) && value.scale != null)
			{
				scale = Helper.RandomValue(value.scale);
			}
			view.SetLocalScale(scale);
			if (Mathf.Approximately(scale.x, scale.y) && Mathf.Approximately(scale.x, scale.z))
			{
				view.GetZDO().RemoveVec3(ZDOVars.s_scaleHash);
			}
			else
			{
				view.GetZDO().RemoveFloat(ZDOVars.s_scaleScalarHash);
			}
		}

		public static bool InsideClearArea(List<ClearArea> areas, Vector3 point)
		{
			//IL_001a: 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_003e: Unknown result type (might be due to invalid IL or missing references)
			float num = 0f;
			if (Extra.TryGetValue(CurrentVegetation, out VegetationExtra value))
			{
				if (!value.IsDistanceOk(point))
				{
					return true;
				}
				num = value.clearRadius;
			}
			foreach (ClearArea area in areas)
			{
				if (Utils.DistanceXZ(point, area.m_center) < area.m_radius + num)
				{
					return true;
				}
			}
			return false;
		}

		private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0049: 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_007c: Expected O, but got Unknown
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Expected O, but got Unknown
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Expected O, but got Unknown
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Expected O, but got Unknown
			//IL_0155: Unknown result type (might be due to invalid IL or missing references)
			//IL_015b: Expected O, but got Unknown
			//IL_01a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01aa: Expected O, but got Unknown
			//IL_01c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c8: Expected O, but got Unknown
			MethodInfo methodInfo = AccessTools.FirstMethod(typeof(Object), (Func<MethodInfo, bool>)((MethodInfo info) => info.Name == "Instantiate" && info.IsGenericMethodDefinition && info.GetParameters().Length == 3 && info.GetParameters()[1].ParameterType == typeof(Vector3) && info.GetParameters()[2].ParameterType == typeof(Quaternion))).MakeGenericMethod(typeof(GameObject));
			return new CodeMatcher(instructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Ldfld, (object)AccessTools.Field(typeof(ZoneVegetation), "m_enable"), (string)null)
			}).Insert((CodeInstruction[])(object)new CodeInstruction[1]
			{
				new CodeInstruction(OpCodes.Call, Transpilers.EmitDelegate<Func<ZoneVegetation, ZoneVegetation>>((Func<ZoneVegetation, ZoneVegetation>)SetVeg).operand)
			}).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Call, (object)methodInfo, (string)null)
			})
				.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
				{
					new CodeInstruction(OpCodes.Ldarg_S, (object)5)
				})
				.Set(OpCodes.Call, Transpilers.EmitDelegate<Func<GameObject, Vector3, Quaternion, List<ClearArea>, GameObject>>((Func<GameObject, Vector3, Quaternion, List<ClearArea>, GameObject>)Instantiate).operand)
				.MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
				{
					new CodeMatch((OpCode?)OpCodes.Callvirt, (object)AccessTools.Method(typeof(ZNetView), "SetLocalScale", (Type[])null, (Type[])null), (string)null)
				})
				.Set(OpCodes.Call, Transpilers.EmitDelegate<Action<ZNetView, Vector3>>((Action<ZNetView, Vector3>)SetScale).operand)
				.MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
				{
					new CodeMatch((OpCode?)OpCodes.Call, (object)methodInfo, (string)null)
				})
				.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
				{
					new CodeInstruction(OpCodes.Ldarg_S, (object)5)
				})
				.Set(OpCodes.Call, Transpilers.EmitDelegate<Func<GameObject, Vector3, Quaternion, List<ClearArea>, GameObject>>((Func<GameObject, Vector3, Quaternion, List<ClearArea>, GameObject>)InstantiateBlueprint).operand)
				.InstructionEnumeration();
		}

		private static void Prefix(ZoneSystem __instance)
		{
			foreach (ZoneVegetation item in __instance.m_vegetation)
			{
				if (Extra.TryGetValue(item, out VegetationExtra value) && (value.forbiddenGlobalKeys != null || value.requiredGlobalKeys != null))
				{
					item.m_enable = true;
					if (value.forbiddenGlobalKeys != null && Helper.HasAnyGlobalKey(value.forbiddenGlobalKeys))
					{
						item.m_enable = false;
					}
					if (value.requiredGlobalKeys != null && !Helper.HasEveryGlobalKey(value.requiredGlobalKeys))
					{
						item.m_enable = false;
					}
				}
			}
		}
	}
	[HarmonyPatch(typeof(ZoneSystem), "InsideClearArea")]
	public class InsideClearArea
	{
		private static bool Prefix(ref bool __result, List<ClearArea> areas, Vector3 point)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			__result = VegetationSpawning.InsideClearArea(areas, point);
			return false;
		}
	}
	[HarmonyPatch(typeof(ZoneSystem), "ValidateVegetation")]
	public class ValidateVegetation
	{
		private static bool Prefix()
		{
			return false;
		}
	}
	public class BiomeEnvironment
	{
		public string environment = "";

		[DefaultValue(1f)]
		public float weight = 1f;

		[DefaultValue(false)]
		public bool? ashlandsOverride;

		[DefaultValue(false)]
		public bool? deepNorthOverride;

		[DefaultValue("")]
		public string requiredGlobalKeys = "";

		[DefaultValue("")]
		public string forbiddenGlobalKeys = "";

		[DefaultValue("")]
		public string requiredPlayerKeys = "";

		[DefaultValue("")]
		public string forbiddenPlayerKeys = "";
	}
	public class BiomeYaml
	{
		public string biome = "";

		[DefaultValue("")]
		public string name = "";

		[DefaultValue("")]
		public string terrain = "";

		[DefaultValue("")]
		public string nature = "";

		[DefaultValue(1f)]
		public float altitudeMultiplier = 1f;

		[DefaultValue(1f)]
		public float waterDepthMultiplier = 1f;

		[DefaultValue(-1000f)]
		public float minimumAltitude = -1000f;

		[DefaultValue(10000f)]
		public float maximumAltitude = 10000f;

		[DefaultValue(0.5f)]
		public float excessFactor = 0.5f;

		[DefaultValue(1f)]
		public float forestMultiplier = 1f;

		[DefaultValue(0f)]
		public float altitudeDelta;

		public BiomeEnvironment[] environments = Array.Empty<BiomeEnvironment>();

		[DefaultValue("")]
		public string paint = "";

		public Color? color;

		[DefaultValue(1f)]
		public float mapColorMultiplier = 1f;

		public Color? mapColor;

		public string? colorMap;

		public string? colorTerrain;

		public string? colorWaterSurface;

		public string? colorWaterTop;

		public string? colorWaterBottom;

		public string? colorWaterShallow;

		[DefaultValue("")]
		public string musicMorning = "morning";

		[DefaultValue("")]
		public string musicEvening = "evening";

		[DefaultValue("")]
		public string musicDay = "";

		[DefaultValue("")]
		public string musicNight = "";

		[DefaultValue(false)]
		public bool noBuild;

		[DefaultValue(null)]
		public StatusData[]? statusEffects;

		[DefaultValue("")]
		public string lava = "";

		[DefaultValue(1f)]
		public float lavaAmount = 1f;

		[DefaultValue(1f)]
		public float lavaStretch = 1f;
	}
	public class BiomeData
	{
		public bool noBuild;

		public float altitudeMultiplier = 1f;

		public float waterDepthMultiplier = 1f;

		public float altitudeDelta;

		public float excessFactor = 0.5f;

		public float excessSign = 1f;

		public float minimumAltitude = -1000f;

		public float maximumAltitude = 10000f;

		public float mapColorMultiplier = 1f;

		public Color colorTerrain = new Color(0f, 0f, 0f, 0f);

		public Color colorMap = new Color(0f, 0f, 0f, 0f);

		public Color? colorWaterTop;

		public Color? colorWaterBottom;

		public Color? colorWaterShallow;

		public Color? colorWaterSurface;

		public float forestMultiplier = 1f;

		public bool lava;

		public float lavaAmount = 1f;

		public float lavaStretch = 1f;

		private float? lavaSeed;

		public List<Status> statusEffects = new List<Status>();

		public float GetLavaSeed()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			if (!lavaSeed.HasValue)
			{
				State state = Random.state;
				Random.InitState(ZNet.m_world.m_seed);
				lavaSeed = Random.Range(-10000, 10000);
				Random.state = state;
			}
			return lavaSeed.Value;
		}

		public BiomeData(BiomeYaml data)
		{
			//IL_0062: 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_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_0153: 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_0158: Unknown result type (might be due to invalid IL or missing references)
			//IL_017d: 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_0182: Unknown result type (might be due to invalid IL or missing references)
			//IL_0196: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0211: Unknown result type (might be due to invalid IL or missing references)
			noBuild = data.noBuild;
			altitudeMultiplier = data.altitudeMultiplier;
			waterDepthMultiplier = data.waterDepthMultiplier;
			altitudeDelta = data.altitudeDelta;
			excessFactor = Mathf.Abs(data.excessFactor);
			excessSign = Mathf.Sign(data.excessFactor);
			minimumAltitude = data.minimumAltitude;
			maximumAltitude = data.maximumAltitude;
			mapColorMultiplier = data.mapColorMultiplier;
			colorTerrain = (Color)(((??)data.color) ?? DataManager.ToColor(data.colorTerrain));
			colorMap = (Color)(((??)data.mapColor) ?? DataManager.ToColor(data.colorMap));
			colorWaterBottom = ((data.colorWaterBottom == null) ? ((Color?)null) : new Color?(DataManager.ToColor(data.colorWaterBottom)));
			colorWaterTop = ((data.colorWaterTop == null) ? ((Color?)null) : new Color?(DataManager.ToColor(data.colorWaterTop)));
			colorWaterShallow = ((data.colorWaterShallow == null) ? ((Color?)null) : new Color?(DataManager.ToColor(data.colorWaterShallow)));
			colorWaterSurface = ((data.colorWaterSurface == null) ? ((Color?)null) : new Color?(DataManager.ToColor(data.colorWaterSurface)));
			forestMultiplier = data.forestMultiplier;
			if (data.statusEffects != null)
			{
				statusEffects = data.statusEffects.Select((StatusData s) => new Status(s)).ToList();
			}
			if (data.lava == "")
			{
				lava = colorTerrain.a > 0.929f && colorTerrain.r > 0.929f;
			}
			else
			{
				lava = data.lava == "true";
			}
			lavaAmount = data.lavaAmount;
			lavaStretch = 0.01f / data.lavaStretch;
		}

		public bool IsValid()
		{
			if (statusEffects.Count <= 0 && altitudeMultiplier == 1f && waterDepthMultiplier == 1f && altitudeDelta == 0f && minimumAltitude == -1000f && maximumAltitude == 10000f && mapColorMultiplier == 1f && colorMap.a == 0f && forestMultiplier == 1f)
			{
				return lavaAmount != 1f;
			}
			return true;
		}
	}
	public class EnvEntryKeys
	{
		public List<string> requiredGlobalKeys = DataManager.ToList(data.requiredGlobalKeys);

		public List<string> forbiddenGlobalKeys = DataManager.ToList(data.forbiddenGlobalKeys);

		public List<string> requiredPlayerKeys = DataManager.ToList(data.requiredPlayerKeys);

		public List<string> forbiddenPlayerKeys = DataManager.ToList(data.forbiddenPlayerKeys);

		public EnvEntryKeys(BiomeEnvironment data)
		{
		}

		public bool CheckKeys()
		{
			if (requiredGlobalKeys.Any((string k) => !ZoneSystem.instance.GetGlobalKey(k)))
			{
				return false;
			}
			if (((IEnumerable<string>)forbiddenGlobalKeys).Any((Func<string, bool>)ZoneSystem.instance.GetGlobalKey))
			{
				return false;
			}
			Player player = Player.m_localPlayer;
			if (Object.op_Implicit((Object)(object)player) && requiredPlayerKeys.Any((string k) => !((Humanoid)player).HaveUniqueKey(k)))
			{
				return false;
			}
			if (Object.op_Implicit((Object)(object)player) && ((IEnumerable<string>)forbiddenPlayerKeys).Any((Func<string, bool>)((Humanoid)player).HaveUniqueKey))
			{
				return false;
			}
			return true;
		}

		public bool HasKeys()
		{
			if (requiredGlobalKeys.Count <= 0 && forbiddenGlobalKeys.Count <= 0 && requiredPlayerKeys.Count <= 0)
			{
				return forbiddenPlayerKeys.Count > 0;
			}
			return true;
		}
	}
	public class BiomeManager
	{
		public static string FileName = "expand_biomes.yaml";

		public static string FilePath = Path.Combine(Yaml.BaseDirectory, FileName);

		public static string Pattern = "expand_biomes*.yaml";

		public static Dictionary<string, EnvironmentData> Extra = new Dictionary<string, EnvironmentData>();

		public static Dictionary<EnvEntry, EnvEntryKeys> EnvKeys = new Dictionary<EnvEntry, EnvEntryKeys>();

		public static Biome LavaBiomes = (Biome)32;

		public static Biome FullLavaBiomes = (Biome)32;

		public static Biome NoBuildBiomes = (Biome)0;

		private static HashSet<string> UsedGlobalKeys = new HashSet<string>();

		private static readonly Dictionary<string, Biome> OriginalBiomes = new Dictionary<string, Biome>
		{
			{
				"None",
				(Biome)0
			},
			{
				"Meadows",
				(Biome)1
			},
			{
				"Swamp",
				(Biome)2
			},
			{
				"Mountain",
				(Biome)4
			},
			{
				"BlackForest",
				(Biome)8
			},
			{
				"Plains",
				(Biome)16
			},
			{
				"AshLands",
				(Biome)32
			},
			{
				"DeepNorth",
				(Biome)64
			},
			{
				"Ocean",
				(Biome)256
			},
			{
				"Mistlands",
				(Biome)512
			}
		};

		private static readonly Dictionary<string, BiomeYaml> ExtraBiomeYamls = new Dictionary<string, BiomeYaml>();

		private static Dictionary<string, Biome> NameToBiome = OriginalBiomes.ToDictionary<KeyValuePair<string, Biome>, string, Biome>((KeyValuePair<string, Biome> kvp) => kvp.Key.ToLowerInvariant(), (KeyValuePair<string, Biome> kvp) => kvp.Value);

		public static Dictionary<Biome, string> BiomeToDisplayName = OriginalBiomes.ToDictionary<KeyValuePair<string, Biome>, Biome, string>((KeyValuePair<string, Biome> kvp) => kvp.Value, (KeyValuePair<string, Biome> kvp) => kvp.Key);

		private static Dictionary<Biome, Biome> BiomeToTerrain = NameToBiome.ToDictionary<KeyValuePair<string, Biome>, Biome, Biome>((KeyValuePair<string, Biome> kvp) => kvp.Value, (KeyValuePair<string, Biome> kvp) => kvp.Value);

		private static Dictionary<Biome, Biome> BiomeToNature = NameToBiome.ToDictionary<KeyValuePair<string, Biome>, Biome, Biome>((KeyValuePair<string, Biome> kvp) => kvp.Value, (KeyValuePair<string, Biome> kvp) => kvp.Value);

		private static readonly Dictionary<Biome, Color> BiomeToColor = new Dictionary<Biome, Color>();

		private static readonly Dictionary<Biome, BiomeData> BiomeData = new Dictionary<Biome, BiomeData>();

		public static bool BiomeForestMultiplier = false;

		private static List<BiomeEnvSetup> Environments = new List<BiomeEnvSetup>();

		private static bool Initialized;

		private static bool Pending;

		private static readonly float[] biomeWeights = new float[33];

		private static readonly Biome[] indexToBiome = biomeWeights.Select((float _, int i) => (i < 2) ? ((Biome)i) : ((Biome)(2 << i - 2))).ToArray();

		public static EnvEntry FromData(BiomeEnvironment data, Dictionary<EnvEntry, EnvEntryKeys> keys)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: 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_005e: Expected O, but got Unknown
			EnvEntry val = new EnvEntry
			{
				m_environment = data.environment,
				m_weight = data.weight,
				m_ashlandsOverride = (data.ashlandsOverride ?? (data.environment == "Ashlands_SeaStorm")),
				m_deepnorthOverride = (data.deepNorthOverride == true)
			};
			EnvEntryKeys envEntryKeys = new EnvEntryKeys(data);
			if (envEntryKeys.HasKeys())
			{
				keys[val] = envEntryKeys;
			}
			return val;
		}

		public static BiomeEnvironment ToData(EnvEntry env)
		{
			return new BiomeEnvironment
			{
				environment = env.m_environment,
				weight = env.m_weight,
				ashlandsOverride = env.m_ashlandsOverride,
				deepNorthOverride = env.m_deepnorthOverride
			};
		}

		public static void AddBiome(BiomeYaml yaml)
		{
			string name = yaml.name;
			if (ExtraBiomeYamls.ContainsKey(name))
			{
				throw new Exception("Biome " + name + " already exists.");
			}
			ExtraBiomeYamls[name] = yaml;
		}

		public static bool TryGetColor(Biome biome, out Color color)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			return BiomeToColor.TryGetValue(biome, out color);
		}

		public static bool TryGetData(Biome biome, out BiomeData data)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			return BiomeData.TryGetValue(biome, out data);
		}

		public static bool TryGetBiome(string name, out Biome biome)
		{
			return NameToBiome.TryGetValue(name.ToLowerInvariant(), out biome);
		}

		public static Biome GetBiome(string name)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			if (!NameToBiome.TryGetValue(name.ToLowerInvariant(), out var value))
			{
				return (Biome)0;
			}
			return value;
		}

		public static bool TryGetDisplayName(Biome biome, out string name)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			return BiomeToDisplayName.TryGetValue(biome, out name);
		}

		public static Biome GetTerrain(Biome biome)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			if (!BiomeToTerrain.TryGetValue(biome, out var value))
			{
				return biome;
			}
			return value;
		}

		public static Biome GetNature(Biome biome)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			if (!BiomeToNature.TryGetValue(biome, out var value))
			{
				return biome;
			}
			return value;
		}

		public static BiomeEnvSetup FromData(BiomeYaml data, Dictionary<EnvEntry, EnvEntryKeys> keys, string fileName)
		{
			//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_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: 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_0052: 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_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Expected O, but got Unknown
			return new BiomeEnvSetup
			{
				m_biome = DataManager.ToBiomes(data.biome, fileName),
				m_environments = data.environments.Select((BiomeEnvironment d) => FromData(d, keys)).ToList(),
				m_musicMorning = data.musicMorning,
				m_musicEvening = data.musicEvening,
				m_musicDay = data.musicDay,
				m_musicNight = data.musicNight
			};
		}

		public static BiomeYaml ToData(BiomeEnvSetup biome)
		{
			//IL_0007: 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_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Invalid comparison between Unknown and I4
			BiomeYaml obj = new BiomeYaml
			{
				biome = DataManager.FromBiomes(biome.m_biome)
			};
			List<BiomeEnvironment> list = new List<BiomeEnvironment>();
			list.AddRange(biome.m_environments.Select(ToData));
			obj.environments = list.ToArray();
			obj.musicMorning = biome.m_musicMorning;
			obj.musicEvening = biome.m_musicEvening;
			obj.musicDay = biome.m_musicDay;
			obj.musicNight = biome.m_musicNight;
			obj.colorTerrain = DataManager.FromColor(Color32.op_Implicit(Heightmap.GetBiomeColor(biome.m_biome)));
			obj.colorMap = DataManager.FromColor(Minimap.instance.GetPixelColor(biome.m_biome));
			obj.lava = (((int)biome.m_biome == 32) ? "true" : "");
			return obj;
		}

		public static void CreateConfigs()
		{
			if (Helper.IsClient() || !Configuration.DataBiome || File.Exists(FilePath))
			{
				return;
			}
			List<BiomeYaml> list = (from b in OriginalBiomes.Values
				select EnvMan.instance.m_biomes.Find((BiomeEnvSetup ev) => ev.m_biome == b) into b
				where b != null
				select b).Select(ToData).ToList();
			Dictionary<string, BiomeYaml>.ValueCollection values = ExtraBiomeYamls.Values;
			List<BiomeYaml> list2 = new List<BiomeYaml>(list.Count + values.Count);
			list2.AddRange(list);
			list2.AddRange(values);
			List<BiomeYaml> list3 = list2;
			string contents = Yaml.Serializer().Serialize((object)list3);
			File.WriteAllText(FilePath, contents);
			if (ExtraBiomeYamls.Count > 0)
			{
				ReadConfigs();
			}
		}

		public static void ReadConfigs()
		{
			if (Helper.IsClient())
			{
				return;
			}
			if (Configuration.DataBiome)
			{
				if (File.Exists(FilePath))
				{
					string text = DataManager.Read<BiomeYaml, BiomeYaml>(Pattern, From);
					Configuration.valueBiomeData.Value = text;
					Set(text);
				}
				else
				{
					CreateConfigs();
				}
			}
			else
			{
				Configuration.valueBiomeData.Value = "";
				Set("");
			}
		}

		public static void NamesFromFile()
		{
			if (Configuration.DataBiome)
			{
				LoadNames(DataManager.ReadData<BiomeYaml, BiomeYaml>(Pattern, From));
			}
		}

		private static BiomeYaml From(BiomeYaml data, string file)
		{
			return data;
		}

		public static void FromSetting(string yaml)
		{
			if (Helper.IsClient())
			{
				Set(yaml);
			}
		}

		private static List<BiomeYaml> Parse(string yaml)
		{
			List<BiomeYaml> result = new List<BiomeYaml>();
			if (Configuration.DataBiome)
			{
				try
				{
					result = Yaml.Deserialize<BiomeYaml>(yaml, "Biomes");
				}
				catch (Exception ex)
				{
					Log.Warning("Failed to load any biome data.");
					Log.Error(ex.Message);
					Log.Error(ex.StackTrace);
				}
			}
			return result;
		}

		public static void SetNames(Dictionary<Biome, string> names)
		{
			BiomeToDisplayName = names;
			NameToBiome = BiomeToDisplayName.ToDictionary<KeyValuePair<Biome, string>, string, Biome>((KeyValuePair<Biome, string> kvp) => kvp.Value.ToLowerInvariant(), (KeyValuePair<Biome, string> kvp) => kvp.Key);
			Log.Info($"Received {BiomeToDisplayName.Count} biome names.");
		}

		private static void LoadNames(List<BiomeYaml> rawData)
		{
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: 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_00d5: Unknown result type (might be due to invalid IL or missing references)
			if (rawData.Count > 0)
			{
				Log.Info($"Preloading biome names ({rawData.Count} entries).");
			}
			HashSet<string> hashSet = OriginalBiomes.Select<KeyValuePair<string, Biome>, string>((KeyValuePair<string, Biome> kvp) => kvp.Key.ToLowerInvariant()).ToHashSet();
			BiomeToDisplayName = OriginalBiomes.ToDictionary<KeyValuePair<string, Biome>, Biome, string>((KeyValuePair<string, Biome> kvp) => kvp.Value, (KeyValuePair<string, Biome> kvp) => kvp.Key);
			Biome val = (Biome)512;
			foreach (BiomeYaml rawDatum in rawData)
			{
				if (!hashSet.Contains(rawDatum.biome.ToLowerInvariant()))
				{
					val = NextBiome(val);
					BiomeToDisplayName[val] = rawDatum.biome;
				}
			}
			NameToBiome = BiomeToDisplayName.ToDictionary<KeyValuePair<Biome, string>, string, Biome>((KeyValuePair<Biome, string> kvp) => kvp.Value.ToLowerInvariant(), (KeyValuePair<Biome, string> kvp) => kvp.Key);
		}

		public static void Load()
		{
			Initialized = true;
			if (Pending)
			{
				Pending = false;
				Set(Configuration.valueBiomeData.Value);
			}
		}

		public static void CleanUp()
		{
			Initialized = false;
			Pending = false;
		}

		private static void Load(string yaml)
		{
			//IL_0068: 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: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: 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_012e: Unknown result type (might be due to invalid IL or missing references)
			//IL_016e: Unknown result type (might be due to invalid IL or missing references)
			//IL_016f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0174: 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_0176: 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_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_0149: 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_015f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0218: Unknown result type (might be due to invalid IL or missing references)
			//IL_0219: Unknown result type (might be due to invalid IL or missing references)
			//IL_022c: 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_0200: Unknown result type (might be due to invalid IL or missing references)
			//IL_0202: Unknown result type (might be due to invalid IL or missing references)
			//IL_0203: Unknown result type (might be due to invalid IL or missing references)
			//IL_024c: 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)
			if (yaml == "" || !Configuration.DataBiome)
			{
				return;
			}
			List<BiomeYaml> list = Parse(yaml);
			if (list.Count > 0)
			{
				Log.Info($"Reloading biome data ({list.Count} entries).");
			}
			EnvKeys.Clear();
			UsedGlobalKeys.Clear();
			BiomeData.Clear();
			BiomeToColor.Clear();
			LavaBiomes = (Biome)0;
			FullLavaBiomes = (Biome)0;
			NoBuildBiomes = (Biome)0;
			NameToBiome = OriginalBiomes.ToDictionary<KeyValuePair<string, Biome>, string, Biome>((KeyValuePair<string, Biome> kvp) => kvp.Key.ToLowerInvariant(), (KeyValuePair<string, Biome> kvp) => kvp.Value);
			BiomeToDisplayName = OriginalBiomes.ToDictionary<KeyValuePair<string, Biome>, Biome, string>((KeyValuePair<string, Biome> kvp) => kvp.Value, (KeyValuePair<string, Biome> kvp) => kvp.Key);
			Biome val = (Biome)512;
			foreach (BiomeYaml item in list)
			{
				Biome val2 = val;
				if (NameToBiome.TryGetValue(item.biome.ToLowerInvariant(), out var value))
				{
					val2 = value;
					if (item.name != "")
					{
						AddTranslation(val2, item.name);
					}
				}
				else
				{
					val2 = (val = NextBiome(val));
					NameToBiome.Add(item.biome.ToLowerInvariant(), val2);
					BiomeToDisplayName[val2] = item.biome;
					AddTranslation(val2, item.name);
				}
				BiomeData biomeData = new BiomeData(item);
				if (biomeData.lava)
				{
					LavaBiomes |= val2;
				}
				if (biomeData.lava && biomeData.colorTerrain.a == 1f && biomeData.colorTerrain.r == 1f)
				{
					FullLavaBiomes |= val2;
				}
				if (biomeData.noBuild)
				{
					NoBuildBiomes |= val2;
				}
				if (biomeData.IsValid())
				{
					BiomeData[val2] = biomeData;
				}
				if (item.paint != "")
				{
					BiomeToColor[val2] = Terrain.ParsePaint(item.paint);
				}
			}
			BiomeToTerrain = list.ToDictionary((BiomeYaml data) => GetBiome(data.biome), (BiomeYaml data) => TryGetBiome(data.terrain, out var biome) ? biome : GetBiome(data.biome));
			BiomeToNature = ((IEnumerable<BiomeYaml>)list).ToDictionary((Func<BiomeYaml, Biome>)((BiomeYaml data) => GetBiome(data.biome)), (Func<BiomeYaml, Biome>)delegate(BiomeYaml data)
			{
				//IL_000f: 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)
				//IL_0020: Unknown result type (might be due to invalid IL or missing references)
				if (TryGetBiome(data.nature, out biome))
				{
					return biome;
				}
				Biome biome2;
				return TryGetBiome(data.terrain, out biome2) ? biome2 : GetBiome(data.biome);
			});
			BiomeForestMultiplier = list.Any((BiomeYaml data) => data.forestMultiplier != 1f);
			List<BiomeEnvSetup> list2 = new List<BiomeEnvSetup>();
			list2.AddRange(list.Select((BiomeYaml d) => FromData(d, EnvKeys, "Biomes")));
			Environments = list2;
			HashSet<string> hashSet = new HashSet<string>();
			foreach (string item2 in (from key in EnvKeys.Values.SelectMany((EnvEntryKeys data) => data.requiredGlobalKeys.Concat(data.forbiddenGlobalKeys))
				where key != null && key != ""
				select key).Select(NormalizeKey))
			{
				hashSet.Add(item2);
			}
			UsedGlobalKeys = hashSet;
			LoadEnvironments();
			EWD.Instance.InvokeRegenerate();
		}

		public static void LoadEnvironments()
		{
			if (Configuration.DataBiome && Environments.Count != 0)
			{
				SetupBiomeEnvs(Environments);
			}
		}

		private static void SetupBiomeEnvs(List<BiomeEnvSetup> data)
		{
			EnvMan instance = EnvMan.instance;
			foreach (LocationList allLocationList in LocationList.m_allLocationLists)
			{
				allLocationList.m_biomeEnvironments.Clear();
			}
			instance.m_biomes.Clear();
			foreach (BiomeEnvSetup datum in data)
			{
				instance.AppendBiomeSetup(datum);
			}
			instance.m_environmentPeriod = -1L;
			instance.m_firstEnv = true;
		}

		private unsafe static void AddTranslation(Biome biome, string name)
		{
			string key = "biome_" + ((object)(*(Biome*)(&biome))/*cast due to .constrained prefix*/).ToString().ToLowerInvariant();
			string value = ((name == "") ? ((object)(*(Biome*)(&biome))/*cast due to .constrained prefix*/).ToString() : name);
			Localization.instance.m_translations[key] = value;
		}

		private static Biome NextBiome(Biome biome)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Expected I4, but got Unknown
			uint num = (uint)(int)biome;
			return (Biome)(num switch
			{
				128u => throw new Exception("Too many biomes."), 
				2147483648u => 128, 
				_ => 2 * num, 
			});
		}

		private static void Set(string yaml)
		{
			if (!Initialized)
			{
				Pending = true;
			}
			else
			{
				Load(yaml);
			}
		}

		public static void SetupWatcher()
		{
			Yaml.SetupWatcher(Pattern, callback);
			static void callback()
			{
				if ((Object)(object)ZNet.m_instance == (Object)null)
				{
					NamesFromFile();
				}
				else
				{
					ReadConfigs();
				}
			}
		}

		public unsafe static void SetupBiomeArrays()
		{
			fixed (Biome[]* s_indexToBiome = &Heightmap.s_indexToBiome)
			{
				void* ptr = s_indexToBiome;
				Unsafe.Write(ptr, indexToBiome);
			}
			fixed (float[]* s_tempBiomeWeights = &Heightmap.s_tempBiomeWeights)
			{
				void* ptr2 = s_tempBiomeWeights;
				Unsafe.Write(ptr2, biomeWeights);
			}
			for (int i = 0; i < indexToBiome.Length; i++)
			{
				Heightmap.s_biomeToIndex[indexToBiome[i]] = i;
			}
		}

		public static bool CheckKeys(EnvEntry env)
		{
			if (EnvKeys.TryGetValue(env, out EnvEntryKeys value))
			{
				return value.CheckKeys();
			}
			return true;
		}

		private static string NormalizeKey(string key)
		{
			return key.Trim().ToLowerInvariant();
		}

		public static bool UsesGlobalKey(string key)
		{
			if (UsedGlobalKeys.Count == 0)
			{
				return false;
			}
			if (key == null || key == "")
			{
				return false;
			}
			return UsedGlobalKeys.Contains(NormalizeKey(key));
		}

		public static bool HasRelevantGlobalKeyChanges(HashSet<string> oldKeys, List<string> newKeys)
		{
			if (UsedGlobalKeys.Count == 0)
			{
				return false;
			}
			HashSet<string> hashSet = new HashSet<string>();
			HashSet<string> hashSet2 = new HashSet<string>();
			foreach (string oldKey in oldKeys)
			{
				if (UsesGlobalKey(oldKey))
				{
					hashSet.Add(oldKey);
				}
			}
			foreach (string newKey in newKeys)
			{
				if (UsesGlobalKey(newKey))
				{
					hashSet2.Add(newKey);
				}
			}
			return !hashSet.SetEquals(hashSet2);
		}
	}
	public class GenerateWorldMap
	{
		private static float GetBiomeHeight(Biome biome, float wx, float wy, out Color mask, bool preGeneration = false)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			return WorldGenerator.instance.GetBiomeHeight(biome, wx, wy, ref mask, preGeneration);
		}

		private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0002: 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_0035: Expected O, but got Unknown
			return new CodeMatcher(instructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Callvirt, (object)AccessTools.Field(typeof(WorldGenerator), "GetBiomeHeight"), (string)null)
			}).Set(OpCodes.Call, Transpilers.EmitDelegate<<>f__AnonymousDelegate0<Biome, float, float, Color, bool, float>>((<>f__AnonymousDelegate0<Biome, float, float, Color, bool, float>)GetBiomeHeight).operand).InstructionEnumeration();
		}
	}
	[HarmonyPatch(typeof(Minimap), "UpdateBiome")]
	public class UpdateBiome
	{
		private static readonly char[] EmptyChars = Array.Empty<char>();

		private static char[] OriginalChars = Array.Empty<char>();

		private static string AppendTerritoryName(string text, Vector3 coords)
		{
			//IL_0000: 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)
			TerritoryData territory = BiomeCalculator.GetTerritory(coords.x, coords.z);
			if (territory == null || territory.name == "")
			{
				return text;
			}
			return text + " (" + territory.name + ")";
		}

		private static void Prefix()
		{
			OriginalChars = Localization.instance.m_endChars;
			Localization.instance.m_endChars = EmptyChars;
		}

		private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
		{
			//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_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Expected O, but got Unknown
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Expected O, but got Unknown
			return new CodeMatcher(instructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Stloc_2, (object)null, (string)null)
			}).Insert((CodeInstruction[])(object)new CodeInstruction[2]
			{
				new CodeInstruction(OpCodes.Ldloc_0, (object)null),
				new CodeInstruction(OpCodes.Call, Transpilers.EmitDelegate<Func<string, Vector3, string>>((Func<string, Vector3, string>)AppendTerritoryName).operand)
			}).InstructionEnumeration();
		}

		private static void Postfix()
		{
			Localization.instance.m_endChars = OriginalChars;
		}
	}
	[HarmonyPatch(typeof(EnvMan), "GetAvailableEnvironments")]
	public class GetAvailableEnvironments
	{
		private static List<EnvEntry> Postfix(List<EnvEntry> result)
		{
			if (result == null)
			{
				return null;
			}
			if (BiomeManager.EnvKeys.Count == 0)
			{
				return result;
			}
			List<EnvEntry> list = new List<EnvEntry>();
			list.AddRange(result.Where(BiomeManager.CheckKeys));
			return list;
		}
	}
	[HarmonyPatch(typeof(ZoneSystem), "RPC_GlobalKeys")]
	public class RPC_GlobalKeys
	{
		private static void Prefix(List<string> keys)
		{
			if (BiomeManager.HasRelevantGlobalKeyChanges(ZoneSystem.instance.m_globalKeys, keys))
			{
				EnvMan.instance.m_environmentPeriod = 0L;
			}
		}
	}
	[HarmonyPatch(typeof(ZoneSystem), "GlobalKeyAdd")]
	public class GlobalKeyAdd
	{
		private static void Postfix(string keyStr)
		{
			if (BiomeManager.UsesGlobalKey(keyStr))
			{
				EnvMan.instance.m_environmentPeriod = 0L;
			}
		}
	}
	[HarmonyPatch(typeof(ZoneSystem), "GlobalKeyRemove")]
	public class GlobalKeyRemove
	{
		private static void Postfix(string keyStr, bool __result)
		{
			if (__result && BiomeManager.UsesGlobalKey(keyStr))
			{
				EnvMan.instance.m_environmentPeriod = 0L;
			}
		}
	}
	public class TerritoryYaml
	{
		public string territory = "";

		[DefaultValue(false)]
		public bool noBuild;

		[DefaultValue(1f)]
		public float altitudeMultiplier = 1f;

		[DefaultValue(1f)]
		public float waterDepthMultiplier = 1f;

		[DefaultValue(-1000f)]
		public float minimumAltitude = -1000f;

		[DefaultValue(10000f)]
		public float maximumAltitude = 10000f;

		[DefaultValue(0.5f)]
		public float excessFactor = 0.5f;

		[DefaultValue(1f)]
		public float forestMultiplier = 1f;

		[DefaultValue(0f)]
		public float altitudeDelta;

		public string? colorMap;

		public string? colorTerrain;

		public string? colorWaterSurface;

		public string? colorWaterTop;

		public string? colorWaterBottom;

		public string? colorWaterShallow;

		[DefaultValue(null)]
		public StatusData[]? statusEffects;
	}
	public class TerritoryData
	{
		public string name = "";

		public bool noBuild;

		public float altitudeMultiplier = 1f;

		public float waterDepthMultiplier = 1f;

		public float altitudeDelta;

		public float excessFactor = 0.5f;

		public float excessSign = 1f;

		public float minimumAltitude = -1000f;

		public float maximumAltitude = 10000f;

		public float forestMultiplier = 1f;

		public Color? colorMap;

		public Color? colorTerrain;

		public Color? colorWaterTop;

		public Color? colorWaterBottom;

		public Color? colorWaterShallow;

		public Color? colorWaterSurface;

		public List<Status> statusEffects = new List<Status>();

		public TerritoryData(TerritoryYaml data)
		{
			//IL_00fa: 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_014c: 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_019e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c7: Unknown result type (might be due to invalid IL or missing references)
			name = data.territory;
			noBuild = data.noBuild;
			altitudeMultiplier = data.altitudeMultiplier;
			waterDepthMultiplier = data.waterDepthMultiplier;
			altitudeDelta = data.altitudeDelta;
			excessFactor = Mathf.Abs(data.excessFactor);
			excessSign = Mathf.Sign(data.excessFactor);
			minimumAltitude = data.minimumAltitude;
			maximumAltitude = data.maximumAltitude;
			forestMultiplier = data.forestMultiplier;
			colorTerrain = ((data.colorTerrain == null) ? ((Color?)null) : new Color?(DataManager.ToColor(data.colorTerrain)));
			colorMap = ((data.colorMap == null) ? ((Color?)null) : new Color?(DataManager.ToColor(data.colorMap)));
			colorWaterBottom = ((data.colorWaterBottom == null) ? ((Color?)null) : new Color?(DataManager.ToColor(data.colorWaterBottom)));
			colorWaterTop = ((data.colorWaterTop == null) ? ((Color?)null) : new Color?(DataManager.ToColor(data.colorWaterTop)));
			colorWaterShallow = ((data.colorWaterShallow == null) ? ((Color?)null) : new Color?(DataManager.ToColor(data.colorWaterShallow)));
			colorWaterSurface = ((data.colorWaterSurface == null) ? ((Color?)null) : new Color?(DataManager.ToColor(data.colorWaterSurface)));
			if (data.statusEffects != null)
			{
				List<Status> list = new List<Status>();
				list.AddRange(data.statusEffects.Select((StatusData s) => new Status(s)));
				statusEffects = list;
			}
		}

		public bool IsValid()
		{
			if (!noBuild && statusEffects.Count <= 0 && altitudeMultiplier == 1f && waterDepthMultiplier == 1f && altitudeDelta == 0f && minimumAltitude == -1000f && maximumAltitude == 10000f && !colorMap.HasValue && !colorTerrain.HasValue && !colorWaterTop.HasValue && !colorWaterBottom.HasValue && !colorWaterShallow.HasValue && !colorWaterSurface.HasValue)
			{
				return forestMultiplier != 1f;
			}
			return true;
		}
	}
	public class TerritoryManager
	{
		public static string FileName = "expand_territories.yaml";

		public static string FilePath = Path.Combine(Yaml.BaseDirectory, FileName);

		public static string Pattern = "expand_territories*.yaml";

		private static bool Initialized;

		private static bool Pending;

		private static readonly Dictionary<string, TerritoryYaml> ExtraTerritoryYamls = new Dictionary<string, TerritoryYaml>();

		private static readonly Dictionary<string, TerritoryData> Data = new Dictionary<string, TerritoryData>();

		public static void Load()
		{
			Initialized = true;
			if (Pending)
			{
				Pending = false;
				Set(Configuration.valueTerritoryData.Value);
			}
		}

		public static void CleanUp()
		{
			Initialized = false;
			Pending = false;
		}

		public static void AddTerritory(TerritoryYaml yaml)
		{
			string text = Normalize(yaml.territory);
			if (text == "")
			{
				throw new Exception("Territory name can't be empty.");
			}
			if (ExtraTerritoryYamls.ContainsKey(text))
			{
				throw new Exception("Territory " + yaml.territory + " already exists.");
			}
			ExtraTerritoryYamls[text] = yaml;
		}

		public static bool TryGetData(string territory, out TerritoryData data)
		{
			return Data.TryGetValue(Normalize(territory), out data);
		}

		public static void CreateConfigs()
		{
			if (!Helper.IsClient() && Configuration.DataTerritory && !File.Exists(FilePath) && ExtraTerritoryYamls.Count != 0)
			{
				string contents = Yaml.Serializer().Serialize((object)ExtraTerritoryYamls.Values);
				File.WriteAllText(FilePath, contents);
			}
		}

		public static void ReadConfigs()
		{
			if (!Helper.IsClient())
			{
				string text = (Configuration.DataTerritory ? DataManager.Read<TerritoryYaml, TerritoryYaml>(Pattern, From) : "");
				Configuration.valueTerritoryData.Value = text;
				Set(text);
			}
		}

		private static TerritoryYaml From(TerritoryYaml data, string file)
		{
			return data;
		}

		public static void FromSetting(string yaml)
		{
			if (Helper.IsClient())
			{
				Set(yaml);
			}
		}

		private static List<TerritoryYaml> Parse(string yaml)
		{
			List<TerritoryYaml> result = new List<TerritoryYaml>();
			if (Configuration.DataTerritory)
			{
				try
				{
					result = Yaml.Deserialize<TerritoryYaml>(yaml, "Territories");
				}
				catch (Exception ex)
				{
					Log.Warning("Failed to load any territory data.");
					Log.Error(ex.Message);
					Log.Error(ex.StackTrace);
				}
			}
			return result;
		}

		private static void Set(string yaml)
		{
			if (!Initialized)
			{
				Pending = true;
				return;
			}
			Data.Clear();
			if (yaml == "" || !Configuration.DataTerritory)
			{
				return;
			}
			List<TerritoryYaml> list = Parse(yaml);
			if (list.Count > 0)
			{
				Log.Info($"Reloading territory data ({list.Count} entries).");
			}
			foreach (TerritoryYaml item in list)
			{
				string text = Normalize(item.territory);
				if (!(text == ""))
				{
					TerritoryData territoryData = new TerritoryData(item);
					if (territoryData.IsValid())
					{
						Data[text] = territoryData;
					}
				}
			}
		}

		public static void SetupWatcher()
		{
			Yaml.SetupWatcher(Pattern, ReadConfigs);
		}

		private static string Normalize(string value)
		{
			return value.Trim().ToLowerInvariant();
		}
	}
	public class WorldYaml
	{
		[DefaultValue("")]
		public string biome = "";

		[DefaultValue("")]
		public string territory = "";

		[DefaultValue(10000f)]
		public float maxAltitude = 10000f;

		[DefaultValue(-1000f)]
		public float minAltitude = -1000f;

		[DefaultValue(1f)]
		public float maxDistance = 1f;

		[DefaultValue(0f)]
		public float minDistance;

		[DefaultValue(1f)]
		public float maxSector = 1f;

		[DefaultValue(0f)]
		public float minSector;

		[DefaultValue(0f)]
		public float centerX;

		[DefaultValue(0f)]
		public float centerY;

		[DefaultValue(1f)]
		public float amount = 1f;

		[DefaultValue(1f)]
		public float stretch = 1f;

		[DefaultValue("")]
		public string seed = "";

		[DefaultValue(true)]
		public bool wiggleDistance = true;

		[DefaultValue(true)]
		public bool wiggleSector = true;

		[DefaultValue(null)]
		public float? wiggleDistanceLength;

		[DefaultValue(null)]
		public float? wiggleDistanceWidth;

		[DefaultValue(null)]
		public float? wiggleSectorLength;

		[DefaultValue(null)]
		public float? wiggleSectorWidth;

		[DefaultValue("")]
		public string boiling = "";
	}
	public class WorldEntry
	{
		public Biome biome;

		public string territory = "";

		public float maxAltitude = 10000f;

		public float minAltitude = -1000f;

		public float maxDistance = 1f;

		public float minDistance;

		public float maxSector = 1f;

		public float minSector;

		public float centerX;

		public float centerY;

		public float amount = 1f;

		public float stretch = 1f;

		public Biome biomeSeed;

		public int? seed;

		public float wiggleDistanceLength = 20f;

		public float wiggleDistanceWidth = 100f;

		public float wiggleSectorLength = 500f;

		public float wiggleSectorWidth = 0.01f;

		public float boiling;

		public static float ConvertDist(float percent)
		{
			return percent * WorldInfo.Radius;
		}

		public WorldEntry(WorldYaml data, string fileName)
		{
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: 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_00aa: 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_00ee: 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_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			territory = data.territory;
			if (data.biome != "")
			{
				biome = DataManager.ToBiomes(data.biome, fileName);
			}
			biomeSeed = BiomeManager.GetTerrain(biome);
			Biome val;
			if (Parse.TryInt(data.seed, out var result))
			{
				seed = result;
			}
			else if (BiomeManager.TryGetBiome(data.seed, out val))
			{
				biomeSeed = val;
			}
			if (data.boiling == "" && (biome & BiomeManager.LavaBiomes) != 0)
			{
				boiling = 1f;
			}
			if (data.boiling == "true")
			{
				boiling = 1f;
			}
			if (Parse.TryFloat(data.boiling, out var result2))
			{
				boiling = result2;
			}
			maxAltitude = data.maxAltitude;
			minAltitude = data.minAltitude;
			maxDistance = ConvertDist(data.maxDistance);
			minDistance = ConvertDist(data.minDistance);
			maxSector = data.maxSector;
			minSector = data.minSector;
			centerX = ConvertDist(data.centerX);
			centerY = ConvertDist(data.centerY);
			amount = data.amount;
			stretch = data.stretch;
			wiggleDistanceLength = Configuration.WiggleFrequency;
			wiggleDistanceWidth = Configuration.WiggleWidth;
			wiggleSectorLength = Configuration.DistanceWiggleLength;
			wiggleSectorWidth = Configuration.DistanceWiggleWidth;
			if (!data.wiggleDistance)
			{
				wiggleDistanceWidth = 0f;
			}
			if (!data.wiggleSector)
			{
				wiggleSectorWidth = 0f;
			}
			if (data.wiggleDistanceLength.HasValue)
			{
				wiggleDistanceLength = data.wiggleDistanceLength.Value;
			}
			if (data.wiggleDistanceWidth.HasValue)
			{
				wiggleDistanceWidth = data.wiggleDistanceWidth.Value;
			}
			if (data.wiggleSectorLength.HasValue)
			{
				wiggleSectorLength = data.wiggleSectorLength.Value;
			}
			if (data.wiggleSectorWidth.HasValue)
			{
				wiggleSectorWidth = data.wiggleSectorWidth.Value;
			}
			if (minSector < 0f)
			{
				minSector += 1f;
			}
			if (maxSector > 1f)
			{
				maxSector -= 1f;
			}
		}
	}
	public class WorldManager
	{
		public static string FileName = "expand_world.yaml";

		public static string FilePath = Path.Combine(Yaml.BaseDirectory, FileName);

		public static string Pattern = "expand_world*.yaml";

		private static bool Initialized;

		private static bool Pending;

		public static List<WorldYaml> DefaultData = new List<WorldYaml>(10)
		{
			new WorldYaml
			{
				biome = "ashlands",
				centerY = 0.4f,
				minDistance = 1.2f,
				maxDistance = 1.6f,
				boiling = "true"
			},
			new WorldYaml
			{
				biome = "ocean",
				maxAltitude = -26f
			},
			new WorldYaml
			{
				biome = "mountain",
				minAltitude = 50f
			},
			new WorldYaml
			{
				biome = "deepnorth",
				centerY = -0.4f,
				minDistance = 1.2f,
				maxDistance = 1.6f
			},
			new WorldYaml
			{
				biome = "swamp",
				wiggleDistance = false,
				minDistance = 0.2f,
				maxDistance = 0.6f,
				minAltitude = -20f,
				maxAltitude = 20f,
				amount = 0.4f
			},
			new WorldYaml
			{
				biome = "mistlands",
				minDistance = 0.6f,
				amount = 0.6f
			},
			new WorldYaml
			{
				biome = "plains",
				minDistance = 0.3f,
				maxDistance = 0.8f,
				amount = 0.6f
			},
			new WorldYaml
			{
				biome = "blackforest",
				minDistance = 0.06f,
				maxDistance = 0.6f,
				amount = 0.6f
			},
			new WorldYaml
			{
				biome = "blackforest",
				minDistance = 0.5f
			},
			new WorldYaml
			{
				biome = "meadows"
			}
		};

		public static List<WorldEntry> DefaultEntries = DefaultData.Select((WorldYaml s) => new WorldEntry(s, "default world")).ToList();

		public static List<WorldYaml> Data = DefaultData;

		public static void Load()
		{
			Initialized = true;
			if (Pending)
			{
				Pending = false;
				Set(Configuration.valueWorldData.Value);
			}
		}

		public static void CleanUp()
		{
			Initialized = false;
			Pending = false;
		}

		public static void AddWorld(WorldYaml data, int index)
		{
			DefaultData.Insert(index, data);
			DefaultEntries.Insert(index, new WorldEntry(data, ""));
		}

		public static WorldYaml ToData(WorldYaml biome)
		{
			return biome;
		}

		public static void CreateConfigs()
		{
			if (!Helper.IsClient() && Configuration.DataWorld && !File.Exists(FilePath))
			{
				string contents = Yaml.Serializer().Serialize((object)DefaultData);
				File.WriteAllText(FilePath, contents);
			}
		}

		public static void ReadConfigs()
		{
			if (Helper.IsClient())
			{
				return;
			}
			if (Configuration.DataWorld)
			{
				if (File.Exists(FilePath))
				{
					string text = DataManager.Read(Pattern, (WorldYaml d, string f) => new WorldEntry(d, f));
					Configuration.valueWorldData.Value = text;
					Set(text);
				}
				else
				{
					CreateConfigs();
				}
			}
			else
			{
				Configuration.valueWorldData.Value = "";
				Set("");
			}
		}

		public static void FromSetting(string yaml)
		{
			if (Helper.IsClient())
			{
				Set(yaml);
			}
		}

		private static void Set(string yaml)
		{
			if (!Initialized)
			{
				Pending = true;
			}
			else
			{
				if (yaml == "" || !Configuration.DataWorld)
				{
					return;
				}
				try
				{
					Data = Yaml.Deserialize<WorldYaml>(yaml, "World");
					if (Data.Count == 0)
					{
						Log.Warning("Failed to load any world data.");
						Log.Info($"Reloading default world data ({Data.Count} entries).");
						Data = DefaultData;
					}
					else
					{
						Log.Info($"Reloading world data ({Data.Count} entries).");
					}
					List<WorldEntry> list = new List<WorldEntry>();
					list.AddRange(Data.Select((WorldYaml s) => new WorldEntry(s, "world")));
					BiomeCalculator.SetData(list);
					BiomeCalculator.CheckAngles = Data.Any((WorldYaml x) => x.minSector != 0f || x.maxSector != 1f);
					EWD.Instance.InvokeRegenerate();
				}
				catch (Exception ex)
				{
					Log.Error(ex.Message);
					Log.Error(ex.StackTrace);
				}
			}
		}

		public static void Reload()
		{
			Log.Info($"Reloading world data ({Data.Count} entries).");
			List<WorldEntry> list = new List<WorldEntry>();
			list.AddRange(Data.Select((WorldYaml s) => new WorldEntry(s, "world")));
			BiomeCalculator.SetData(list);
			BiomeCalculator.CheckAngles = Data.Any((WorldYaml x) => x.minSector != 0f || x.maxSector != 1f);
			EWD.Instance.InvokeRegenerate();
		}

		public static void SetupWatcher()
		{
			Yaml.SetupWatcher(Pattern, ReadConfigs);
		}
	}
}
namespace ExpandWorldData.Dungeon
{
	[HarmonyPatch]
	public class Loader
	{
		public static string FileName = "expand_dungeons.yaml";

		public static string FilePath = Path.Combine(Yaml.BaseDirectory, FileName);

		public static string Pattern = "expand_dungeons*.yaml";

		private static readonly List<DungeonYaml> ExtraDungeonYamls = new List<DungeonYaml>();

		private static Dictionary<string, DungeonGenerator> DefaultGenerators = new Dictionary<string, DungeonGenerator>();

		public static FakeDungeonGenerator From(DungeonYaml data, string fileName)
		{
			//IL_0024: 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_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_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_00da: 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_00b8: Unknown result type (might be due to invalid IL or missing references)
			FakeDungeonGenerator fakeDungeonGenerator = new FakeDungeonGenerator();
			if (Enum.TryParse<Algorithm>(data.algorithm, ignoreCase: true, out Algorithm result))
			{
				fakeDungeonGenerator.m_algorithm = result;
			}
			else
			{
				Log.Warning(fileName + ": Failed to find dungeon algorithm " + data.algorithm + ".");
			}
			fakeDungeonGenerator.name = data.name;
			if (data.bounds == "")
			{
				fakeDungeonGenerator.m_zoneSize = new Vector3(64f, 256f, 64f);
			}
			else if (data.bounds.Contains(","))
			{
				fakeDungeonGenerator.m_zoneSize = Parse.VectorXZY(data.bounds, new Vector3(64f, 256f, 64f));
			}
			else
			{
				fakeDungeonGenerator.m_zoneSize = Parse.Float(data.bounds) * Vector3.one;
			}
			fakeDungeonGenerator.m_alternativeFunctionality = data.alternative || data.roomWeights;
			fakeDungeonGenerator.m_campRadiusMax = data.campRadiusMax;
			fakeDungeonGenerator.m_campRadiusMin = data.campRadiusMin;
			fakeDungeonGenerator.m_doorChance = data.doorChance;
			fakeDungeonGenerator.m_doorTypes = ((IEnumerable<DungeonDoorYaml>)data.doorTypes).Select((Func<DungeonDoorYaml, DoorDef>)((DungeonDoorYaml type) => new DoorDef
			{
				m_chance = type.chance,
				m_connectionType = type.connectionType,
				m_prefab = DataManager.ToPrefab(type.prefab, fileName)
			})).ToList();
			fakeDungeonGenerator.m_maxRooms = data.maxRooms;
			fakeDungeonGenerator.m_minRooms = data.minRooms;
			fakeDungeonGenerator.m_maxTilt = data.maxTilt;
			fakeDungeonGenerator.m_minAltitude = data.minAltitude;
			fakeDungeonGenerator.m_minRequiredRooms = data.minRequiredRooms;
			FakeDungeonGenerator fakeDungeonGenerator2 = fakeDungeonGenerator;
			HashSet<string> hashSet = new HashSet<string>();
			foreach (string item in RoomLoading.ParseRooms(data.excludedRooms))
			{
				hashSet.Add(item);
			}
			fakeDungeonGenerator2.m_excludedRooms = hashSet;
			fakeDungeonGenerator.m_requiredRooms = RoomLoading.ParseRooms(data.requiredRooms);
			fakeDungeonGenerator.m_themes = DataManager.ToList(data.themes);
			fakeDungeonGenerator.m_tileWidth = data.tileWidth;
			fakeDungeonGenerator.m_spawnChance = data.spawnChance;
			fakeDungeonGenerator.m_gridSize = data.gridSize;
			fakeDungeonGenerator.m_perimeterSections = data.perimeterSections;
			fakeDungeonGenerator.m_perimeterBuffer = data.perimeterBuffer;
			fakeDungeonGenerator.m_useCustomInteriorTransform = data.interiorTransform;
			fakeDungeonGenerator.m_randomSeed = data.randomSeed;
			if (data.objectSwap != null)
			{
				fakeDungeonGenerator.m_objectSwaps = Spawn.LoadSwaps(data.objectSwap);
			}
			if (data.objectData != null)
			{
				fakeDungeonGenerator.m_objectData = Spawn.LoadData(data.objectData, fileName);
			}
			return fakeDungeonGenerator;
		}

		public static DungeonYaml To(DungeonGenerator dg)
		{
			//IL_002f: 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_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0132: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Invalid comparison between Unknown and I4
			//IL_019b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a1: Invalid comparison between Unknown and I4
			DungeonYaml dungeonYaml = new DungeonYaml
			{
				name = Utils.GetPrefabName(((Component)dg).gameObject),
				algorithm = ((object)Unsafe.As<Algorithm, Algorithm>(ref dg.m_algorithm)/*cast due to .constrained prefix*/).ToString(),
				themes = DataManager.FromEnum<Theme>(dg.m_themes),
				interiorTransform = dg.m_useCustomInteriorTransform
			};
			if (dg.m_zoneSize.x == dg.m_zoneSize.y && dg.m_zoneSize.y == dg.m_zoneSize.z)
			{
				dungeonYaml.bounds = Helper.Print(dg.m_zoneSize.x);
			}
			else
			{
				dungeonYaml.bounds = Helper.Print(dg.m_zoneSize);
			}
			if ((int)dg.m_algorithm == 0)
			{
				dungeonYaml.doorChance = dg.m_doorChance;
				dungeonYaml.doorTypes = dg.m_doorTypes.Select((DoorDef type) => new DungeonDoorYaml
				{
					chance = type.m_chance,
					connectionType = type.m_connectionType,
					prefab = Utils.GetPrefabName(type.m_prefab)
				}).ToArray();
				dungeonYaml.maxRooms = dg.m_maxRooms;
				dungeonYaml.minRequiredRooms = dg.m_minRequiredRooms;
				dungeonYaml.minRooms = dg.m_minRooms;
				dungeonYaml.requiredRooms = DataManager.FromList(dg.m_requiredRooms);
				dungeonYaml.roomWeights = dg.m_alternativeFunctionality;
			}
			if ((int)dg.m_algorithm == 2)
			{
				dungeonYaml.campRadiusMax = dg.m_campRadiusMax;
				dungeonYaml.campRadiusMin = dg.m_campRadiusMin;
				dungeonYaml.minRooms = dg.m_minRooms;
				dungeonYaml.maxRooms = dg.m_maxRooms;
				dungeonYaml.maxTilt = dg.m_maxTilt;
				dungeonYaml.perimeterBuffer = dg.m_perimeterBuffer;
				dungeonYaml.perimeterSections = dg.m_perimeterSections;
				dungeonYaml.minAltitude = dg.m_minAltitude;
			}
			if ((int)dg.m_algorithm == 1)
			{
				dungeonYaml.maxTilt = dg.m_maxTilt;
				dungeonYaml.tileWidth = dg.m_tileWidth;
				dungeonYaml.gridSize = dg.m_gridSize;
				dungeonYaml.spawnChance = dg.m_spawnChance;
			}
			return dungeonYaml;
		}

		public static void AddDungeon(DungeonYaml yaml)
		{
			ExtraDungeonYamls.Add(yaml);
		}

		public static void Initialize()
		{
			EnvironmentBox.Cache.Clear();
			DefaultGenerators.Clear();
			if (Helper.IsServer())
			{
				DefaultGenerators = (from prefab in ZNetScene.instance.m_namedPrefabs.Values
					where Object.op_Implicit((Object)(object)prefab.GetComponent<DungeonGenerator>())
					select prefab.GetComponent<DungeonGenerator>()).ToDictionary((DungeonGenerator kvp) => ((Object)kvp).name, (DungeonGenerator kvp) => kvp);
			}
			Load();
		}

		private static void ToFile()
		{
			List<DungeonYaml> list = DefaultGenerators.Values.Select(To).ToList();
			if (ExtraDungeonYamls.Count > 0)
			{
				list.AddRange(ExtraDungeonYamls);
			}
			Save(list, log: false);
		}

		private static Dictionary<string, FakeDungeonGenerator> FromFile()
		{
			try
			{
				return DataManager.ReadData<DungeonYaml, FakeDungeonGenerator>(Pattern, From).ToDictionary((FakeDungeonGenerator data) => data.name);
			}
			catch (Exception ex)
			{
				Log.Error(ex.Message);
				Log.Error(ex.StackTrace);
			}
			return new Dictionary<string, FakeDungeonGenerator>();
		}

		public static void Load()
		{
			DungeonObjects.Generators.Clear();
			if (Helper.IsClient())
			{
				return;
			}
			if (!Configuration.DataRooms)
			{
				Log.Info("Reloading default dungeon entries).");
				return;
			}
			if (!File.Exists(FilePath))
			{
				ToFile();
				return;
			}
			Dictionary<string, FakeDungeonGenerator> dictionary = FromFile();
			if (dictionary.Count == 0)
			{
				Log.Warning("Failed to load any dungeon data.");
				Log.Info("Reloading default dungeon data.");
			}
			else if (!Configuration.DataMigration || !AddMissingEntries(dictionary))
			{
				Log.Info($"Reloading dungeon data ({dictionary.Count} entries).");
				DungeonObjects.Generators = dictionary;
			}
		}

		private static bool AddMissingEntries(Dictionary<string, FakeDungeonGenerator> entries)
		{
			Dictionary<string, DungeonGenerator> dictionary = DefaultGenerators.ToDictionary<KeyValuePair<string, DungeonGenerator>, string, DungeonGenerator>((KeyValuePair<string, DungeonGenerator> kvp) => kvp.Key, (KeyValuePair<string, DungeonGenerator> kvp) => kvp.Value);
			foreach (KeyValuePair<string, FakeDungeonGenerator> entry in entries)
			{
				dictionary.Remove(entry.Key);
			}
			if (dictionary.Count == 0)
			{
				return false;
			}
			Log.Warning($"Adding {dictionary.Count} missing dungeon generators to the expand_dungeons.yaml file.");
			Save(dictionary.Values.Select(To).ToList(), log: true);
			return true;
		}

		private static void Save(List<DungeonYaml> data, bool log)
		{
			Dictionary<string, List<DungeonYaml>> dictionary = new Dictionary<string, List<DungeonYaml>>();
			foreach (DungeonYaml datum in data)
			{
				string modFromPrefab = AssetTracker.GetModFromPrefab(datum.name);
				string key = (Configuration.SplitDataPerMod ? AssetTracker.GetFileNameFromMod(modFromPrefab) : "");
				if (!dictionary.ContainsKey(key))
				{
					dictionary[key] = new List<DungeonYaml>();
				}
				dictionary[key].Add(datum);
				if (log)
				{
					Log.Warning(modFromPrefab + ": " + datum.name);
				}
			}
			foreach (KeyValuePair<string, List<DungeonYaml>> item in dictionary)
			{
				string path = Path.Combine(Yaml.BaseDirectory, "expand_dungeons" + item.Key + ".yaml");
				string text = (File.Exists(path) ? (File.ReadAllText(path) + "\n") : "");
				text += Yaml.Serializer().Serialize((object)item.Value);
				File.WriteAllText(path, text);
			}
		}

		public static void SetupWatcher()
		{
			Yaml.SetupWatcher(Pattern, Load);
		}
	}
	public static class DungeonObjects
	{
		public static Dictionary<string, FakeDungeonGenerator> Generators = new Dictionary<string, FakeDungeonGenerator>();

		public static string CurrentDungeon = "";

		public static RoomData? CurrentRoom;

		public static Dictionary<RoomData, Dictionary<string, List<Tuple<float, DataEntry?>>>> ObjectData = new Dictionary<RoomData, Dictionary<string, List<Tuple<float, DataEntry>>>>();

		public static Dictionary<RoomData, List<BlueprintObject>> Objects = new Dictionary<RoomData, List<BlueprintObject>>();

		public static Dictionary<RoomData, Dictionary<string, List<Tuple<float, string>>>> ObjectSwaps = new Dictionary<RoomData, Dictionary<string, List<Tuple<float, string>>>>();

		public static string PrefabOverride(string prefab)
		{
			prefab = LocationSpawning.DungeonPrefabOverride(prefab);
			prefab = PrefabDungeonOverride(prefab);
			prefab = PrefabRoomOverride(prefab);
			return prefab;
		}

		private static string PrefabDungeonOverride(string prefab)
		{
			if (!Generators.TryGetValue(CurrentDungeon, out FakeDungeonGenerator value))
			{
				return prefab;
			}
			if (!value.m_objectSwaps.TryGetValue(prefab, out List<Tuple<float, string>> value2))
			{
				return prefab;
			}
			return Spawn.RandomizeSwap(value2);
		}

		public static string PrefabRoomOverride(string prefab)
		{
			if (!ObjectSwaps.TryGetValue(CurrentRoom, out Dictionary<string, List<Tuple<float, string>>> value))
			{
				return prefab;
			}
			if (!value.TryGetValue(prefab, out var value2))
			{
				return prefab;
			}
			return Spawn.RandomizeSwap(value2);
		}

		public static DataEntry? DataOverride(DataEntry? pgk, string prefab)
		{
			return DataHelper.Merge(DataHelper.Merge(DataHelper.Merge(DataHelper.Merge(null, LocationSpawning.DungeonDataOverride(prefab)), DataDungeonOverride(prefab)), DataRoomOverride(prefab)), pgk);
		}

		private static DataEntry? DataDungeonOverride(string prefab)
		{
			if (!Generators.TryGetValue(CurrentDungeon, out FakeDungeonGenerator value))
			{
				return null;
			}
			return Spawn.GetData(value.m_objectData, prefab);
		}

		public static DataEntry? DataRoomOverride(string prefab)
		{
			if (!ObjectData.TryGetValue(CurrentRoom, out Dictionary<string, List<Tuple<float, DataEntry>>> value))
			{
				return null;
			}
			return Spawn.GetData(value, prefab);
		}
	}
	[HarmonyPatch(typeof(DungeonGenerator))]
	public class Spawner
	{
		private static readonly List<RoomConnection> endConnections = new List<RoomConnection>();

		private static GameObject CustomObject(GameObject prefab, Vector3 pos, Quaternion rot)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: 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_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)
			if (DungeonObjects.CurrentRoom == null)
			{
				return Object.Instantiate<GameObject>(prefab, pos, rot);
			}
			return Spawn.BPO(new BlueprintObject(Utils.GetPrefabName(prefab), pos, rot, prefab.transform.localScale, null, 1f), 0, DungeonObjects.DataOverride, DungeonObjects.PrefabOverride, null) ?? LocationSpawning.DummySpawn;
		}

		private static IEnumerable<CodeInstruction> Transpile(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Expected O, but got Unknown
			MethodInfo methodInfo = AccessTools.FirstMethod(typeof(Object), (Func<MethodInfo, bool>)((MethodInfo info) => info.Name == "Instantiate" && info.IsGenericMethodDefinition && info.GetParameters().Length == 3 && info.GetParameters()[1].ParameterType == typeof(Vector3) && info.GetParameters()[2].ParameterType == typeof(Quaternion))).MakeGenericMethod(typeof(GameObject));
			return new CodeMatcher(instructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Call, (object)methodInfo, (string)null)
			}).Set(OpCodes.Call, Transpilers.EmitDelegate<Func<GameObject, Vector3, Quaternion, GameObject>>((Func<GameObject, Vector3, Quaternion, GameObject>)CustomObject).operand).InstructionEnumeration();
		}

		[HarmonyPatch("PlaceRoom", new Type[]
		{
			typeof(RoomConnection),
			typeof(RoomData),
			typeof(SpawnMode)
		})]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> FixConnections(IEnumerable<CodeInstruction> instructions)
		{
			//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
			return new CodeMatcher(instructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Stloc_1, (object)null, (string)null)
			}).Advance(-3).SetAndAdvance(OpCodes.Ldarg_2, (object)null)
				.SetAndAdvance(OpCodes.Callvirt, (object)AccessTools.PropertyGetter(typeof(RoomData), "RoomInPrefab"))
				.SetAndAdvance(OpCodes.Nop, (object)null)
				.InstructionEnumeration();
		}

		[HarmonyPatch("PlaceRoom", new Type[]
		{
			typeof(RoomData),
			typeof(Vector3),
			typeof(Quaternion),
			typeof(RoomConnection),
			typeof(SpawnMode)
		})]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> DungeonSpawnObjects(IEnumerable<CodeInstruction> instructions)
		{
			return Transpile(instructions);
		}

		[HarmonyPatch("PlaceDoors")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> DungeonSpawnDoors(IEnumerable<CodeInstruction> instructions)
		{
			return Transpile(instructions);
		}

		[HarmonyPatch("Generate", new Type[] { typeof(SpawnMode) })]
		[HarmonyPrefix]
		private static void Generate(DungeonGenerator __instance, SpawnMode mode)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Invalid comparison between Unknown and I4
			if ((int)mode != 1 && !Helper.IsClient())
			{
				string dungeonName = LocationExtra.GetDungeonName(LocationSpawning.CurrentLocation, __instance);
				Override(__instance, dungeonName);
				DungeonObjects.CurrentDungeon = dungeonName;
			}
		}

		[HarmonyPatch("GetWeightedRoom")]
		[HarmonyPrefix]
		private static bool GetWeightedRoomIndexCheck(List<RoomData> rooms)
		{
			return rooms.Count > 0;
		}

		[HarmonyPatch("PlaceRoom", new Type[]
		{
			typeof(RoomConnection),
			typeof(RoomData),
			typeof(SpawnMode)
		})]
		[HarmonyPrefix]
		private static bool PlaceRoomNullCheck(RoomConnection connection, RoomData roomData)
		{
			if (roomData == null)
			{
				Log.Warning("No room found for connection type " + connection.m_type);
				return false;
			}
			return true;
		}

		[HarmonyPatch("PlaceRoom", new Type[]
		{
			typeof(RoomData),
			typeof(Vector3),
			typeof(Quaternion),
			typeof(RoomConnection),
			typeof(SpawnMode)
		})]
		[HarmonyPrefix]
		private static void SpawnBlueprintRoom(RoomData roomData, Vector3 pos, Quaternion rot, SpawnMode mode)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Invalid comparison between Unknown and I4
			//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_0036: Unknown result type (might be due to invalid IL or missing references)
			if (Configuration.DataRooms && (int)mode != 1 && !Helper.IsClient())
			{
				DungeonObjects.CurrentRoom = roomData;
				if (RoomSpawning.Blueprints.TryGetValue(roomData, out string value) && BlueprintManager.TryGet(value, out Blueprint bp))
				{
					Spawn.Blueprint(bp, pos, rot, Vector3.one, 0, DungeonObjects.DataOverride, DungeonObjects.PrefabOverride, null);
				}
			}
		}

		[HarmonyPatch("PlaceRoom", new Type[]
		{
			typeof(RoomData),
			typeof(Vector3),
			typeof(Quaternion),
			typeof(RoomConnection),
			typeof(SpawnMode)
		})]
		[HarmonyPostfix]
		private static void PlaceRoomCustomObjects(RoomData roomData, Vector3 pos, Quaternion rot, SpawnMode mode)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Invalid comparison between Unknown and I4
			//IL_0025: 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_0040: 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_0053: 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_0086: 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_00e2: Unknown result type (might be due to invalid IL or missing references)
			if (!Configuration.DataRooms || (int)mode == 1 || Helper.IsClient())
			{
				return;
			}
			if (DungeonObjects.Objects.TryGetValue(roomData, out List<BlueprintObject> value))
			{
				int num = (int)pos.x * 4271 + (int)pos.y * 9187 + (int)pos.z * 2134;
				State state = Random.state;
				Random.InitState(num);
				foreach (BlueprintObject item in value)
				{
					if (!(item.Chance < 1f) || !(Random.value > item.Chance))
					{
						Spawn.BPO(item, pos, rot, Vector3.one, 0, DungeonObjects.DataOverride, DungeonObjects.PrefabOverride, null);
					}
				}
				Random.state = state;
			}
			DungeonObjects.CurrentRoom = null;
		}

		[HarmonyPatch("Generate", new Type[] { typeof(SpawnMode) })]
		[HarmonyPostfix]
		private static void GenerateEnd()
		{
			DungeonObjects.CurrentDungeon = "";
		}

		[HarmonyPatch("GenerateRooms", new Type[] { typeof(SpawnMode) })]
		[HarmonyPostfix]
		private static void GenerateRooms()
		{
			Log.Info($"Dungeon generated with {DungeonGenerator.m_placedRooms.Count} rooms.");
		}

		[HarmonyPatch("GetSeed")]
		[HarmonyPrefix]
		private static void GetSeed()
		{
			LocationYaml data;
			FakeDungeonGenerator value;
			if (Configuration.RandomLocations)
			{
				DungeonGenerator.m_forceSeed = DateTime.Now.Ticks.GetHashCode();
			}
			else if (Configuration.DataLocation && LocationSpawning.CurrentLocation != null && LocationExtra.TryGetData(LocationSpawning.CurrentLocation, out data) && data.randomSeed)
			{
				DungeonGenerator.m_forceSeed = DateTime.Now.Ticks.GetHashCode();
			}
			else if (Configuration.DataDungeons && DungeonObjects.Generators.TryGetValue(DungeonObjects.CurrentDungeon, out value) && value.m_randomSeed)
			{
				DungeonGenerator.m_forceSeed = DateTime.Now.Ticks.GetHashCode();
			}
		}

		public static void Override(DungeonGenerator dg, string name)
		{
			//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_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_00ba: 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)
			if (DungeonObjects.Generators.TryGetValue(name, out FakeDungeonGenerator value))
			{
				((Object)dg).name = name;
				dg.m_algorithm = value.m_algorithm;
				dg.m_zoneSize = value.m_zoneSize;
				dg.m_alternativeFunctionality = value.m_alternativeFunctionality;
				dg.m_campRadiusMax = value.m_campRadiusMax;
				dg.m_campRadiusMin = value.m_campRadiusMin;
				dg.m_doorChance = value.m_doorChance;
				dg.m_doorTypes = value.m_doorTypes;
				dg.m_maxRooms = value.m_maxRooms;
				dg.m_minRooms = value.m_minRooms;
				dg.m_maxTilt = value.m_maxTilt;
				dg.m_minAltitude = value.m_minAltitude;
				dg.m_minRequiredRooms = value.m_minRequiredRooms;
				dg.m_requiredRooms = value.m_requiredRooms;
				dg.m_themes = DataManager.ToEnum<Theme>(value.m_themes);
				dg.m_gridSize = value.m_gridSize;
				dg.m_tileWidth = value.m_tileWidth;
				dg.m_spawnChance = value.m_spawnChance;
				dg.m_perimeterSections = value.m_perimeterSections;
				dg.m_perimeterBuffer = value.m_perimeterBuffer;
				dg.m_useCustomInteriorTransform = value.m_useCustomInteriorTransform;
			}
		}

		[HarmonyPatch("SetupAvailableRooms")]
		[HarmonyPostfix]
		public static void SetupAvailableRooms(DungeonGenerator __instance)
		{
			if (Helper.IsClient())
			{
				return;
			}
			string prefabName = Utils.GetPrefabName(((Component)__instance).gameObject);
			if (DungeonObjects.Generators.TryGetValue(prefabName, out FakeDungeonGenerator gen) && gen.m_excludedRooms.Count != 0)
			{
				DungeonGenerator.m_availableRooms = DungeonGenerator.m_availableRooms.Where((RoomData room) => !gen.m_excludedRooms.Contains(room.m_prefab.Name)).ToList();
			}
		}

		private static void MoveConnection(RoomConnection conn)
		{
			endConnections.Add(conn);
			DungeonGenerator.m_openConnections.Remove(conn);
		}

		[HarmonyPatch("PlaceOneRoom")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> PlaceOneRoom(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0002: 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_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Expected O, but got Unknown
			return new CodeMatcher(instructions, (ILGenerator)null).End().Advance(-1).Insert((CodeInstruction[])(object)new CodeInstruction[2]
			{
				new CodeInstruction(OpCodes.Ldloc_0, (object)null),
				new CodeInstruction(OpCodes.Call, Transpilers.EmitDelegate<Action<RoomConnection>>((Action<RoomConnection>)MoveConnection).operand)
			})
				.InstructionEnumeration();
		}

		[HarmonyPatch("CheckRequiredRooms")]
		[HarmonyPrefix]
		public static bool CheckRequiredRooms(ref bool __result)
		{
			if (DungeonGenerator.m_openConnections.Count == 0)
			{
				__result = true;
				return false;
			}
			return true;
		}

		[HarmonyPatch("PlaceRooms")]
		[HarmonyPostfix]
		public static void PlaceRooms()
		{
			foreach (RoomConnection endConnection in endConnections)
			{
				DungeonGenerator.m_openConnections.Add(endConnection);
			}
			endConnections.Clear();
		}

		[HarmonyPatch("AddOpenConnections")]
		[HarmonyPrefix]
		private static void AddOpenConnections(Room newRoom)
		{
			if (DungeonObjects.CurrentRoom != null && DungeonDB.instance.GetRoom(newRoom.GetHash()) != null && RoomSpawning.Data.TryGetValue(DungeonObjects.CurrentRoom, out RoomYaml value))
			{
				((Object)newRoom).name = value.name;
				RoomConnection[] connections = newRoom.GetConnections();
				for (int i = 0; i < value.connections.Length && i < connections.Length; i++)
				{
					RoomConnectionYaml roomConnectionYaml = value.connections[i];
					RoomConnection obj = connections[i];
					obj.m_type = (roomConnectionYaml.type.StartsWith(">") ? roomConnectionYaml.type.Substring(1) : roomConnectionYaml.type);
					obj.m_entrance = roomConnectionYaml.entrance;
					obj.m_allowDoor = roomConnectionYaml.door == "true";
					obj.m_doorOnlyIfOtherAlsoAllowsDoor = roomConnectionYaml.door == "other";
				}
			}
		}
	}
	[HarmonyPatch]
	public class EnvironmentBox
	{
		public static Dictionary<Vector2i, Vector3> Cache = new Dictionary<Vector2i, Vector3>();

		private static void TryScale(Location loc)
		{
			//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_0010: 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_0040: 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_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_0060: 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_0078: 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_0094: Unknown result type (might be due to invalid IL or missing references)
			Vector2i zone = ZoneSystem.GetZone(((Component)loc).transform.position);
			if (Cache.TryGetValue(zone, out var value) && loc.m_hasInterior)
			{
				EnvZone componentInChildren = ((Component)loc).GetComponentInChildren<EnvZone>();
				if (Object.op_Implicit((Object)(object)componentInChildren))
				{
					Vector3 localScale = ((Component)componentInChildren).transform.localScale;
					value.x = Mathf.Max(value.x, localScale.x);
					value.y = Mathf.Max(value.y, localScale.y);
					value.z = Mathf.Max(value.z, localScale.z);
					((Component)componentInChildren).transform.localScale = value;
				}
			}
		}

		[HarmonyPatch(typeof(DungeonGenerator), "Load")]
		[HarmonyPostfix]
		private static void ScaleEnvironmentBox1(DungeonGenerator __instance)
		{
			//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)
			//IL_0013: 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_001f: 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_002d: 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_003a: 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_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_007c: 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_00b8: 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_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: 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_00d5: 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_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: 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_0122: 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_013e: Unknown result type (might be due to invalid IL or missing references)
			//IL_015d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0166: 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)
			//IL_0182: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01af: 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)
			Vector3 position = ((Component)__instance).transform.position;
			Vector2i zone = ZoneSystem.GetZone(position);
			Vector3 zonePos = ZoneSystem.GetZonePos(zone);
			zonePos.y = position.y;
			Vector3 val = zonePos;
			List<BoxCollider> list = ((Component)__instance).GetComponentsInChildren<Room>().SelectMany((Room room) => ((Component)room).GetComponentsInChildren<BoxCollider>()).ToList();
			Bounds val2 = default(Bounds);
			((Bounds)(ref val2)).center = val;
			Bounds val3 = val2;
			foreach (BoxCollider item in list)
			{
				((Bounds)(ref val3)).Encapsulate(((Collider)item).bounds);
			}
			Vector3 val4 = ((Bounds)(ref val3)).center - val;
			Vector3 zero = Vector3.zero;
			float num = -1f;
			zero.x = Mathf.Max(Mathf.Abs(val4.x + ((Bounds)(ref val3)).extents.x) + num, Mathf.Abs(val4.x - ((Bounds)(ref val3)).extents.x) + num);
			zero.y = Mathf.Max(Mathf.Abs(val4.y + ((Bounds)(ref val3)).extents.y) + num, Mathf.Abs(val4.y - ((Bounds)(ref val3)).extents.y) + num);
			zero.z = Mathf.Max(Mathf.Abs(val4.z + ((Bounds)(ref val3)).extents.z) + num, Mathf.Abs(val4.z - ((Bounds)(ref val3)).extents.z) + num);
			Cache[zone] = 2f * zero;
			Location[] array = Location.s_allLocations.Where((Location loc) => ZoneSystem.GetZone(((Component)loc).transform.position) == zone).ToArray();
			for (int num2 = 0; num2 < array.Length; num2++)
			{
				TryScale(array[num2]);
			}
		}

		[HarmonyPatch(typeof(Location), "Awake")]
		[HarmonyPostfix]
		private static void ScaleEnvironmentBox2(Location __instance)
		{
			TryScale(__instance);
		}
	}
}