using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.IO.Compression;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Text;
using BepInEx;
using Microsoft.CodeAnalysis;
using RoboPhredDev.PotionCraft.Crucible.GameAPI;
using RoboPhredDev.PotionCraft.Crucible.Resources;
using RoboPhredDev.PotionCraft.Crucible.Yaml;
using UnityEngine;
using YamlDotNet.Core;
using YamlDotNet.Core.Events;
using YamlDotNet.Serialization;
using YamlDotNet.Serialization.NamingConventions;
using YamlDotNet.Serialization.NodeDeserializers;

[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("Crucible.Core")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+f1dd13232f81f5d85002c3808fb2053d996cc897")]
[assembly: AssemblyProduct("Crucible.Core")]
[assembly: AssemblyTitle("Crucible.Core")]
[assembly: AssemblyVersion("1.0.0.0")]
[module: RefSafetyRules(11)]
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 RoboPhredDev.PotionCraft.Crucible
{
	public static class CrucibleLog
	{
		private static readonly Stack<string> LogScopeStack = new Stack<string>();

		public static void Log(string message, params object[] logParams)
		{
			WriteToLog(GetLogGUID(Assembly.GetCallingAssembly()), message, logParams);
		}

		public static void LogInScope(string modGUID, string message, params object[] logParams)
		{
			WriteToLog(modGUID, message, logParams);
		}

		public static void RunInLogScope(Assembly modAssembly, Action action)
		{
			RunInLogScope(GetLogGUID(modAssembly), action);
		}

		public static void RunInLogScope(string modGUID, Action action)
		{
			LogScopeStack.Push(modGUID);
			try
			{
				action();
			}
			finally
			{
				LogScopeStack.Pop();
			}
		}

		private static void WriteToLog(string modGUID, string message, params object[] logParams)
		{
			Debug.Log((object)("[" + modGUID + "]: " + string.Format(message, logParams)));
		}

		private static string GetLogGUID(Assembly assembly)
		{
			if (LogScopeStack.Count > 0)
			{
				return LogScopeStack.Peek();
			}
			BepInPlugin val = (from type in assembly.GetTypes()
				let attribute = (BepInPlugin)Attribute.GetCustomAttribute(type, typeof(BepInPlugin))
				where attribute != null
				select attribute).FirstOrDefault();
			if (val != null)
			{
				return val.GUID;
			}
			return assembly.FullName;
		}
	}
	public class CrucibleMissingDependencyException : Exception
	{
		public string ModGuid { get; }

		public string RequiredSemver { get; }

		public CrucibleMissingDependencyException(string message, string modGuid, string semver)
			: base(message)
		{
			ModGuid = modGuid;
			RequiredSemver = semver;
		}

		public static CrucibleMissingDependencyException CreateMissingDependencyException(string sourceGuid, string dependencyGuid, string semver)
		{
			return new CrucibleMissingDependencyException("Mod \"" + sourceGuid + "\" is missing required dependency \"" + dependencyGuid + "\"@" + semver + ".", dependencyGuid, semver);
		}

		public static CrucibleMissingDependencyException CreateBadVersionException(string sourceGuid, string dependencyGuid, string semver)
		{
			return new CrucibleMissingDependencyException("Mod \"" + sourceGuid + "\" is incompatible with dependency \"" + dependencyGuid + "\".  The mod requires a version matching \"" + semver + "\".", dependencyGuid, semver);
		}
	}
	[AttributeUsage(AttributeTargets.Class)]
	public class CrucibleRegistryAttributeAttribute : Attribute
	{
	}
	public static class CrucibleTypeRegistry
	{
		private static bool initialized;

		private static Dictionary<Type, HashSet<Type>> typesByAttribute;

		public static IEnumerable<Type> GetTypesByAttribute<T>()
		{
			return GetTypesByAttribute(typeof(T));
		}

		public static IEnumerable<Type> GetTypesByAttribute(Type t)
		{
			if (!typeof(Attribute).IsAssignableFrom(t))
			{
				throw new ArgumentException("The provided type must be an attribute.", "t");
			}
			if (t.GetCustomAttribute<CrucibleRegistryAttributeAttribute>() == null)
			{
				throw new ArgumentException("Target attribute must be marked with CrucibleRegistryAttributeAttribute.", "t");
			}
			EnsureTypesLoaded();
			if (typesByAttribute.TryGetValue(t, out var value))
			{
				return value.ToArray();
			}
			return new Type[0];
		}

		private static void EnsureTypesLoaded()
		{
			EnsureInitialized();
			if (typesByAttribute == null)
			{
				BuildTypesByAttribute();
			}
		}

		private static void EnsureInitialized()
		{
			if (!initialized)
			{
				initialized = true;
				AppDomain.CurrentDomain.AssemblyLoad += delegate
				{
					typesByAttribute = null;
				};
			}
		}

		private static void BuildTypesByAttribute()
		{
			Type[] array = GetCrucibleRegistryAttributes().ToArray();
			IEnumerable<Type> enumerable = from assembly in AppDomain.CurrentDomain.GetAssemblies()
				from type in assembly.GetTypes()
				select type;
			typesByAttribute = new Dictionary<Type, HashSet<Type>>();
			foreach (Type item in enumerable)
			{
				Type[] array2 = array;
				foreach (Type type2 in array2)
				{
					if (item.GetCustomAttribute(type2, inherit: true) != null)
					{
						if (!typesByAttribute.TryGetValue(type2, out var value))
						{
							value = new HashSet<Type>();
							typesByAttribute.Add(type2, value);
						}
						value.Add(item);
					}
				}
			}
		}

		private static IEnumerable<Type> GetCrucibleRegistryAttributes()
		{
			return from assembly in AppDomain.CurrentDomain.GetAssemblies()
				from type in assembly.GetTypes()
				where type.GetCustomAttribute<CrucibleRegistryAttributeAttribute>(inherit: true) != null
				select type;
		}
	}
	internal static class TypeExtensions
	{
		public static bool BaseTypeIncludes(this Type type, Type baseType)
		{
			do
			{
				if (type == baseType)
				{
					return true;
				}
			}
			while ((type = type.BaseType) != null);
			return false;
		}

		public static bool BaseTypeIncludesGeneric(this Type type, Type genericType, out Type genericInstantiation)
		{
			do
			{
				if (type.GetGenericTypeDefinition() == genericType)
				{
					genericInstantiation = type;
					return true;
				}
			}
			while ((type = type.BaseType) != null);
			genericInstantiation = null;
			return false;
		}
	}
}
namespace RoboPhredDev.PotionCraft.Crucible.Yaml
{
	public static class Deserializer
	{
		public static readonly INamingConvention NamingConvention = CamelCaseNamingConvention.Instance;

		private static readonly Stack<string> ParsingFiles = new Stack<string>();

		public static string CurrentFilePath
		{
			get
			{
				if (ParsingFiles.Count == 0)
				{
					return null;
				}
				return ParsingFiles.Peek();
			}
		}

		public static T DeserializeFromResource<T>(string resourcePath)
		{
			return WithResourceFileParser(resourcePath, (IParser parser) => BuildDeserializer().Deserialize<T>(parser));
		}

		public static object Deserialize(string resourcePath, Type type)
		{
			return WithResourceFileParser(resourcePath, (IParser parser) => BuildDeserializer().Deserialize(parser, type));
		}

		public static object DeserializeFromParser(string filePath, Type type, IParser parser)
		{
			ParsingFiles.Push(filePath);
			YamlException val = default(YamlException);
			try
			{
				return BuildDeserializer().Deserialize(parser, type);
			}
			catch (object obj) when (((Func<bool>)delegate
			{
				// Could not convert BlockContainer to single expression
				object obj2 = ((obj is YamlException) ? obj : null);
				System.Runtime.CompilerServices.Unsafe.SkipInit(out int result);
				if (obj2 == null)
				{
					result = 0;
				}
				else
				{
					val = (YamlException)obj2;
					result = ((!(val is YamlFileException)) ? 1 : 0);
				}
				return (byte)result != 0;
			}).Invoke())
			{
				throw new YamlFileException(CurrentFilePath, val.Start, val.End, ((Exception)(object)val).Message, (Exception)(object)val);
			}
			finally
			{
				ParsingFiles.Pop();
			}
		}

		public static object DeserializeFromParser(Type type, IParser parser)
		{
			return BuildDeserializer().Deserialize(parser, type);
		}

		public static T WithResourceFileParser<T>(string resourcePath, Func<IParser, T> func)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Expected O, but got Unknown
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Expected O, but got Unknown
			ParsingFiles.Push(resourcePath);
			YamlException val = default(YamlException);
			try
			{
				MergingParser arg = new MergingParser((IParser)new Parser((TextReader)new StringReader(CrucibleResources.ReadAllText(resourcePath))));
				return func((IParser)(object)arg);
			}
			catch (object obj) when (((Func<bool>)delegate
			{
				// Could not convert BlockContainer to single expression
				object obj2 = ((obj is YamlException) ? obj : null);
				System.Runtime.CompilerServices.Unsafe.SkipInit(out int result);
				if (obj2 == null)
				{
					result = 0;
				}
				else
				{
					val = (YamlException)obj2;
					result = ((!(val is YamlFileException)) ? 1 : 0);
				}
				return (byte)result != 0;
			}).Invoke())
			{
				throw new YamlFileException(CurrentFilePath, val.Start, val.End, ((Exception)(object)val).Message, (Exception)(object)val);
			}
			finally
			{
				ParsingFiles.Pop();
			}
		}

		private static IDeserializer BuildDeserializer()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Expected O, but got Unknown
			DeserializerBuilder val = new DeserializerBuilder();
			((BuilderSkeleton<DeserializerBuilder>)(object)val).WithNamingConvention(NamingConvention).IgnoreUnmatchedProperties().WithNodeTypeResolver((INodeTypeResolver)(object)new ImportNodeTypeResolver(), (Action<IRegistrationLocationSelectionSyntax<INodeTypeResolver>>)delegate(IRegistrationLocationSelectionSyntax<INodeTypeResolver> s)
			{
				s.OnTop();
			})
				.WithNodeDeserializer((INodeDeserializer)(object)new ImportDeserializer(), (Action<IRegistrationLocationSelectionSyntax<INodeDeserializer>>)delegate(IRegistrationLocationSelectionSyntax<INodeDeserializer> s)
				{
					s.OnTop();
				})
				.WithNodeDeserializer((INodeDeserializer)(object)new DuckTypeDeserializer(), (Action<IRegistrationLocationSelectionSyntax<INodeDeserializer>>)delegate(IRegistrationLocationSelectionSyntax<INodeDeserializer> s)
				{
					s.OnTop();
				})
				.WithNodeDeserializer((INodeDeserializer)(object)new TypePropertyDeserializer(), (Action<IRegistrationLocationSelectionSyntax<INodeDeserializer>>)delegate(IRegistrationLocationSelectionSyntax<INodeDeserializer> s)
				{
					s.OnTop();
				});
			foreach (Type item in CrucibleTypeRegistry.GetTypesByAttribute<YamlDeserializerAttribute>())
			{
				object? obj = Activator.CreateInstance(item);
				INodeDeserializer val2 = (INodeDeserializer)((obj is INodeDeserializer) ? obj : null);
				if (val2 != null)
				{
					val.WithNodeDeserializer(val2, (Action<IRegistrationLocationSelectionSyntax<INodeDeserializer>>)delegate(IRegistrationLocationSelectionSyntax<INodeDeserializer> s)
					{
						s.OnTop();
					});
				}
			}
			val.WithNodeDeserializer<ExtendedObjectNodeDeserializer>((WrapperFactory<INodeDeserializer, ExtendedObjectNodeDeserializer>)((INodeDeserializer objectDeserializer) => new ExtendedObjectNodeDeserializer(objectDeserializer)), (Action<ITrackingRegistrationLocationSelectionSyntax<INodeDeserializer>>)delegate(ITrackingRegistrationLocationSelectionSyntax<INodeDeserializer> s)
			{
				s.InsteadOf<ObjectNodeDeserializer>();
			});
			return val.Build();
		}
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Interface, AllowMultiple = true)]
	public class DuckTypeCandidateAttribute : Attribute
	{
		public Type CandidateType { get; }

		public DuckTypeCandidateAttribute(Type candidateType)
		{
			CandidateType = candidateType;
		}

		public static ICollection<Type> GetDuckCandidates(Type type)
		{
			return ((DuckTypeCandidateAttribute[])type.GetCustomAttributes(typeof(DuckTypeCandidateAttribute), inherit: false)).Select((DuckTypeCandidateAttribute attr) => attr.CandidateType).ToArray();
		}
	}
	internal class DuckTypeDeserializer : INodeDeserializer
	{
		public bool Deserialize(IParser reader, Type expectedType, Func<IParser, Type, object> nestedObjectDeserializer, out object value)
		{
			ICollection<Type> candidates = DuckTypeCandidateAttribute.GetDuckCandidates(expectedType);
			if (candidates.Count == 0)
			{
				value = null;
				return false;
			}
			if (ImportDeserializer.TryConsumeImport(reader, out var filePath))
			{
				value = Deserializer.WithResourceFileParser(filePath, delegate(IParser importParser)
				{
					ParserExtensions.Consume<StreamStart>(importParser);
					ParserExtensions.Consume<DocumentStart>(importParser);
					object result = DeserializeDuckType(importParser, expectedType, candidates, nestedObjectDeserializer);
					ParserExtensions.Consume<DocumentEnd>(importParser);
					ParserExtensions.Consume<StreamEnd>(importParser);
					return result;
				});
			}
			else
			{
				value = DeserializeDuckType(reader, expectedType, candidates, nestedObjectDeserializer);
			}
			return true;
		}

		private static object DeserializeDuckType(IParser reader, Type expectedType, ICollection<Type> candidates, Func<IParser, Type, object> nestedObjectDeserializer)
		{
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			ReplayParser replayParser = new ReplayParser();
			MappingStart val = ParserExtensions.Consume<MappingStart>(reader);
			replayParser.Enqueue((ParsingEvent)(object)val);
			List<string> list = new List<string>();
			MappingEnd val2 = default(MappingEnd);
			while (!ParserExtensions.TryConsume<MappingEnd>(reader, ref val2))
			{
				Scalar val3 = ParserExtensions.Consume<Scalar>(reader);
				list.Add(val3.Value);
				replayParser.Enqueue((ParsingEvent)(object)val3);
				int num = 0;
				do
				{
					ParsingEvent val4 = ParserExtensions.Consume<ParsingEvent>(reader);
					num += val4.NestingIncrease;
					replayParser.Enqueue(val4);
				}
				while (num > 0);
			}
			replayParser.Enqueue((ParsingEvent)(object)val2);
			Type type = ChooseType(candidates, list);
			if (type == null)
			{
				throw new YamlException(((ParsingEvent)val).Start, ((ParsingEvent)val2).End, "Cannot identify instance type for " + expectedType.Name + " based on its properties " + string.Join(", ", list) + ".  Must be one of: " + string.Join(", ", candidates.Select((Type x) => x.Name)));
			}
			replayParser.Start();
			return nestedObjectDeserializer((IParser)(object)replayParser, type);
		}

		private static Type ChooseType(ICollection<Type> candidates, IList<string> keys)
		{
			return (from candidate in candidates
				let yamlProperties = GetTypeYamlProperties(candidate)
				where !keys.Except(yamlProperties).Any()
				let matchCount = yamlProperties.Intersect(keys).Count()
				where matchCount > 0
				orderby matchCount descending
				select candidate).FirstOrDefault();
		}

		private static IReadOnlyList<string> GetTypeYamlProperties(Type type)
		{
			DuckTypeKeysAttribute duckTypeKeysAttribute = (DuckTypeKeysAttribute)type.GetCustomAttribute(typeof(DuckTypeKeysAttribute));
			if (duckTypeKeysAttribute != null)
			{
				return duckTypeKeysAttribute.Keys;
			}
			IEnumerable<string> first = from <>h__TransparentIdentifier1 in (from property in type.GetProperties(BindingFlags.Instance | BindingFlags.Public)
					select new
					{
						property = property,
						yamlAttribute = ((MemberInfo)property).GetCustomAttribute<YamlMemberAttribute>()
					}).Select(<>h__TransparentIdentifier0 =>
				{
					YamlMemberAttribute yamlAttribute2 = <>h__TransparentIdentifier0.yamlAttribute;
					return new
					{
						<>h__TransparentIdentifier0 = <>h__TransparentIdentifier0,
						name = (((yamlAttribute2 != null) ? yamlAttribute2.Alias : null) ?? Deserializer.NamingConvention.Apply(<>h__TransparentIdentifier0.property.Name))
					};
				})
				select <>h__TransparentIdentifier1.name;
			IEnumerable<string> second = from <>h__TransparentIdentifier1 in (from field in type.GetFields(BindingFlags.Instance | BindingFlags.Public)
					select new
					{
						field = field,
						yamlAttribute = ((MemberInfo)field).GetCustomAttribute<YamlMemberAttribute>()
					}).Select(<>h__TransparentIdentifier0 =>
				{
					YamlMemberAttribute yamlAttribute = <>h__TransparentIdentifier0.yamlAttribute;
					return new
					{
						<>h__TransparentIdentifier0 = <>h__TransparentIdentifier0,
						name = (((yamlAttribute != null) ? yamlAttribute.Alias : null) ?? Deserializer.NamingConvention.Apply(<>h__TransparentIdentifier0.field.Name))
					};
				})
				select <>h__TransparentIdentifier1.name;
			return first.Concat(second).ToList();
		}
	}
	[AttributeUsage(AttributeTargets.Class)]
	public class DuckTypeKeysAttribute : Attribute
	{
		public IReadOnlyList<string> Keys { get; }

		public DuckTypeKeysAttribute(string[] keys)
		{
			Keys = keys.ToList();
		}
	}
	public class ExtendedObjectNodeDeserializer : INodeDeserializer
	{
		private readonly INodeDeserializer nodeDeserializer;

		public ExtendedObjectNodeDeserializer(INodeDeserializer nodeDeserializer)
		{
			this.nodeDeserializer = nodeDeserializer;
		}

		public bool Deserialize(IParser reader, Type expectedType, Func<IParser, Type, object> nestedObjectDeserializer, out object value)
		{
			ReplayParser replayParser = ReplayParser.ParseObject(reader);
			reader = (IParser)(object)replayParser;
			Mark start = null;
			ParsingEvent val = default(ParsingEvent);
			if (ParserExtensions.Accept<ParsingEvent>(reader, ref val))
			{
				start = ((val != null) ? val.Start : null);
			}
			if (!nodeDeserializer.Deserialize(reader, expectedType, nestedObjectDeserializer, ref value))
			{
				return false;
			}
			ParsingEvent current = reader.Current;
			Mark end = ((current != null) ? current.End : null);
			if (value is IDeserializeExtraData deserializeExtraData)
			{
				replayParser.Reset();
				deserializeExtraData.OnDeserializeExtraData(replayParser);
			}
			if (value is IAfterYamlDeserialization afterYamlDeserialization)
			{
				afterYamlDeserialization.OnDeserializeCompleted(start, end);
			}
			return true;
		}
	}
	public interface IAfterYamlDeserialization
	{
		void OnDeserializeCompleted(Mark start, Mark end);
	}
	public interface IDeserializeExtraData
	{
		void OnDeserializeExtraData(ReplayParser parser);
	}
	internal class ImportDeserializer : INodeDeserializer
	{
		public static bool TryConsumeImport(IParser reader, out string filePath)
		{
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			NodeEvent val = default(NodeEvent);
			if (ParserExtensions.Accept<NodeEvent>(reader, ref val) && val.Tag == "!import")
			{
				ParserExtensions.Consume<NodeEvent>(reader);
				Scalar val2 = (Scalar)(object)((val is Scalar) ? val : null);
				if (val2 != null)
				{
					filePath = val2.Value;
				}
				else
				{
					filePath = ParserExtensions.Consume<Scalar>(reader).Value;
				}
				filePath = Path.Combine(Path.GetDirectoryName(Deserializer.CurrentFilePath), filePath);
				if (!CrucibleResources.Exists(filePath))
				{
					throw new YamlException(((ParsingEvent)val).Start, ((ParsingEvent)val).End, "Cannot import file \"" + filePath + "\" as the file does not exist in the current package.");
				}
				return true;
			}
			filePath = null;
			return false;
		}

		public bool Deserialize(IParser reader, Type expectedType, Func<IParser, Type, object> nestedObjectDeserializer, out object value)
		{
			if (TryConsumeImport(reader, out var filePath))
			{
				value = Deserializer.Deserialize(filePath, expectedType);
				return true;
			}
			value = null;
			return false;
		}
	}
	internal class ImportNodeTypeResolver : INodeTypeResolver
	{
		public bool Resolve(NodeEvent nodeEvent, ref Type currentType)
		{
			if (nodeEvent.Tag == "!import")
			{
				return true;
			}
			return false;
		}
	}
	public class OneOrMany<T> : IList<T>, ICollection<T>, IEnumerable<T>, IEnumerable
	{
		private readonly List<T> contents;

		public int Count => contents.Count;

		public bool IsReadOnly => false;

		public T this[int index]
		{
			get
			{
				return contents[index];
			}
			set
			{
				contents[index] = value;
			}
		}

		public OneOrMany()
		{
			contents = new List<T>();
		}

		public OneOrMany(IEnumerable<T> source)
		{
			contents = source.ToList();
		}

		public OneOrMany(IEnumerable source)
		{
			contents = source.Cast<T>().ToList();
		}

		public void Add(T item)
		{
			contents.Add(item);
		}

		public void Clear()
		{
			contents.Clear();
		}

		public bool Contains(T item)
		{
			return contents.Contains(item);
		}

		public void CopyTo(T[] array, int arrayIndex)
		{
			contents.CopyTo(array, arrayIndex);
		}

		public IEnumerator<T> GetEnumerator()
		{
			return contents.GetEnumerator();
		}

		public int IndexOf(T item)
		{
			return contents.IndexOf(item);
		}

		public void Insert(int index, T item)
		{
			contents.Insert(index, item);
		}

		public bool Remove(T item)
		{
			return contents.Remove(item);
		}

		public void RemoveAt(int index)
		{
			contents.RemoveAt(index);
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return contents.GetEnumerator();
		}
	}
	public class ReplayParser : IParser
	{
		private readonly List<ParsingEvent> replayEvents = new List<ParsingEvent>();

		private IEnumerator<ParsingEvent> replayEnumerator;

		public ParsingEvent Current
		{
			get
			{
				if (replayEnumerator == null)
				{
					throw new InvalidOperationException("ReplayParser has not been activated.");
				}
				return replayEnumerator.Current;
			}
		}

		public static ReplayParser ParseObject(IParser reader)
		{
			ReplayParser replayParser = new ReplayParser();
			MappingStart parsingEvent = ParserExtensions.Consume<MappingStart>(reader);
			replayParser.Enqueue((ParsingEvent)(object)parsingEvent);
			List<string> list = new List<string>();
			MappingEnd parsingEvent2 = default(MappingEnd);
			while (!ParserExtensions.TryConsume<MappingEnd>(reader, ref parsingEvent2))
			{
				Scalar val = ParserExtensions.Consume<Scalar>(reader);
				list.Add(val.Value);
				replayParser.Enqueue((ParsingEvent)(object)val);
				int num = 0;
				do
				{
					ParsingEvent val2 = ParserExtensions.Consume<ParsingEvent>(reader);
					num += val2.NestingIncrease;
					replayParser.Enqueue(val2);
				}
				while (num > 0);
			}
			replayParser.Enqueue((ParsingEvent)(object)parsingEvent2);
			replayParser.Start();
			return replayParser;
		}

		public void Enqueue(ParsingEvent parsingEvent)
		{
			if (replayEnumerator != null)
			{
				throw new InvalidOperationException("Cannot enqueue to a ReplayParser that has already been started.");
			}
			replayEvents.Add(parsingEvent);
		}

		public void Start()
		{
			if (replayEnumerator != null)
			{
				throw new InvalidOperationException("This ReplayParser has already been started.");
			}
			replayEnumerator = replayEvents.GetEnumerator();
		}

		public void Reset()
		{
			replayEnumerator = replayEvents.GetEnumerator();
		}

		public bool MoveNext()
		{
			return replayEnumerator.MoveNext();
		}
	}
	[AttributeUsage(AttributeTargets.Class)]
	public class TypePropertyAttribute : Attribute
	{
		public string TypePropertyName { get; }

		public TypePropertyAttribute(string typePropertyName)
		{
			TypePropertyName = typePropertyName;
		}
	}
	[AttributeUsage(AttributeTargets.Class)]
	public class TypePropertyCandidateAttribute : Attribute
	{
		private static readonly Dictionary<Type, Dictionary<string, Type>> CandidateCache;

		public string TypeName { get; }

		static TypePropertyCandidateAttribute()
		{
			CandidateCache = new Dictionary<Type, Dictionary<string, Type>>();
			AppDomain.CurrentDomain.AssemblyLoad += delegate
			{
				CandidateCache.Clear();
			};
		}

		public TypePropertyCandidateAttribute(string typeName)
		{
			TypeName = typeName;
		}

		public static IDictionary<string, Type> GetCandidateTypes(Type baseType)
		{
			if (!CandidateCache.TryGetValue(baseType, out var value))
			{
				value = (from assembly in AppDomain.CurrentDomain.GetAssemblies()
					from type in assembly.GetTypes()
					where baseType.IsAssignableFrom(type)
					let candidateAttribute = type.GetCustomAttribute<TypePropertyCandidateAttribute>()
					where candidateAttribute != null
					select new KeyValuePair<string, Type>(candidateAttribute.TypeName, type)).ToDictionary((KeyValuePair<string, Type> x) => x.Key, (KeyValuePair<string, Type> x) => x.Value);
				CandidateCache.Add(baseType, value);
			}
			return value;
		}
	}
	internal class TypePropertyDeserializer : INodeDeserializer
	{
		public bool Deserialize(IParser reader, Type expectedType, Func<IParser, Type, object> nestedObjectDeserializer, out object value)
		{
			TypePropertyAttribute typePropertyAttribute = expectedType.GetCustomAttribute<TypePropertyAttribute>(inherit: false);
			if (typePropertyAttribute == null || string.IsNullOrEmpty(typePropertyAttribute.TypePropertyName))
			{
				value = null;
				return false;
			}
			IDictionary<string, Type> candidates = TypePropertyCandidateAttribute.GetCandidateTypes(expectedType);
			if (ImportDeserializer.TryConsumeImport(reader, out var filePath))
			{
				value = Deserializer.WithResourceFileParser(filePath, delegate(IParser importParser)
				{
					ParserExtensions.Consume<StreamStart>(importParser);
					ParserExtensions.Consume<DocumentStart>(importParser);
					object result = DeserializeType(importParser, expectedType, typePropertyAttribute.TypePropertyName, candidates, nestedObjectDeserializer);
					ParserExtensions.Consume<DocumentEnd>(importParser);
					ParserExtensions.Consume<StreamEnd>(importParser);
					return result;
				});
			}
			else
			{
				value = DeserializeType(reader, expectedType, typePropertyAttribute.TypePropertyName, candidates, nestedObjectDeserializer);
			}
			return true;
		}

		private static object DeserializeType(IParser reader, Type expectedType, string typePropertyName, IDictionary<string, Type> candidates, Func<IParser, Type, object> nestedObjectDeserializer)
		{
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			ReplayParser replayParser = new ReplayParser();
			MappingStart val = ParserExtensions.Consume<MappingStart>(reader);
			replayParser.Enqueue((ParsingEvent)(object)val);
			string text = null;
			MappingEnd val2 = default(MappingEnd);
			while (!ParserExtensions.TryConsume<MappingEnd>(reader, ref val2))
			{
				Scalar val3 = ParserExtensions.Consume<Scalar>(reader);
				replayParser.Enqueue((ParsingEvent)(object)val3);
				if (val3.Value == typePropertyName)
				{
					Scalar val4 = ParserExtensions.Consume<Scalar>(reader);
					replayParser.Enqueue((ParsingEvent)(object)val4);
					text = val4.Value;
					continue;
				}
				int num = 0;
				do
				{
					ParsingEvent val5 = ParserExtensions.Consume<ParsingEvent>(reader);
					num += val5.NestingIncrease;
					replayParser.Enqueue(val5);
				}
				while (num > 0);
			}
			replayParser.Enqueue((ParsingEvent)(object)val2);
			if (!candidates.TryGetValue(text, out var value))
			{
				throw new YamlException(((ParsingEvent)val).Start, ((ParsingEvent)val2).End, "Cannot identify instance type for " + expectedType.Name + " based on its type property " + text + ".  Must be one of: " + string.Join(", ", candidates.Keys));
			}
			replayParser.Start();
			return nestedObjectDeserializer((IParser)(object)replayParser, value);
		}
	}
	[AttributeUsage(AttributeTargets.Class)]
	[CrucibleRegistryAttribute]
	public class YamlDeserializerAttribute : Attribute
	{
	}
	public static class YamlExceptionExtensions
	{
		public static string GetInnermostMessage(this YamlException exception)
		{
			Exception ex = (Exception)(object)exception;
			while (ex is YamlException && ex.InnerException != null)
			{
				ex = ex.InnerException;
			}
			return ex.Message;
		}
	}
	public class YamlFileException : YamlException
	{
		public string FilePath { get; }

		public YamlFileException(string filePath, string message)
			: base(message)
		{
			FilePath = filePath;
		}

		public YamlFileException(string filePath, Mark start, Mark end, string message)
			: base(start, end, message)
		{
			FilePath = filePath;
		}

		public YamlFileException(string filePath, Mark start, Mark end, string message, Exception innerException)
			: base(start, end, message, innerException)
		{
			FilePath = filePath;
		}

		public YamlFileException(string filePath, string message, Exception inner)
			: base(message, inner)
		{
			FilePath = filePath;
		}
	}
}
namespace RoboPhredDev.PotionCraft.Crucible.Yaml.Deserializers
{
	[YamlDeserializer]
	public class ColorDeserializer : INodeDeserializer
	{
		private class ColorParseObj
		{
			public float A { get; set; } = 1f;


