using System;
using System.Collections;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.IO;
using System.IO.Compression;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Serialization;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using System.Text.RegularExpressions;
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.Core;
using YamlDotNet.Core.Events;
using YamlDotNet.Core.Tokens;
using YamlDotNet.Helpers;
using YamlDotNet.Serialization;
using YamlDotNet.Serialization.Converters;
using YamlDotNet.Serialization.EventEmitters;
using YamlDotNet.Serialization.NamingConventions;
using YamlDotNet.Serialization.NodeDeserializers;
using YamlDotNet.Serialization.NodeTypeResolvers;
using YamlDotNet.Serialization.ObjectFactories;
using YamlDotNet.Serialization.ObjectGraphTraversalStrategies;
using YamlDotNet.Serialization.ObjectGraphVisitors;
using YamlDotNet.Serialization.Schemas;
using YamlDotNet.Serialization.TypeInspectors;
using YamlDotNet.Serialization.TypeResolvers;
using YamlDotNet.Serialization.Utilities;
using YamlDotNet.Serialization.ValueDeserializers;

[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+e828d7868b8bc7cf821bdfca68b7b44db6b402af")]
[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 = default(T5));
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

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

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
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 j = 0; j < array3.Length; j++)
				{
					if (!(array3[j] == "") || j + 1 >= array3.Length)
					{
						num2 = (num2.HasValue ? (num2 - EvaluateDouble(array3[j])) : new double?(EvaluateDouble(array3[j])));
					}
					else
					{
						array3[j + 1] = "-" + array3[j + 1];
					}
				}
				return num2.GetValueOrDefault();
			}
			string[] array4 = expression.Split(new char[1] { '*' });
			if (array4.Length > 1)
			{
				double num3 = 1.0;
				string[] array2 = array4;
				foreach (string expression3 in array2)
				{
					num3 *= EvaluateDouble(expression3);
				}
				return num3;
			}
			string[] array5 = expression.Split(new char[1] { '/' });
			if (array5.Length > 1)
			{
				double num4 = EvaluateDouble(array5[0]);
				for (int k = 1; k < array5.Length; k++)
				{
					num4 /= EvaluateDouble(array5[k]);
				}
				return num4;
			}
			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 j = 0; j < array3.Length; j++)
				{
					if (!(array3[j] == "") || j + 1 >= array3.Length)
					{
						num2 = (num2.HasValue ? (num2 - EvalLong(array3[j])) : new long?(EvalLong(array3[j])));
					}
					else
					{
						array3[j + 1] = "-" + array3[j + 1];
					}
				}
				return num2.GetValueOrDefault();
			}
			string[] array4 = expression.Split(new char[1] { '*' });
			if (array4.Length > 1)
			{
				long num3 = 1L;
				string[] array2 = array4;
				foreach (string expression3 in array2)
				{
					num3 *= EvalLong(expression3);
				}
				return num3;
			}
			string[] array5 = expression.Split(new char[1] { '/' });
			if (array5.Length > 1)
			{
				long num4 = EvalLong(array5[0]);
				for (int k = 1; k < array5.Length; k++)
				{
					num4 /= EvalLong(array5[k]);
				}
				return num4;
			}
			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;
	}
	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 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
			this.Load(new ZPackage(base64));
		}

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

		public DataEntry(ZDO zdo)
		{
			Load(zdo);
		}

		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(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_000d: 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_0071: 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_00d5: 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_0139: 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_019d: 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_0201: 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_0265: Unknown result type (might be due to invalid IL or missing references)
			//IL_0275: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fb: 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_02d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0306: Unknown result type (might be due to invalid IL or missing references)
			//IL_030b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0319: Unknown result type (might be due to invalid IL or missing references)
			//IL_032a: Unknown result type (might be due to invalid IL or missing references)
			//IL_032f: Unknown result type (might be due to invalid IL or missing references)
			ZDOID uid = zdo.m_uid;
			Floats = (ZDOExtraData.s_floats.ContainsKey(uid) ? ((IEnumerable<KeyValuePair<int, float>>)ZDOExtraData.s_floats[uid]).ToDictionary((KeyValuePair<int, float> kvp) => kvp.Key, (KeyValuePair<int, float> kvp) => DataValue.Simple(kvp.Value)) : null);
			Ints = (ZDOExtraData.s_ints.ContainsKey(uid) ? ((IEnumerable<KeyValuePair<int, int>>)ZDOExtraData.s_ints[uid]).ToDictionary((KeyValuePair<int, int> kvp) => kvp.Key, (KeyValuePair<int, int> kvp) => DataValue.Simple(kvp.Value)) : null);
			Longs = (ZDOExtraData.s_longs.ContainsKey(uid) ? ((IEnumerable<KeyValuePair<int, long>>)ZDOExtraData.s_longs[uid]).ToDictionary((KeyValuePair<int, long> kvp) => kvp.Key, (KeyValuePair<int, long> kvp) => DataValue.Simple(kvp.Value)) : null);
			Strings = (ZDOExtraData.s_strings.ContainsKey(uid) ? ((IEnumerable<KeyValuePair<int, string>>)ZDOExtraData.s_strings[uid]).ToDictionary((KeyValuePair<int, string> kvp) => kvp.Key, (KeyValuePair<int, string> kvp) => DataValue.Simple(kvp.Value)) : null);
			Vecs = (ZDOExtraData.s_vec3.ContainsKey(uid) ? ((IEnumerable<KeyValuePair<int, Vector3>>)ZDOExtraData.s_vec3[uid]).ToDictionary((KeyValuePair<int, Vector3> kvp) => kvp.Key, (KeyValuePair<int, Vector3> kvp) => DataValue.Simple(kvp.Value)) : null);
			Quats = (ZDOExtraData.s_quats.ContainsKey(uid) ? ((IEnumerable<KeyValuePair<int, Quaternion>>)ZDOExtraData.s_quats[uid]).ToDictionary((KeyValuePair<int, Quaternion> kvp) => kvp.Key, (KeyValuePair<int, Quaternion> kvp) => DataValue.Simple(kvp.Value)) : null);
			ByteArrays = (ZDOExtraData.s_byteArrays.ContainsKey(uid) ? ((IEnumerable<KeyValuePair<int, byte[]>>)ZDOExtraData.s_byteArrays[uid]).ToDictionary((KeyValuePair<int, byte[]> kvp) => kvp.Key, (KeyValuePair<int, byte[]> kvp) => kvp.Value) : null);
			if (ZDOExtraData.s_connectionsHashData.TryGetValue(uid, out var value))
			{
				ConnectionType = value.m_type;
				ConnectionHash = value.m_hash;
			}
			OriginalId = new SimpleZdoIdValue(uid);
			if (ZDOExtraData.s_connections.TryGetValue(uid, out var value2) && value2.m_target != ZDOID.None)
			{
				TargetConnectionId = new SimpleZdoIdValue(value2.m_target);
				ConnectionType = value2.m_type;
			}
		}

		public void Load(DataEntry data)
		{
			//IL_0411: Unknown result type (might be due to invalid IL or missing references)
			//IL_0416: Unknown result type (might be due to invalid IL or missing references)
			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.Position != null)
			{
				Position = data.Position;
			}
			if (data.Rotation != null)
			{
				Rotation = data.Rotation;
			}
		}

		public DataEntry Reset(DataData data)
		{
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			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 = (ConnectionType)0;
			ConnectionHash = 0;
			OriginalId = null;
			TargetConnectionId = null;
			Position = null;
			Rotation = null;
			Load(data);
			return this;
		}

		public void Load(DataData data)
		{
			//IL_0765: Unknown result type (might be due to invalid IL or missing references)
			//IL_089e: Unknown result type (might be due to invalid IL or missing references)
			//IL_08a3: 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]);
					}
					Floats.Add(Hash(keyValuePair.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]);
					}
					Ints.Add(Hash(keyValuePair2.Key), 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]);
					}
					Bools.Add(Hash(keyValuePair3.Key), 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]);
					}
					Hashes.Add(Hash(keyValuePair4.Key), 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]);
					}
					Longs.Add(Hash(keyValuePair5.Key), 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]);
					}
					Strings.Add(Hash(keyValuePair6.Key), 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]);
					}
					Vecs.Add(Hash(keyValuePair7.Key), 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]);
					}
					Quats.Add(Hash(keyValuePair8.Key), 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]);
					}
					ByteArrays.Add(Hash(keyValuePair9.Key), Convert.FromBase64String(keyValuePair9.Value));
				}
			}
			if (data.items != null)
			{
				Items = data.items.Select((ItemData item) => new ItemValue(item)).ToList();
			}
			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 (string.IsNullOrWhiteSpace(data.connection))
			{
				return;
			}
			string[] array = Parse.SplitWithEmpty(data.connection);
			if (array.Length <= 1)
			{
				return;
			}
			List<string> list = array.Take(array.Length - 1).ToList();
			string text10 = array[^1];
			ConnectionType = ToByteEnum<ConnectionType>(list);
			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)
			//IL_0232: Unknown result type (might be due to invalid IL or missing references)
			pkg.SetPos(0);
			int num = pkg.ReadInt();
			if (((uint)num & (true ? 1u : 0u)) != 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 (((uint)num & 2u) != 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 (((uint)num & 4u) != 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 (((uint)num & 8u) != 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 (((uint)num & 0x40u) != 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 (((uint)num & 0x10u) != 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 (((uint)num & 0x80u) != 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 (((uint)num & 0x100u) != 0)
			{
				ConnectionType = (ConnectionType)pkg.ReadByte();
				ConnectionHash = pkg.ReadInt();
			}
		}

		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_04f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_04f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0501: Unknown result type (might be due to invalid IL or missing references)
			//IL_0506: Unknown result type (might be due to invalid IL or missing references)
			//IL_0532: Unknown result type (might be due to invalid IL or missing references)
			//IL_0537: Unknown result type (might be due to invalid IL or missing references)
			//IL_053b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0540: 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)
			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> int2 in Ints)
				{
					int? num2 = int2.Value.Get(pars);
					if (num2.HasValue)
					{
						ZDOExtraData.s_ints[uid].SetValue(int2.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? @int = @bool.Value.GetInt(pars);
					if (@int.HasValue)
					{
						ZDOExtraData.s_ints[uid].SetValue(@bool.Key, @int.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? num4 = @long.Value.Get(pars);
					if (num4.HasValue)
					{
						ZDOExtraData.s_longs[uid].SetValue(@long.Key, num4.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);
				}
			}
			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_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_0036: 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_0047: 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_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Invalid comparison between Unknown and I4
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			if (OriginalId == null)
			{
				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, val.Value);
					if ((int)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_000a: 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)
			//IL_0019: 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_002c: 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_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_003e: Invalid comparison between Unknown and I4
			//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)
			//IL_0058: 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_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Invalid comparison between Unknown and I4
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Invalid comparison between Unknown and I4
			//IL_00c5: 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: Invalid comparison between Unknown and I4
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: 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_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			if (ConnectionHash == 0 || (int)ConnectionType == 0)
			{
				return;
			}
			ZDOID uid = ownZdo.m_uid;
			ZDOExtraData.SetConnectionData(uid, ConnectionType, ConnectionHash);
			? val = ConnectionType ^ 0x10;
			bool flag = (ConnectionType & 0x10) == 0;
			ZDOID val2 = ((IEnumerable<ZDOID>)ZDOExtraData.GetAllConnectionZDOIDs((ConnectionType)val)).FirstOrDefault((Func<ZDOID, bool>)((ZDOID z) => ZDOExtraData.GetConnectionHashData(z, ConnectionType)?.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 bool Match(Parameters pars, ZDO zdo)
		{
			//IL_0196: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ac: 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_01b6: 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_01d3: 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_01e6: Unknown result type (might be due to invalid IL or missing references)
			Parameters pars2 = pars;
			ZDO zdo2 = zdo;
			if (Strings != null && Strings.Any<KeyValuePair<int, IStringValue>>((KeyValuePair<int, IStringValue> pair) => pair.Value.Match(pars2, zdo2.GetString(pair.Key, "")) == false))
			{
				return false;
			}
			if (Floats != null && Floats.Any<KeyValuePair<int, IFloatValue>>((KeyValuePair<int, IFloatValue> pair) => pair.Value.Match(pars2, zdo2.GetFloat(pair.Key, 0f)) == false))
			{
				return false;
			}
			if (Ints != null && Ints.Any<KeyValuePair<int, IIntValue>>((KeyValuePair<int, IIntValue> pair) => pair.Value.Match(pars2, zdo2.GetInt(pair.Key, 0)) == false))
			{
				return false;
			}
			if (Longs != null && Longs.Any<KeyValuePair<int, ILongValue>>((KeyValuePair<int, ILongValue> pair) => pair.Value.Match(pars2, zdo2.GetLong(pair.Key, 0L)) == false))
			{
				return false;
			}
			if (Bools != null && Bools.Any<KeyValuePair<int, IBoolValue>>((KeyValuePair<int, IBoolValue> pair) => pair.Value.Match(pars2, zdo2.GetBool(pair.Key, false)) == false))
			{
				return false;
			}
			if (Hashes != null && Hashes.Any<KeyValuePair<int, IHashValue>>((KeyValuePair<int, IHashValue> pair) => pair.Value.Match(pars2, zdo2.GetInt(pair.Key, 0)) == false))
			{
				return false;
			}
			if (Vecs != null && Vecs.Any<KeyValuePair<int, IVector3Value>>((KeyValuePair<int, IVector3Value> pair) => pair.Value.Match(pars2, zdo2.GetVec3(pair.Key, Vector3.zero)) == false))
			{
				return false;
			}
			if (Quats != null && Quats.Any<KeyValuePair<int, IQuaternionValue>>((KeyValuePair<int, IQuaternionValue> pair) => pair.Value.Match(pars2, zdo2.GetQuaternion(pair.Key, Quaternion.identity)) == false))
			{
				return false;
			}
			if (ByteArrays != null && ByteArrays.Any<KeyValuePair<int, byte[]>>((KeyValuePair<int, byte[]> pair) => !pair.Value.SequenceEqual(zdo2.GetByteArray(pair.Key, (byte[])null))))
			{
				return false;
			}
			if (Items != null)
			{
				return ItemValue.Match(pars2, Items, zdo2, ItemAmount);
			}
			if (ItemAmount != null)
			{
				return ItemValue.Match(pars2, zdo2, ItemAmount);
			}
			if ((int)ConnectionType != 0 && TargetConnectionId != null)
			{
				ZDOID connectionZDOID = zdo2.GetConnectionZDOID(ConnectionType);
				ZDOID? val = TargetConnectionId.Get(pars2);
				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_019c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b7: 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_01d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d9: 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_01ec: Unknown result type (might be due to invalid IL or missing references)
			Parameters pars2 = pars;
			ZDO zdo2 = zdo;
			if (Strings != null && Strings.Any<KeyValuePair<int, IStringValue>>((KeyValuePair<int, IStringValue> pair) => pair.Value.Match(pars2, zdo2.GetString(pair.Key, "")).GetValueOrDefault()))
			{
				return false;
			}
			if (Floats != null && Floats.Any<KeyValuePair<int, IFloatValue>>((KeyValuePair<int, IFloatValue> pair) => pair.Value.Match(pars2, zdo2.GetFloat(pair.Key, 0f)).GetValueOrDefault()))
			{
				return false;
			}
			if (Ints != null && Ints.Any<KeyValuePair<int, IIntValue>>((KeyValuePair<int, IIntValue> pair) => pair.Value.Match(pars2, zdo2.GetInt(pair.Key, 0)).GetValueOrDefault()))
			{
				return false;
			}
			if (Longs != null && Longs.Any<KeyValuePair<int, ILongValue>>((KeyValuePair<int, ILongValue> pair) => pair.Value.Match(pars2, zdo2.GetLong(pair.Key, 0L)).GetValueOrDefault()))
			{
				return false;
			}
			if (Bools != null && Bools.Any<KeyValuePair<int, IBoolValue>>((KeyValuePair<int, IBoolValue> pair) => pair.Value.Match(pars2, zdo2.GetBool(pair.Key, false)).GetValueOrDefault()))
			{
				return false;
			}
			if (Hashes != null && Hashes.Any<KeyValuePair<int, IHashValue>>((KeyValuePair<int, IHashValue> pair) => pair.Value.Match(pars2, zdo2.GetInt(pair.Key, 0)).GetValueOrDefault()))
			{
				return false;
			}
			if (Vecs != null && Vecs.Any<KeyValuePair<int, IVector3Value>>((KeyValuePair<int, IVector3Value> pair) => pair.Value.Match(pars2, zdo2.GetVec3(pair.Key, Vector3.zero)).GetValueOrDefault()))
			{
				return false;
			}
			if (Quats != null && Quats.Any<KeyValuePair<int, IQuaternionValue>>((KeyValuePair<int, IQuaternionValue> pair) => pair.Value.Match(pars2, zdo2.GetQuaternion(pair.Key, Quaternion.identity)).GetValueOrDefault()))
			{
				return false;
			}
			if (ByteArrays != null && ByteArrays.Any<KeyValuePair<int, byte[]>>((KeyValuePair<int, byte[]> pair) => pair.Value.SequenceEqual(zdo2.GetByteArray(pair.Key, (byte[])null))))
			{
				return false;
			}
			if (Items != null)
			{
				return !ItemValue.Match(pars2, Items, zdo2, ItemAmount);
			}
			if (ItemAmount != null)
			{
				return !ItemValue.Match(pars2, zdo2, ItemAmount);
			}
			if ((int)ConnectionType != 0 && TargetConnectionId != null)
			{
				ZDOID connectionZDOID = zdo2.GetConnectionZDOID(ConnectionType);
				ZDOID? val = TargetConnectionId.Get(pars2);
				if (val.HasValue)
				{
					ZDOID val2 = connectionZDOID;
					ZDOID? val3 = val;
					if (val3.HasValue && val2 == val3.GetValueOrDefault())
					{
						return false;
					}
				}
			}
			return true;
		}

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

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

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

		private 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 class DataHelper
	{
		public static void Init(GameObject obj, Vector3 pos, Quaternion rot, Vector3? scale, DataEntry? data, Dictionary<string, string> pars)
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: 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)
			ZNetView val = default(ZNetView);
			if ((data != null || scale.HasValue) && obj.TryGetComponent<ZNetView>(ref val))
			{
				string prefabName = Utils.GetPrefabName(obj);
				int stableHashCode = StringExtensionMethods.GetStableHashCode(prefabName);
				ZNetView.m_initZDO = ZDOMan.instance.CreateNewZDO(pos, stableHashCode);
				data?.Write(new ObjectParameters(prefabName, "", ZNetView.m_initZDO), ZNetView.m_initZDO);
				ZNetView.m_initZDO.m_rotation = ((Quaternion)(ref rot)).eulerAngles;
				ZNetView.m_initZDO.Type = val.m_type;
				ZNetView.m_initZDO.Distant = val.m_distant;
				ZNetView.m_initZDO.Persistent = 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();
			}
		}

		public static ZDO? Init(GameObject obj, Vector3 pos, Quaternion rot, Vector3? scale, DataEntry? data)
		{
			//IL_002e: 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_0071: 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)
			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);
			data?.Write(new ObjectParameters(prefabName, "", ZNetView.m_initZDO), ZNetView.m_initZDO);
			ZNetView.m_initZDO.m_rotation = ((Quaternion)(ref rot)).eulerAngles;
			ZNetView.m_initZDO.Type = val.m_type;
			ZNetView.m_initZDO.Distant = val.m_distant;
			ZNetView.m_initZDO.Persistent = 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(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)
		{
			if (!(name == ""))
			{
				return DataLoading.Get(name);
			}
			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" || 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 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)
		{
			int stableHashCode = StringExtensionMethods.GetStableHashCode(name);
			if (!Data.ContainsKey(stableHashCode))
			{
				try
				{
					Data[stableHashCode] = new DataEntry(name);
				}
				catch (Exception innerException)
				{
					if (name.Contains("=") || name.Length > 32)
					{
						throw new InvalidOperationException("Can't load data value: " + name, innerException);
					}
					throw new InvalidOperationException("Can't find data entry: " + name, innerException);
				}
			}
			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").Concat(Directory.GetFiles(ProfilePath, "*.yaml")).Concat(Directory.GetFiles(Yaml.BaseDirectory, Pattern))
				.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));
			}
		}

		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;
				}
				value.GetComponentsInChildren<MonoBehaviour>(ZNetView.m_tempComponents);
				foreach (MonoBehaviour tempComponent in ZNetView.m_tempComponents)
				{
					int stableHashCode = StringExtensionMethods.GetStableHashCode(((object)tempComponent).GetType().Name.ToLowerInvariant());
					if (!DefaultValueGroups.ContainsKey(stableHashCode))
					{
						DefaultValueGroups[stableHashCode] = new List<string>();
					}
					DefaultValueGroups[stableHashCode].Add(((Object)value).name);
				}
			}
			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
	{
		protected readonly string[] Values;

		public AnyValue(string[] values)
		{
			Values = values;
			base..ctor();
		}

		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)
		{
			Parameters pars2 = pars;
			Inventory inv = CreateInventory(zdo);
			int num = data.Where((ItemValue item) => item.Match(pars2, inv)).Count();
			if (amount == null)
			{
				if (num == data.Count)
				{
					return inv.m_inventory.Count == 0;
				}
				return false;
			}
			return amount.Match(pars2, num).GetValueOrDefault();
		}

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

		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 @string = zdo.GetString(ZDOVars.s_items, "");
			if (@string != "")
			{
				ZPackage val2 = new ZPackage(@string);
				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 i = 0; i < amount; i++)
			{
				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)).GetValueOrDefault(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 valueOrDefault = (Quality?.Get(pars)).GetValueOrDefault(1);
			float? num = Durability?.Get(pars);
			if (!num.HasValue)
			{
				ItemDrop val = default(ItemDrop);
				num = ((!((Object)(object)itemPrefab != (Object)null) || !itemPrefab.TryGetComponent<ItemDrop>(ref val)) ? new float?(100f) : new float?(val.m_itemData.GetMaxDurability(valueOrDefault)));
			}
			pkg.Write(RolledStack);
			pkg.Write(num.Value);
			pkg.Write(RolledPosition);
			pkg.Write((Equipped?.GetBool(pars)).GetValueOrDefault());
			pkg.Write(valueOrDefault);
			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)).GetValueOrDefault());
		}

		public void AddTo(Parameters pars, Inventory inv)
		{
			int valueOrDefault = (Stack?.Get(pars)).GetValueOrDefault(1);
			valueOrDefault = StackTo(pars, valueOrDefault, inv);
			InsertTo(pars, valueOrDefault, 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)
			Parameters pars2 = pars;
			ItemDrop val = default(ItemDrop);
			while (stack > 0)
			{
				int valueOrDefault = Prefab.Get(pars2).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(pars2)).GetValueOrDefault(1);
				val2.m_variant = (Variant?.Get(pars2)).GetValueOrDefault();
				val2.m_crafterID = (CrafterID?.Get(pars2)).GetValueOrDefault();
				val2.m_crafterName = CrafterName?.Get(pars2) ?? "";
				val2.m_worldLevel = (WorldLevel?.Get(pars2)).GetValueOrDefault();
				val2.m_durability = Durability?.Get(pars2) ?? val2.GetMaxDurability(val2.m_quality);
				val2.m_equipped = (Equipped?.GetBool(pars2)).GetValueOrDefault();
				val2.m_pickedUp = (PickedUp?.GetBool(pars2)).GetValueOrDefault();
				val2.m_customData = CustomData.ToDictionary<KeyValuePair<string, IStringValue>, string, string>((KeyValuePair<string, IStringValue> x) => x.Key, (KeyValuePair<string, IStringValue> x) => x.Value.Get(pars2) ?? "");
				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)).GetValueOrDefault(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
	{
		[CompilerGenerated]
		private string <prefab>P;

		[CompilerGenerated]
		private string <arg>P;

		[CompilerGenerated]
		private Vector3 <pos>P;

		protected string[]? args;

		private readonly double time;

		public Parameters(string prefab, string arg, Vector3 pos)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			<prefab>P = prefab;
			<arg>P = arg;
			<pos>P = pos;
			time = ZNet.instance.GetTimeSeconds();
			base..ctor();
		}

		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>P, 
				"<par>" => <arg>P, 
				"<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>P.x), 
				"<y>" => Format(<pos>P.y), 
				"<z>" => Format(<pos>P.z), 
				"<snap>" => Format(WorldGenerator.instance.GetHeight(<pos>P.x, <pos>P.z)), 
				_ => null, 
			};
		}

		private string GetArg(int index)
		{
			if (args == null)
			{
				args = <arg>P.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
	{
		[CompilerGenerated]
		private ZDO <zdo>P;

		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)(ZDOID)(ref <zdo>P.m_uid)).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)(ZDOID)(ref peer.m_characterID)).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":
			{
				ZDOID zDOID = <zdo>P.GetZDOID(value);
				return ((object)(ZDOID)(ref zDOID)).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 (fi