			public float R { get; set; }

			public float G { get; set; }

			public float B { get; set; }
		}

		public bool Deserialize(IParser reader, Type expectedType, Func<IParser, Type, object> nestedObjectDeserializer, out object value)
		{
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			if (expectedType != typeof(Color) && Nullable.GetUnderlyingType(expectedType) != typeof(Color))
			{
				value = null;
				return false;
			}
			Scalar val = default(Scalar);
			if (ParserExtensions.TryConsume<Scalar>(reader, ref val))
			{
				string value2 = val.Value;
				if (value2.StartsWith("#"))
				{
					value2 = value2.Substring(1);
					if (value2.Length != 6)
					{
						throw new FormatException("Unknown color format.  Expected a hexadecimal string.");
					}
					if (!int.TryParse(value2, NumberStyles.HexNumber, CultureInfo.InvariantCulture, out var result))
					{
						throw new FormatException("Unknown color format.  Failed to parse hexadecimal value.");
					}
					value = (object)new Color
					{
						a = 1f,
						r = (float)(int)(byte)((result >> 16) & 0xFF) / 255f,
						g = (float)(int)(byte)((result >> 8) & 0xFF) / 255f,
						b = (float)(int)(byte)(result & 0xFF) / 255f
					};
					return true;
				}
				throw new FormatException("Unknown color format.  Expected a string starting with \"#\".");
			}
			ColorParseObj colorParseObj = (ColorParseObj)nestedObjectDeserializer(reader, typeof(ColorParseObj));
			value = (object)new Color(colorParseObj.R, colorParseObj.G, colorParseObj.B, colorParseObj.A);
			return true;
		}
	}
	[YamlDeserializer]
	public class LocalizedStringDeserializer : INodeDeserializer
	{
		public bool Deserialize(IParser reader, Type expectedType, Func<IParser, Type, object> nestedObjectDeserializer, out object value)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Expected O, but got Unknown
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Expected O, but got Unknown
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Expected O, but got Unknown
			if (expectedType != typeof(LocalizedString))
			{
				value = null;
				return false;
			}
			Scalar val = default(Scalar);
			if (ParserExtensions.TryConsume<Scalar>(reader, ref val))
			{
				value = (object)new LocalizedString(val.Value);
				return true;
			}
			Dictionary<string, string> dictionary = (Dictionary<string, string>)nestedObjectDeserializer(reader, typeof(Dictionary<string, string>));
			LocalizedString val2;
			if (dictionary.TryGetValue("default", out var value2))
			{
				val2 = new LocalizedString(value2);
				dictionary.Remove("default");
			}
			else
			{
				val2 = new LocalizedString();
			}
			foreach (KeyValuePair<string, string> item in dictionary)
			{
				val2.SetLocalization(item.Key, item.Value);
			}
			value = val2;
			return true;
		}
	}
	[YamlDeserializer]
	public class OneOrManyDeserializer : INodeDeserializer
	{
		public bool Deserialize(IParser reader, Type expectedType, Func<IParser, Type, object> nestedObjectDeserializer, out object value)
		{
			if (!expectedType.IsGenericType || expectedType.GetGenericTypeDefinition() != typeof(OneOrMany<>))
			{
				value = null;
				return false;
			}
			Type type = expectedType.GetGenericArguments()[0];
			SequenceStart val = default(SequenceStart);
			IEnumerable enumerable;
			if (ParserExtensions.Accept<SequenceStart>(reader, ref val))
			{
				enumerable = (IEnumerable)nestedObjectDeserializer(reader, typeof(List<>).MakeGenericType(type));
			}
			else
			{
				object value2 = nestedObjectDeserializer(reader, type);
				Array array = Array.CreateInstance(type, 1);
				array.SetValue(value2, 0);
				enumerable = array;
			}
			object[] args = new IEnumerable[1] { enumerable };
			value = Activator.CreateInstance(expectedType, args);
			return true;
		}
	}
	[YamlDeserializer]
	public class SpriteDeserializer : INodeDeserializer
	{
		internal class SpriteData
		{
			public Texture2D Texture { get; set; }

			public Vector2? Pivot { get; set; }
		}

		public bool Deserialize(IParser reader, Type expectedType, Func<IParser, Type, object> nestedObjectDeserializer, out object value)
		{
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			if (!typeof(Sprite).IsAssignableFrom(expectedType))
			{
				value = null;
				return false;
			}
			if (TryDeserializeFilename(reader, out value))
			{
				return true;
			}
			SpriteData spriteData = (SpriteData)nestedObjectDeserializer(reader, typeof(SpriteData));
			Texture2D texture = spriteData.Texture;
			if ((Object)(object)texture == (Object)null)
			{
				throw new Exception("Sprite must specify a texture.");
			}
			Sprite val = Sprite.Create(texture, new Rect(0f, 0f, (float)((Texture)texture).width, (float)((Texture)texture).height), (Vector2)(((??)spriteData.Pivot) ?? new Vector2(0.5f, 0.5f)));
			((Object)val).name = ((Object)texture).name;
			value = val;
			return true;
		}

		private bool TryDeserializeFilename(IParser reader, out object value)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Expected O, but got Unknown
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			Scalar val = default(Scalar);
			if (!ParserExtensions.TryConsume<Scalar>(reader, ref val))
			{
				value = null;
				return false;
			}
			string value2 = val.Value;
			byte[] array = CrucibleResources.ReadAllBytes(value2);
			Texture2D val2 = new Texture2D(2, 2, (TextureFormat)5, false, false)
			{
				filterMode = (FilterMode)1
			};
			if (!ImageConversion.LoadImage(val2, array))
			{
				throw new CrucibleResourceException("Failed to load image from resource at \"" + value2 + "\".");
			}
			Sprite val3 = Sprite.Create(val2, new Rect(0f, 0f, (float)((Texture)val2).width, (float)((Texture)val2).height), new Vector2(0.5f, 0.5f));
			((Object)val3).name = value2;
			value = val3;
			return true;
		}
	}
	[YamlDeserializer]
	public class Texture2DDeserializer : INodeDeserializer
	{
		public bool Deserialize(IParser reader, Type expectedType, Func<IParser, Type, object> nestedObjectDeserializer, out object value)
		{
			if (!typeof(Texture2D).IsAssignableFrom(expectedType))
			{
				value = null;
				return false;
			}
			if (TryDeserializeFilename(reader, out value))
			{
				return true;
			}
			value = null;
			return false;
		}

		private bool TryDeserializeFilename(IParser reader, out object value)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Expected O, but got Unknown
			Scalar val = default(Scalar);
			if (!ParserExtensions.TryConsume<Scalar>(reader, ref val))
			{
				value = null;
				return false;
			}
			string value2 = val.Value;
			byte[] array = CrucibleResources.ReadAllBytes(value2);
			Texture2D val2 = new Texture2D(2, 2, (TextureFormat)5, false, false)
			{
				filterMode = (FilterMode)1
			};
			if (!ImageConversion.LoadImage(val2, array))
			{
				throw new CrucibleResourceException("Failed to load image from resource at \"" + value2 + "\".");
			}
			((Object)val2).name = value2;
			value = val2;
			return true;
		}
	}
	[YamlDeserializer]
	public class Vector2Deserializer : INodeDeserializer
	{
		private class Vector2ParseObj
		{
			public float X { get; set; }

			public float Y { get; set; }
		}

		public bool Deserialize(IParser reader, Type expectedType, Func<IParser, Type, object> nestedObjectDeserializer, out object value)
		{
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			if (expectedType != typeof(Vector2) && Nullable.GetUnderlyingType(expectedType) != typeof(Vector2))
			{
				value = null;
				return false;
			}
			Scalar val = default(Scalar);
			if (ParserExtensions.TryConsume<Scalar>(reader, ref val))
			{
				float[] array;
				try
				{
					array = (from x in val.Value.Split(new char[1] { ',' })
						select x.Trim() into x
						select float.Parse(x, CultureInfo.InvariantCulture)).ToArray();
				}
				catch
				{
					throw new FormatException("Invalid vector value.  Expected two floating point numbers.");
				}
				if (array.Length != 2)
				{
					throw new FormatException("Invalid vector value.  Expected two floating point numbers.");
				}
				value = (object)new Vector2(array[0], array[1]);
				return true;
			}
			Vector2ParseObj vector2ParseObj = (Vector2ParseObj)nestedObjectDeserializer(reader, typeof(Vector2ParseObj));
			value = (object)new Vector2(vector2ParseObj.X, vector2ParseObj.Y);
			return true;
		}
	}
}
namespace RoboPhredDev.PotionCraft.Crucible.SVG
{
	public class SvgPath
	{
		public string Data { get; set; }

		public Vector2 Scale { get; set; } = Vector2.one;


		public SvgPath()
		{
		}//IL_0001: Unknown result type (might be due to invalid IL or missing references)
		//IL_0006: Unknown result type (might be due to invalid IL or missing references)


		public SvgPath(string path)
		{
			//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)
			Data = path;
		}

		public IEnumerable<CrucibleBezierCurve> ToPathSegments()
		{
			string path = Data;
			Vector2 scale = new Vector2(Scale.x, Scale.y * -1f);
			Vector2 lastEnd = Vector2.zero;
			CrucibleBezierCurve val;
			while ((val = PartToCurve(ref path, lastEnd)) != null)
			{
				val.P1 *= scale;
				val.P2 *= scale;
				val.End *= scale;
				lastEnd = ((!val.IsRelative) ? val.End : (lastEnd + val.End));
				yield return val;
			}
		}

		public List<Vector2> ToPoints()
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			string svgPath = Data;
			Vector2 partStart = Vector2.zero;
			Vector2 figureStart = Vector2.zero;
			List<Vector2> list = new List<Vector2>();
			bool flag = true;
			Vector2[] array;
			while ((array = PartToPoints(ref svgPath, ref partStart, ref figureStart)) != null)
			{
				if (array.Length == 0)
				{
					flag = true;
				}
				else if (flag)
				{
					flag = false;
					list.Add(figureStart);
				}
				list.AddRange(array);
			}
			Vector2 negY = new Vector2(1f, -1f);
			return list.ConvertAll((Vector2 x) => x * Scale * negY);
		}

		private static string GetToken(ref string svgPath)
		{
			StringBuilder stringBuilder = new StringBuilder();
			int i = 0;
			bool? flag = null;
			for (; i < svgPath.Length; i++)
			{
				char c = svgPath[i];
				if (c == ' ' || c == ',' || c == '\n' || c == '\r')
				{
					if (stringBuilder.Length > 0)
					{
						break;
					}
					continue;
				}
				if (!flag.HasValue)
				{
					flag = char.IsLetter(c);
				}
				else if (char.IsLetter(c) != flag.Value)
				{
					break;
				}
				stringBuilder.Append(c);
			}
			svgPath = svgPath.Substring(i);
			if (stringBuilder.Length == 0)
			{
				return null;
			}
			return stringBuilder.ToString();
		}

		private static float GetFloatTokenOrFail(ref string svgPath)
		{
			string token = GetToken(ref svgPath);
			if (!float.TryParse(token, NumberStyles.Any, CultureInfo.InvariantCulture, out var result))
			{
				throw new Exception("Failed to parse decimal value: \"" + token + "\".");
			}
			return result;
		}

		private static Vector2[] PartToPoints(ref string svgPath, ref Vector2 partStart, ref Vector2 figureStart)
		{
			//IL_0150: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			string token = GetToken(ref svgPath);
			if (token == null)
			{
				return null;
			}
			if (token != null)
			{
				int length = token.Length;
				if (length == 1)
				{
					switch (token[0])
					{
					case 'M':
						return AbsoluteMoveToPoints(ref svgPath, ref partStart, ref figureStart);
					case 'L':
						return UpdatePartStart(AbsoluteLineToPoints(ref svgPath), ref partStart);
					case 'H':
						return UpdatePartStart(RelativeLineToPoints(ref svgPath, partStart), ref partStart);
					case 'V':
						return UpdatePartStart(AbsoluteVerticalToPoints(ref svgPath, partStart), ref partStart);
					case 'C':
						return UpdatePartStart(AbsoluteCubicCurveToPoints(ref svgPath), ref partStart);
					case 'm':
						return RelativeMoveToPoints(ref svgPath, ref partStart, ref figureStart);
					case 'l':
						return UpdatePartStart(RelativeLineToPoints(ref svgPath, partStart), ref partStart);
					case 'v':
						return UpdatePartStart(RelativeVerticalToPoints(ref svgPath, partStart), ref partStart);
					case 'h':
						return UpdatePartStart(RelativeHorizontalToPoints(ref svgPath, partStart), ref partStart);
					case 'c':
						return UpdatePartStart(RelativeCubicCurveToPoints(ref svgPath, partStart), ref partStart);
					case 'Z':
					case 'z':
						return ClosePoints(ref svgPath, ref partStart, ref figureStart);
					}
				}
			}
			throw new Exception("Unsupported SVG path command \"" + token + "\".");
		}

		private static Vector2[] UpdatePartStart(Vector2[] result, ref Vector2 partStart)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			partStart = result.Last();
			return result;
		}

		private static CrucibleBezierCurve PartToCurve(ref string svgPath, Vector2 start)
		{
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			string token = GetToken(ref svgPath);
			if (token == null)
			{
				return null;
			}
			if (token != null)
			{
				int length = token.Length;
				if (length == 1)
				{
					switch (token[0])
					{
					case 'L':
					case 'M':
						return AbsoluteLineToCurve(ref svgPath);
					case 'H':
						return AbsoluteHorizontalToCurve(ref svgPath, start);
					case 'V':
						return AbsoluteVerticalToCurve(ref svgPath, start);
					case 'C':
						return AbsoluteCubicCurveToCurve(ref svgPath);
					case 'l':
					case 'm':
						return RelativeLineToCurve(ref svgPath);
					case 'v':
						return RelativeVerticalToCurve(ref svgPath);
					case 'h':
						return RelativeHorizontalToCurve(ref svgPath);
					case 'c':
						return RelativeCubicCurveToCurve(ref svgPath);
					}
				}
			}
			throw new Exception("Unsupported SVG path command \"" + token + "\".");
		}

		private static Vector2[] AbsoluteMoveToPoints(ref string svgPath, ref Vector2 partStart, ref Vector2 figureStart)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: 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)
			Vector2 val = default(Vector2);
			((Vector2)(ref val))..ctor(GetFloatTokenOrFail(ref svgPath), GetFloatTokenOrFail(ref svgPath));
			partStart = val;
			figureStart = val;
			return (Vector2[])(object)new Vector2[0];
		}

		private static Vector2[] RelativeMoveToPoints(ref string svgPath, ref Vector2 partStart, ref Vector2 figureStart)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			Vector2 val = default(Vector2);
			((Vector2)(ref val))..ctor(GetFloatTokenOrFail(ref svgPath), GetFloatTokenOrFail(ref svgPath));
			partStart += val;
			figureStart = partStart;
			return (Vector2[])(object)new Vector2[0];
		}

		private static CrucibleBezierCurve AbsoluteLineToCurve(ref string svgPath)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			return CrucibleBezierCurve.LineTo(new Vector2(GetFloatTokenOrFail(ref svgPath), GetFloatTokenOrFail(ref svgPath)));
		}

		private static Vector2[] AbsoluteLineToPoints(ref string svgPath)
		{
			//IL_001b: 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)
			Vector2 val = default(Vector2);
			((Vector2)(ref val))..ctor(GetFloatTokenOrFail(ref svgPath), GetFloatTokenOrFail(ref svgPath));
			return (Vector2[])(object)new Vector2[1] { val };
		}

		private static CrucibleBezierCurve RelativeLineToCurve(ref string svgPath)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			return CrucibleBezierCurve.RelativeLineTo(new Vector2(GetFloatTokenOrFail(ref svgPath), GetFloatTokenOrFail(ref svgPath)));
		}

		private static Vector2[] RelativeLineToPoints(ref string svgPath, Vector2 start)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			Vector2 val = default(Vector2);
			((Vector2)(ref val))..ctor(GetFloatTokenOrFail(ref svgPath) + start.x, GetFloatTokenOrFail(ref svgPath) + start.y);
			return (Vector2[])(object)new Vector2[1] { val };
		}

		private static CrucibleBezierCurve AbsoluteHorizontalToCurve(ref string svgPath, Vector2 start)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			return CrucibleBezierCurve.LineTo(new Vector2(GetFloatTokenOrFail(ref svgPath), start.y));
		}

		private static CrucibleBezierCurve RelativeHorizontalToCurve(ref string svgPath)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			return CrucibleBezierCurve.RelativeLineTo(new Vector2(GetFloatTokenOrFail(ref svgPath), 0f));
		}

		private static Vector2[] RelativeHorizontalToPoints(ref string svgPath, Vector2 start)
		{
			//IL_0008: 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_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			Vector2 val = default(Vector2);
			((Vector2)(ref val))..ctor(GetFloatTokenOrFail(ref svgPath) + start.x, start.y);
			return (Vector2[])(object)new Vector2[1] { val };
		}

		private static CrucibleBezierCurve AbsoluteVerticalToCurve(ref string svgPath, Vector2 start)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			return CrucibleBezierCurve.LineTo(new Vector2(start.x, GetFloatTokenOrFail(ref svgPath)));
		}

		private static Vector2[] AbsoluteVerticalToPoints(ref string svgPath, Vector2 start)
		{
			//IL_0002: 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_001c: Unknown result type (might be due to invalid IL or missing references)
			Vector2 val = default(Vector2);
			((Vector2)(ref val))..ctor(start.x, GetFloatTokenOrFail(ref svgPath));
			return (Vector2[])(object)new Vector2[1] { val };
		}

		private static CrucibleBezierCurve RelativeVerticalToCurve(ref string svgPath)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			return CrucibleBezierCurve.RelativeLineTo(new Vector2(0f, GetFloatTokenOrFail(ref svgPath)));
		}

		private static Vector2[] RelativeVerticalToPoints(ref string svgPath, Vector2 start)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			Vector2 val = default(Vector2);
			((Vector2)(ref val))..ctor(start.x, GetFloatTokenOrFail(ref svgPath) + start.y);
			return (Vector2[])(object)new Vector2[1] { val };
		}

		private static CrucibleBezierCurve AbsoluteCubicCurveToCurve(ref string svgPath)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			Vector2 val = new Vector2(GetFloatTokenOrFail(ref svgPath), GetFloatTokenOrFail(ref svgPath));
			Vector2 val2 = default(Vector2);
			((Vector2)(ref val2))..ctor(GetFloatTokenOrFail(ref svgPath), GetFloatTokenOrFail(ref svgPath));
			Vector2 val3 = default(Vector2);
			((Vector2)(ref val3))..ctor(GetFloatTokenOrFail(ref svgPath), GetFloatTokenOrFail(ref svgPath));
			return CrucibleBezierCurve.CurveTo(val, val2, val3);
		}

		private static Vector2[] AbsoluteCubicCurveToPoints(ref string svgPath)
		{
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			Vector2 val = default(Vector2);
			((Vector2)(ref val))..ctor(GetFloatTokenOrFail(ref svgPath), GetFloatTokenOrFail(ref svgPath));
			Vector2 val2 = default(Vector2);
			((Vector2)(ref val2))..ctor(GetFloatTokenOrFail(ref svgPath), GetFloatTokenOrFail(ref svgPath));
			Vector2 val3 = default(Vector2);
			((Vector2)(ref val3))..ctor(GetFloatTokenOrFail(ref svgPath), GetFloatTokenOrFail(ref svgPath));
			return (Vector2[])(object)new Vector2[3] { val, val2, val3 };
		}

		private static CrucibleBezierCurve RelativeCubicCurveToCurve(ref string svgPath)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			Vector2 val = new Vector2(GetFloatTokenOrFail(ref svgPath), GetFloatTokenOrFail(ref svgPath));
			Vector2 val2 = default(Vector2);
			((Vector2)(ref val2))..ctor(GetFloatTokenOrFail(ref svgPath), GetFloatTokenOrFail(ref svgPath));
			Vector2 val3 = default(Vector2);
			((Vector2)(ref val3))..ctor(GetFloatTokenOrFail(ref svgPath), GetFloatTokenOrFail(ref svgPath));
			return CrucibleBezierCurve.RelativeCurveTo(val, val2, val3);
		}

		private static Vector2[] RelativeCubicCurveToPoints(ref string svgPath, Vector2 start)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: 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_004a: 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_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			Vector2 val = default(Vector2);
			((Vector2)(ref val))..ctor(GetFloatTokenOrFail(ref svgPath) + start.x, GetFloatTokenOrFail(ref svgPath) + start.y);
			Vector2 val2 = default(Vector2);
			((Vector2)(ref val2))..ctor(GetFloatTokenOrFail(ref svgPath) + start.x, GetFloatTokenOrFail(ref svgPath) + start.y);
			Vector2 val3 = default(Vector2);
			((Vector2)(ref val3))..ctor(GetFloatTokenOrFail(ref svgPath) + start.x, GetFloatTokenOrFail(ref svgPath) + start.y);
			return (Vector2[])(object)new Vector2[3] { val, val2, val3 };
		}

		private static Vector2[] ClosePoints(ref string svgPath, ref Vector2 partStart, ref Vector2 figureStart)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			partStart = figureStart;
			return (Vector2[])(object)new Vector2[1] { figureStart };
		}
	}
	[YamlDeserializer]
	public class SvgPathDeserializer : INodeDeserializer
	{
		private bool suppressDeserializer;

		public bool Deserialize(IParser reader, Type expectedType, Func<IParser, Type, object> nestedObjectDeserializer, out object value)
		{
			if (suppressDeserializer)
			{
				value = null;
				return false;
			}
			if (expectedType != typeof(SvgPath))
			{
				value = null;
				return false;
			}
			Scalar val = default(Scalar);
			if (ParserExtensions.TryConsume<Scalar>(reader, ref val))
			{
				value = new SvgPath(val.Value);
				return true;
			}
			suppressDeserializer = true;
			try
			{
				value = nestedObjectDeserializer(reader, typeof(SvgPath));
				return true;
			}
			finally
			{
				suppressDeserializer = false;
			}
		}
	}
}
namespace RoboPhredDev.PotionCraft.Crucible.Resources
{
	public class CrucibleResourceException : Exception
	{
		public string ResourceName { get; set; }

		public CrucibleResourceException(string message)
			: base(message)
		{
		}
	}
	public static class CrucibleResources
	{
		private static readonly Stack<ICrucibleResourceProvider> ResourceProviderStack = new Stack<ICrucibleResourceProvider>();

		public static ICrucibleResourceProvider CurrentResourceProvider
		{
			get
			{
				if (ResourceProviderStack.Count == 0)
				{
					return null;
				}
				return ResourceProviderStack.Peek();
			}
		}

		public static bool Exists(string resourceName)
		{
			if (CurrentResourceProvider == null)
			{
				throw new CrucibleResourceException("No resource provider is active.")
				{
					ResourceName = resourceName
				};
			}
			return CurrentResourceProvider.Exists(resourceName);
		}

		public static string ReadAllText(string resourceName)
		{
			if (CurrentResourceProvider == null)
			{
				throw new CrucibleResourceException("No resource provider is active.")
				{
					ResourceName = resourceName
				};
			}
			return CurrentResourceProvider.ReadAllText(resourceName);
		}

		public static byte[] ReadAllBytes(string resourceName)
		{
			if (CurrentResourceProvider == null)
			{
				throw new CrucibleResourceException("No resource provider is active.")
				{
					ResourceName = resourceName
				};
			}
			return CurrentResourceProvider.ReadAllBytes(resourceName);
		}

		public static void WithResourceProvider(ICrucibleResourceProvider provider, Action action)
		{
			ResourceProviderStack.Push(provider);
			try
			{
				action();
			}
			finally
			{
				ResourceProviderStack.Pop();
			}
		}

		public static T WithResourceProvider<T>(ICrucibleResourceProvider provider, Func<T> action)
		{
			ResourceProviderStack.Push(provider);
			try
			{
				return action();
			}
			finally
			{
				ResourceProviderStack.Pop();
			}
		}
	}
	public class DirectoryResourceProvider : ICrucibleResourceProvider
	{
		private readonly string rootPath;

		public DirectoryResourceProvider(string directory)
		{
			rootPath = Path.GetFullPath(directory);
		}

		public bool Exists(string resourcePath)
		{
			return File.Exists(Path.Combine(rootPath, resourcePath));
		}

		public byte[] ReadAllBytes(string resource)
		{
			return File.ReadAllBytes(GetResourcePath(resource));
		}

		public string ReadAllText(string resource)
		{
			return File.ReadAllText(GetResourcePath(resource));
		}

		private string GetResourcePath(string resource)
		{
			string fullPath = Path.GetFullPath(Path.Combine(rootPath, resource));
			if (!fullPath.StartsWith(rootPath))
			{
				throw new CrucibleResourceException("The request resource \"" + resource + "\" is outside of the mod directory \"" + rootPath + "\".")
				{
					ResourceName = resource
				};
			}
			return fullPath;
		}
	}
	public interface ICrucibleResourceProvider
	{
		bool Exists(string resourceName);

		string ReadAllText(string resourceName);

		byte[] ReadAllBytes(string resourceName);
	}
	public class RelativeResourceProvider : ICrucibleResourceProvider
	{
		public ICrucibleResourceProvider Parent { get; }

		public string RelativePath { get; }

		public RelativeResourceProvider(ICrucibleResourceProvider parent, string relativePath)
		{
			Parent = parent;
			RelativePath = relativePath;
		}

		public bool Exists(string resourceName)
		{
			return Parent.Exists(Path.Combine(RelativePath, resourceName));
		}

		public byte[] ReadAllBytes(string resourceName)
		{
			resourceName = Path.Combine(RelativePath, resourceName);
			return Parent.ReadAllBytes(resourceName);
		}

		public string ReadAllText(string resourceName)
		{
			resourceName = Path.Combine(RelativePath, resourceName);
			return Parent.ReadAllText(resourceName);
		}
	}
	public class ZipResourceProvider : ICrucibleResourceProvider
	{
		private readonly ZipArchive zip;

		public ZipResourceProvider(string zipFilePath)
		{
			zip = ZipFile.OpenRead(zipFilePath);
		}

		public bool Exists(string resourceName)
		{
			return zip.Entries.Any((ZipArchiveEntry x) => x.FullName == resourceName);
		}

		public byte[] ReadAllBytes(string resourceName)
		{
			ZipArchiveEntry zipArchiveEntry = zip.Entries.FirstOrDefault((ZipArchiveEntry x) => x.FullName == resourceName);
			if (zipArchiveEntry == null)
			{
				throw new FileNotFoundException("Resource " + resourceName + " not found in zip file.");
			}
			using MemoryStream memoryStream = new MemoryStream();
			using Stream stream = zipArchiveEntry.Open();
			stream.CopyTo(memoryStream);
			return memoryStream.ToArray();
		}

		public string ReadAllText(string resourceName)
		{
			using Stream stream = (zip.Entries.FirstOrDefault((ZipArchiveEntry x) => x.FullName == resourceName) ?? throw new FileNotFoundException("Resource " + resourceName + " not found in zip file.")).Open();
			using StreamReader streamReader = new StreamReader(stream);
			return streamReader.ReadToEnd();
		}
	}
}
namespace RoboPhredDev.PotionCraft.Crucible.CruciblePackages
{
	public class CruciblePackageBepInExDependencyConfig : CruciblePackageDependencyConfig
	{
		public string BepInExGUID { get; set; }

		public override void EnsureDependencyMet()
		{
			if (!BepInExPluginUtilities.GetAllPlugins().Any((BepInPlugin x) => x.GUID == BepInExGUID))
			{
				throw CrucibleMissingDependencyException.CreateMissingDependencyException(base.PackageMod.GUID, BepInExGUID, "*");
			}
		}
	}
	public static class CruciblePackageConfigElementRegistry
	{
		private static readonly HashSet<Type> WarnedTypes = new HashSet<Type>();

		public static IEnumerable<Type> GetConfigRoots()
		{
			foreach (Type item in CrucibleTypeRegistry.GetTypesByAttribute<CruciblePackageConfigRootAttribute>())
			{
				if (!typeof(CruciblePackageConfigRoot).IsAssignableFrom(item))
				{
					WarnMisimplementedRoot(item);
				}
				yield return item;
			}
		}

		public static IEnumerable<Type> GetSubjectExtensionTypes<TSubject>()
		{
			var enumerable = from candidate in CrucibleTypeRegistry.GetTypesByAttribute<CruciblePackageConfigExtensionAttribute>()
				let attribute = (CruciblePackageConfigExtensionAttribute)Attribute.GetCustomAttribute(candidate, typeof(CruciblePackageConfigExtensionAttribute))
				where attribute.SubjectType.IsAssignableFrom(typeof(TSubject))
				select new
				{
					Type = candidate,
					Attribute = attribute
				};
			foreach (var item in enumerable)
			{
				if (VerifySubjectExtension(item.Type, item.Attribute))
				{
					yield return item.Type;
				}
			}
		}

		private static bool VerifySubjectExtension(Type classType, CruciblePackageConfigExtensionAttribute extensionAttribute)
		{
			if (!typeof(ICruciblePackageConfigExtension<>).MakeGenericType(extensionAttribute.SubjectType).IsAssignableFrom(classType) || !classType.BaseTypeIncludes(typeof(CruciblePackageConfigNode)))
			{
				WarnMisimplementedExtension(classType, extensionAttribute.SubjectType);
				return false;
			}
			return true;
		}

		private static void WarnMisimplementedRoot(Type type)
		{
			if (WarnedTypes.Add(type))
			{
				CrucibleLog.LogInScope("net.robophreddev.PotionCraft.Crucible", "Cannot use " + type.FullName + " as a config root because it lacks the appropriate " + typeof(CruciblePackageConfigRoot).Name + " interface.");
			}
		}

		private static void WarnMisimplementedExtension(Type type, Type subjectType)
		{
			if (WarnedTypes.Add(type))
			{
				CrucibleLog.LogInScope("net.robophreddev.PotionCraft.Crucible", "Cannot use " + type.FullName + " as a config extension for " + subjectType.Name + " because it either lacks the appropriate " + typeof(ICruciblePackageConfigExtension<>).Name + " interface, specifies the wrong TSubject, or does not implement CruciblePackageConfigNode.");
			}
		}
	}
	[AttributeUsage(AttributeTargets.Class)]
	[CrucibleRegistryAttribute]
	public class CruciblePackageConfigExtensionAttribute : Attribute
	{
		public Type SubjectType { get; }

		public CruciblePackageConfigExtensionAttribute(Type subject)
		{
			SubjectType = subject;
		}
	}
	public abstract class CruciblePackageConfigNode : IAfterYamlDeserialization
	{
		public CruciblePackageMod PackageMod { get; private set; }

		void IAfterYamlDeserialization.OnDeserializeCompleted(Mark start, Mark end)
		{
			CruciblePackageMod.OnNodeLoaded(this);
			OnDeserializeCompleted(start, end);
		}

		internal void SetParentMod(CruciblePackageMod packageMod)
		{
			PackageMod = packageMod;
		}

		protected virtual void OnDeserializeCompleted(Mark start, Mark end)
		{
		}
	}
	public abstract class CruciblePackageConfigRoot : CruciblePackageConfigNode
	{
		public abstract void ApplyConfiguration();
	}
	[AttributeUsage(AttributeTargets.Class)]
	[CrucibleRegistryAttribute]
	public class CruciblePackageConfigRootAttribute : Attribute
	{
	}
	public abstract class CruciblePackageConfigSubjectNode<TSubject> : CruciblePackageConfigNode, IDeserializeExtraData
	{
		private readonly List<ICruciblePackageConfigExtension<TSubject>> extensions = new List<ICruciblePackageConfigExtension<TSubject>>();

		public TSubject Subject { get; private set; }

		public void ApplyConfiguration()
		{
			Subject = GetSubject();
			OnApplyConfiguration(Subject);
			foreach (ICruciblePackageConfigExtension<TSubject> extension in extensions)
			{
				extension.OnApplyConfiguration(Subject);
			}
		}

		void IDeserializeExtraData.OnDeserializeExtraData(ReplayParser parser)
		{
			extensions.Clear();
			foreach (Type subjectExtensionType in CruciblePackageConfigElementRegistry.GetSubjectExtensionTypes<TSubject>())
			{
				parser.Reset();
				ICruciblePackageConfigExtension<TSubject> item = (ICruciblePackageConfigExtension<TSubject>)Deserializer.DeserializeFromParser(subjectExtensionType, (IParser)(object)parser);
				extensions.Add(item);
			}
		}

		protected abstract TSubject GetSubject();

		protected abstract void OnApplyConfiguration(TSubject subject);
	}
	[DuckTypeCandidate(typeof(CruciblePackageBepInExDependencyConfig))]
	public abstract class CruciblePackageDependencyConfig : CruciblePackageConfigNode
	{
		public abstract void EnsureDependencyMet();
	}
	public sealed class CruciblePackageMod : ICrucibleResourceProvider
	{
		private static List<CruciblePackageConfigNode> loadingNodes;

		private ICrucibleResourceProvider resources;

		private CruciblePackageModConfig parsedData;

		public string Name => parsedData.Name ?? ID;

		public string Author => parsedData.Author;

		public string Version => parsedData.Version;

		public List<CruciblePackageDependencyConfig> Dependencies => parsedData.Dependencies;

		public string ID { get; }

		public string GUID => "Crucible::$" + ID;

		public string Namespace => ID;

		public ICollection<CruciblePackageConfigRoot> Roots => parsedData.ParsedRoots;

		private CruciblePackageMod(string id, ICrucibleResourceProvider resourceProvider)
		{
			ID = id;
			resources = resourceProvider;
		}

		public static CruciblePackageMod LoadFromFolder(string directory)
		{
			loadingNodes = new List<CruciblePackageConfigNode>();
			try
			{
				CruciblePackageMod mod = new CruciblePackageMod(new DirectoryInfo(directory).Name, new DirectoryResourceProvider(directory));
				mod.parsedData = CrucibleResources.WithResourceProvider(mod, () => Deserializer.DeserializeFromResource<CruciblePackageModConfig>("package.yml"));
				loadingNodes.ForEach(delegate(CruciblePackageConfigNode x)
				{
					x.SetParentMod(mod);
				});
				return mod;
			}
			catch (Exception ex)
			{
				throw new CruciblePackageModLoadException("Failed to load crucible package from \"" + directory + "\": " + ex.Message, ex);
			}
			finally
			{
				loadingNodes = null;
			}
		}

		public static CruciblePackageMod LoadFromZip(string zipFilePath)
		{
			loadingNodes = new List<CruciblePackageConfigNode>();
			try
			{
				CruciblePackageMod mod = new CruciblePackageMod(Path.GetFileNameWithoutExtension(zipFilePath), new ZipResourceProvider(zipFilePath));
				mod.parsedData = CrucibleResources.WithResourceProvider(mod, () => Deserializer.DeserializeFromResource<CruciblePackageModConfig>("package.yml"));
				loadingNodes.ForEach(delegate(CruciblePackageConfigNode x)
				{
					x.SetParentMod(mod);
				});
				return mod;
			}
			catch (Exception ex)
			{
				throw new CruciblePackageModLoadException("Failed to load crucible package from \"" + zipFilePath + "\": " + ex.Message, ex);
			}
			finally
			{
				loadingNodes = null;
			}
		}

		public bool Exists(string resourceName)
		{
			return resources.Exists(resourceName);
		}

		public string ReadAllText(string resourceName)
		{
			return resources.ReadAllText(resourceName);
		}

		public byte[] ReadAllBytes(string resourceName)
		{
			return resources.ReadAllBytes(resourceName);
		}

		public void EnsureDependenciesMet()
		{
			if (Dependencies == null)
			{
				return;
			}
			foreach (CruciblePackageDependencyConfig dependency in Dependencies)
			{
				dependency.EnsureDependencyMet();
			}
		}

		public void ApplyConfiguration()
		{
			CrucibleResources.WithResourceProvider(this, delegate
			{
				CrucibleLog.RunInLogScope(Namespace, delegate
				{
					parsedData.ParsedRoots.ForEach(delegate(CruciblePackageConfigRoot x)
					{
						x.ApplyConfiguration();
					});
				});
			});
		}

		public override string ToString()
		{
			return ID + " (" + Namespace + ")";
		}

		internal static void OnNodeLoaded(CruciblePackageConfigNode node)
		{
			if (loadingNodes == null)
			{
				throw new Exception("Cannot instantiate a CruciblePackageConfigNode when no CruciblePackageMod is being loaded.");
			}
			loadingNodes.Add(node);
		}
	}
	public class CruciblePackageModConfig : IDeserializeExtraData
	{
		public List<CruciblePackageConfigRoot> ParsedRoots { get; } = new List<CruciblePackageConfigRoot>();


		public string Name { get; set; }

		public string Author { get; set; }

		public string Version { get; set; }

		public List<CruciblePackageDependencyConfig> Dependencies { get; set; } = new List<CruciblePackageDependencyConfig>();


		void IDeserializeExtraData.OnDeserializeExtraData(ReplayParser parser)
		{
			ParsedRoots.Clear();
			foreach (Type configRoot in CruciblePackageConfigElementRegistry.GetConfigRoots())
			{
				parser.Reset();
				ParsedRoots.Add((CruciblePackageConfigRoot)Deserializer.DeserializeFromParser(configRoot, (IParser)(object)parser));
			}
		}
	}
	public class CruciblePackageModLoadException : Exception
	{
		public string ModPath { get; set; }

		public CruciblePackageModLoadException(string message)
			: base(message)
		{
		}

		public CruciblePackageModLoadException(string message, Exception innerException)
			: base(message, innerException)
		{
		}
	}
	public interface ICruciblePackageConfigExtension<in TSubject>
	{
		void OnApplyConfiguration(TSubject subject);
	}
}