Decompiled source of Onyx API v0.1.0

plugins/Onyx_API.dll

Decompiled 2 hours ago
using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Security;
using System.Security.Permissions;
using System.Text;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Logging;
using JetBrains.Annotations;
using Logger;
using Microsoft.CodeAnalysis;
using Mono.Cecil.Cil;
using MonoMod.Cil;
using MonoMod.RuntimeDetour;
using On;
using SimpleJSON;
using UnityEngine;
using UnityEngine.Events;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyCompany("Onyx_API")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+05ff5857bd64ceb84191d20ff708f65366a87c7d")]
[assembly: AssemblyProduct("Onyx_API")]
[assembly: AssemblyTitle("Onyx_API")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace SimpleJSON
{
	public enum JSONNodeType
	{
		Array = 1,
		Object = 2,
		String = 3,
		Number = 4,
		NullValue = 5,
		Boolean = 6,
		None = 7,
		Custom = 255
	}
	public enum JSONTextMode
	{
		Compact,
		Indent
	}
	public abstract class JSONNode
	{
		public struct Enumerator
		{
			private enum Type
			{
				None,
				Array,
				Object
			}

			private Type type;

			private Dictionary<string, JSONNode>.Enumerator m_Object;

			private List<JSONNode>.Enumerator m_Array;

			public bool IsValid => type != Type.None;

			public KeyValuePair<string, JSONNode> Current
			{
				get
				{
					if (type == Type.Array)
					{
						return new KeyValuePair<string, JSONNode>(string.Empty, m_Array.Current);
					}
					if (type == Type.Object)
					{
						return m_Object.Current;
					}
					return new KeyValuePair<string, JSONNode>(string.Empty, null);
				}
			}

			public Enumerator(List<JSONNode>.Enumerator aArrayEnum)
			{
				type = Type.Array;
				m_Object = default(Dictionary<string, JSONNode>.Enumerator);
				m_Array = aArrayEnum;
			}

			public Enumerator(Dictionary<string, JSONNode>.Enumerator aDictEnum)
			{
				type = Type.Object;
				m_Object = aDictEnum;
				m_Array = default(List<JSONNode>.Enumerator);
			}

			public bool MoveNext()
			{
				if (type == Type.Array)
				{
					return m_Array.MoveNext();
				}
				if (type == Type.Object)
				{
					return m_Object.MoveNext();
				}
				return false;
			}
		}

		public struct ValueEnumerator
		{
			private Enumerator m_Enumerator;

			public JSONNode Current => m_Enumerator.Current.Value;

			public ValueEnumerator(List<JSONNode>.Enumerator aArrayEnum)
				: this(new Enumerator(aArrayEnum))
			{
			}

			public ValueEnumerator(Dictionary<string, JSONNode>.Enumerator aDictEnum)
				: this(new Enumerator(aDictEnum))
			{
			}

			public ValueEnumerator(Enumerator aEnumerator)
			{
				m_Enumerator = aEnumerator;
			}

			public bool MoveNext()
			{
				return m_Enumerator.MoveNext();
			}

			public ValueEnumerator GetEnumerator()
			{
				return this;
			}
		}

		public struct KeyEnumerator
		{
			private Enumerator m_Enumerator;

			public string Current => m_Enumerator.Current.Key;

			public KeyEnumerator(List<JSONNode>.Enumerator aArrayEnum)
				: this(new Enumerator(aArrayEnum))
			{
			}

			public KeyEnumerator(Dictionary<string, JSONNode>.Enumerator aDictEnum)
				: this(new Enumerator(aDictEnum))
			{
			}

			public KeyEnumerator(Enumerator aEnumerator)
			{
				m_Enumerator = aEnumerator;
			}

			public bool MoveNext()
			{
				return m_Enumerator.MoveNext();
			}

			public KeyEnumerator GetEnumerator()
			{
				return this;
			}
		}

		public class LinqEnumerator : IEnumerator<KeyValuePair<string, JSONNode>>, IDisposable, IEnumerator, IEnumerable<KeyValuePair<string, JSONNode>>, IEnumerable
		{
			private JSONNode m_Node;

			private Enumerator m_Enumerator;

			public KeyValuePair<string, JSONNode> Current => m_Enumerator.Current;

			object IEnumerator.Current => m_Enumerator.Current;

			internal LinqEnumerator(JSONNode aNode)
			{
				m_Node = aNode;
				if (m_Node != null)
				{
					m_Enumerator = m_Node.GetEnumerator();
				}
			}

			public bool MoveNext()
			{
				return m_Enumerator.MoveNext();
			}

			public void Dispose()
			{
				m_Node = null;
				m_Enumerator = default(Enumerator);
			}

			public IEnumerator<KeyValuePair<string, JSONNode>> GetEnumerator()
			{
				return new LinqEnumerator(m_Node);
			}

			public void Reset()
			{
				if (m_Node != null)
				{
					m_Enumerator = m_Node.GetEnumerator();
				}
			}

			IEnumerator IEnumerable.GetEnumerator()
			{
				return new LinqEnumerator(m_Node);
			}
		}

		public static bool forceASCII = false;

		public static bool longAsString = false;

		public static bool allowLineComments = true;

		[ThreadStatic]
		private static StringBuilder m_EscapeBuilder;

		public abstract JSONNodeType Tag { get; }

		public virtual JSONNode this[int aIndex]
		{
			get
			{
				return null;
			}
			set
			{
			}
		}

		public virtual JSONNode this[string aKey]
		{
			get
			{
				return null;
			}
			set
			{
			}
		}

		public virtual string Value
		{
			get
			{
				return "";
			}
			set
			{
			}
		}

		public virtual int Count => 0;

		public virtual bool IsNumber => false;

		public virtual bool IsString => false;

		public virtual bool IsBoolean => false;

		public virtual bool IsNull => false;

		public virtual bool IsArray => false;

		public virtual bool IsObject => false;

		public virtual bool Inline
		{
			get
			{
				return false;
			}
			set
			{
			}
		}

		public virtual IEnumerable<JSONNode> Children
		{
			get
			{
				yield break;
			}
		}

		public IEnumerable<JSONNode> DeepChildren
		{
			get
			{
				foreach (JSONNode C in Children)
				{
					foreach (JSONNode deepChild in C.DeepChildren)
					{
						yield return deepChild;
					}
				}
			}
		}

		public IEnumerable<KeyValuePair<string, JSONNode>> Linq => new LinqEnumerator(this);

		public KeyEnumerator Keys => new KeyEnumerator(GetEnumerator());

		public ValueEnumerator Values => new ValueEnumerator(GetEnumerator());

		public virtual double AsDouble
		{
			get
			{
				double result = 0.0;
				if (double.TryParse(Value, NumberStyles.Float, CultureInfo.InvariantCulture, out result))
				{
					return result;
				}
				return 0.0;
			}
			set
			{
				Value = value.ToString(CultureInfo.InvariantCulture);
			}
		}

		public virtual int AsInt
		{
			get
			{
				return (int)AsDouble;
			}
			set
			{
				AsDouble = value;
			}
		}

		public virtual float AsFloat
		{
			get
			{
				return (float)AsDouble;
			}
			set
			{
				AsDouble = value;
			}
		}

		public virtual bool AsBool
		{
			get
			{
				bool result = false;
				if (bool.TryParse(Value, out result))
				{
					return result;
				}
				return !string.IsNullOrEmpty(Value);
			}
			set
			{
				Value = (value ? "true" : "false");
			}
		}

		public virtual long AsLong
		{
			get
			{
				long result = 0L;
				if (long.TryParse(Value, NumberStyles.Integer, CultureInfo.InvariantCulture, out result))
				{
					return result;
				}
				return 0L;
			}
			set
			{
				Value = value.ToString(CultureInfo.InvariantCulture);
			}
		}

		public virtual ulong AsULong
		{
			get
			{
				ulong result = 0uL;
				if (ulong.TryParse(Value, NumberStyles.Integer, CultureInfo.InvariantCulture, out result))
				{
					return result;
				}
				return 0uL;
			}
			set
			{
				Value = value.ToString(CultureInfo.InvariantCulture);
			}
		}

		public virtual JSONArray AsArray => this as JSONArray;

		public virtual JSONObject AsObject => this as JSONObject;

		internal static StringBuilder EscapeBuilder
		{
			get
			{
				if (m_EscapeBuilder == null)
				{
					m_EscapeBuilder = new StringBuilder();
				}
				return m_EscapeBuilder;
			}
		}

		public virtual void Add(string aKey, JSONNode aItem)
		{
		}

		public virtual void Add(JSONNode aItem)
		{
			Add("", aItem);
		}

		public virtual JSONNode Remove(string aKey)
		{
			return null;
		}

		public virtual JSONNode Remove(int aIndex)
		{
			return null;
		}

		public virtual JSONNode Remove(JSONNode aNode)
		{
			return aNode;
		}

		public virtual void Clear()
		{
		}

		public virtual JSONNode Clone()
		{
			return null;
		}

		public virtual bool HasKey(string aKey)
		{
			return false;
		}

		public virtual JSONNode GetValueOrDefault(string aKey, JSONNode aDefault)
		{
			return aDefault;
		}

		public override string ToString()
		{
			StringBuilder stringBuilder = new StringBuilder();
			WriteToStringBuilder(stringBuilder, 0, 0, JSONTextMode.Compact);
			return stringBuilder.ToString();
		}

		public virtual string ToString(int aIndent)
		{
			StringBuilder stringBuilder = new StringBuilder();
			WriteToStringBuilder(stringBuilder, 0, aIndent, JSONTextMode.Indent);
			return stringBuilder.ToString();
		}

		internal abstract void WriteToStringBuilder(StringBuilder aSB, int aIndent, int aIndentInc, JSONTextMode aMode);

		public abstract Enumerator GetEnumerator();

		public static implicit operator JSONNode(string s)
		{
			return (s == null) ? ((JSONNode)JSONNull.CreateOrGet()) : ((JSONNode)new JSONString(s));
		}

		public static implicit operator string(JSONNode d)
		{
			return (d == null) ? null : d.Value;
		}

		public static implicit operator JSONNode(double n)
		{
			return new JSONNumber(n);
		}

		public static implicit operator double(JSONNode d)
		{
			return (d == null) ? 0.0 : d.AsDouble;
		}

		public static implicit operator JSONNode(float n)
		{
			return new JSONNumber(n);
		}

		public static implicit operator float(JSONNode d)
		{
			return (d == null) ? 0f : d.AsFloat;
		}

		public static implicit operator JSONNode(int n)
		{
			return new JSONNumber(n);
		}

		public static implicit operator int(JSONNode d)
		{
			return (!(d == null)) ? d.AsInt : 0;
		}

		public static implicit operator JSONNode(long n)
		{
			if (longAsString)
			{
				return new JSONString(n.ToString(CultureInfo.InvariantCulture));
			}
			return new JSONNumber(n);
		}

		public static implicit operator long(JSONNode d)
		{
			return (d == null) ? 0 : d.AsLong;
		}

		public static implicit operator JSONNode(ulong n)
		{
			if (longAsString)
			{
				return new JSONString(n.ToString(CultureInfo.InvariantCulture));
			}
			return new JSONNumber(n);
		}

		public static implicit operator ulong(JSONNode d)
		{
			return (d == null) ? 0 : d.AsULong;
		}

		public static implicit operator JSONNode(bool b)
		{
			return new JSONBool(b);
		}

		public static implicit operator bool(JSONNode d)
		{
			return !(d == null) && d.AsBool;
		}

		public static implicit operator JSONNode(KeyValuePair<string, JSONNode> aKeyValue)
		{
			return aKeyValue.Value;
		}

		public static bool operator ==(JSONNode a, object b)
		{
			if ((object)a == b)
			{
				return true;
			}
			bool flag = a is JSONNull || (object)a == null || a is JSONLazyCreator;
			bool flag2 = b is JSONNull || b == null || b is JSONLazyCreator;
			if (flag && flag2)
			{
				return true;
			}
			return !flag && a.Equals(b);
		}

		public static bool operator !=(JSONNode a, object b)
		{
			return !(a == b);
		}

		public override bool Equals(object obj)
		{
			return (object)this == obj;
		}

		public override int GetHashCode()
		{
			return base.GetHashCode();
		}

		internal static string Escape(string aText)
		{
			StringBuilder escapeBuilder = EscapeBuilder;
			escapeBuilder.Length = 0;
			if (escapeBuilder.Capacity < aText.Length + aText.Length / 10)
			{
				escapeBuilder.Capacity = aText.Length + aText.Length / 10;
			}
			foreach (char c in aText)
			{
				switch (c)
				{
				case '\\':
					escapeBuilder.Append("\\\\");
					continue;
				case '"':
					escapeBuilder.Append("\\\"");
					continue;
				case '\n':
					escapeBuilder.Append("\\n");
					continue;
				case '\r':
					escapeBuilder.Append("\\r");
					continue;
				case '\t':
					escapeBuilder.Append("\\t");
					continue;
				case '\b':
					escapeBuilder.Append("\\b");
					continue;
				case '\f':
					escapeBuilder.Append("\\f");
					continue;
				}
				if (c < ' ' || (forceASCII && c > '\u007f'))
				{
					ushort num = c;
					escapeBuilder.Append("\\u").Append(num.ToString("X4"));
				}
				else
				{
					escapeBuilder.Append(c);
				}
			}
			string result = escapeBuilder.ToString();
			escapeBuilder.Length = 0;
			return result;
		}

		private static JSONNode ParseElement(string token, bool quoted)
		{
			if (quoted)
			{
				return token;
			}
			if (token.Length <= 5)
			{
				string text = token.ToLower();
				if (text == "false" || text == "true")
				{
					return text == "true";
				}
				if (text == "null")
				{
					return JSONNull.CreateOrGet();
				}
			}
			if (double.TryParse(token, NumberStyles.Float, CultureInfo.InvariantCulture, out var result))
			{
				return result;
			}
			return token;
		}

		public static JSONNode Parse(string aJSON)
		{
			Stack<JSONNode> stack = new Stack<JSONNode>();
			JSONNode jSONNode = null;
			int i = 0;
			StringBuilder stringBuilder = new StringBuilder();
			string aKey = "";
			bool flag = false;
			bool flag2 = false;
			bool flag3 = false;
			for (; i < aJSON.Length; i++)
			{
				switch (aJSON[i])
				{
				case '{':
					if (flag)
					{
						stringBuilder.Append(aJSON[i]);
						break;
					}
					stack.Push(new JSONObject());
					if (jSONNode != null)
					{
						jSONNode.Add(aKey, stack.Peek());
					}
					aKey = "";
					stringBuilder.Length = 0;
					jSONNode = stack.Peek();
					flag3 = false;
					break;
				case '[':
					if (flag)
					{
						stringBuilder.Append(aJSON[i]);
						break;
					}
					stack.Push(new JSONArray());
					if (jSONNode != null)
					{
						jSONNode.Add(aKey, stack.Peek());
					}
					aKey = "";
					stringBuilder.Length = 0;
					jSONNode = stack.Peek();
					flag3 = false;
					break;
				case ']':
				case '}':
					if (flag)
					{
						stringBuilder.Append(aJSON[i]);
						break;
					}
					if (stack.Count == 0)
					{
						throw new Exception("JSON Parse: Too many closing brackets");
					}
					stack.Pop();
					if (stringBuilder.Length > 0 || flag2)
					{
						jSONNode.Add(aKey, ParseElement(stringBuilder.ToString(), flag2));
					}
					if (jSONNode != null)
					{
						jSONNode.Inline = !flag3;
					}
					flag2 = false;
					aKey = "";
					stringBuilder.Length = 0;
					if (stack.Count > 0)
					{
						jSONNode = stack.Peek();
					}
					break;
				case ':':
					if (flag)
					{
						stringBuilder.Append(aJSON[i]);
						break;
					}
					aKey = stringBuilder.ToString();
					stringBuilder.Length = 0;
					flag2 = false;
					break;
				case '"':
					flag = !flag;
					flag2 = flag2 || flag;
					break;
				case ',':
					if (flag)
					{
						stringBuilder.Append(aJSON[i]);
						break;
					}
					if (stringBuilder.Length > 0 || flag2)
					{
						jSONNode.Add(aKey, ParseElement(stringBuilder.ToString(), flag2));
					}
					flag2 = false;
					aKey = "";
					stringBuilder.Length = 0;
					flag2 = false;
					break;
				case '\n':
				case '\r':
					flag3 = true;
					break;
				case '\t':
				case ' ':
					if (flag)
					{
						stringBuilder.Append(aJSON[i]);
					}
					break;
				case '\\':
					i++;
					if (flag)
					{
						char c = aJSON[i];
						switch (c)
						{
						case 't':
							stringBuilder.Append('\t');
							break;
						case 'r':
							stringBuilder.Append('\r');
							break;
						case 'n':
							stringBuilder.Append('\n');
							break;
						case 'b':
							stringBuilder.Append('\b');
							break;
						case 'f':
							stringBuilder.Append('\f');
							break;
						case 'u':
						{
							string s = aJSON.Substring(i + 1, 4);
							stringBuilder.Append((char)int.Parse(s, NumberStyles.AllowHexSpecifier));
							i += 4;
							break;
						}
						default:
							stringBuilder.Append(c);
							break;
						}
					}
					break;
				case '/':
					if (allowLineComments && !flag && i + 1 < aJSON.Length && aJSON[i + 1] == '/')
					{
						while (++i < aJSON.Length && aJSON[i] != '\n' && aJSON[i] != '\r')
						{
						}
					}
					else
					{
						stringBuilder.Append(aJSON[i]);
					}
					break;
				default:
					stringBuilder.Append(aJSON[i]);
					break;
				case '\ufeff':
					break;
				}
			}
			if (flag)
			{
				throw new Exception("JSON Parse: Quotation marks seems to be messed up.");
			}
			if (jSONNode == null)
			{
				return ParseElement(stringBuilder.ToString(), flag2);
			}
			return jSONNode;
		}
	}
	public class JSONArray : JSONNode
	{
		private List<JSONNode> m_List = new List<JSONNode>();

		private bool inline = false;

		public override bool Inline
		{
			get
			{
				return inline;
			}
			set
			{
				inline = value;
			}
		}

		public override JSONNodeType Tag => JSONNodeType.Array;

		public override bool IsArray => true;

		public override JSONNode this[int aIndex]
		{
			get
			{
				if (aIndex < 0 || aIndex >= m_List.Count)
				{
					return new JSONLazyCreator(this);
				}
				return m_List[aIndex];
			}
			set
			{
				if (value == null)
				{
					value = JSONNull.CreateOrGet();
				}
				if (aIndex < 0 || aIndex >= m_List.Count)
				{
					m_List.Add(value);
				}
				else
				{
					m_List[aIndex] = value;
				}
			}
		}

		public override JSONNode this[string aKey]
		{
			get
			{
				return new JSONLazyCreator(this);
			}
			set
			{
				if (value == null)
				{
					value = JSONNull.CreateOrGet();
				}
				m_List.Add(value);
			}
		}

		public override int Count => m_List.Count;

		public override IEnumerable<JSONNode> Children
		{
			get
			{
				foreach (JSONNode item in m_List)
				{
					yield return item;
				}
			}
		}

		public override Enumerator GetEnumerator()
		{
			return new Enumerator(m_List.GetEnumerator());
		}

		public override void Add(string aKey, JSONNode aItem)
		{
			if (aItem == null)
			{
				aItem = JSONNull.CreateOrGet();
			}
			m_List.Add(aItem);
		}

		public override JSONNode Remove(int aIndex)
		{
			if (aIndex < 0 || aIndex >= m_List.Count)
			{
				return null;
			}
			JSONNode result = m_List[aIndex];
			m_List.RemoveAt(aIndex);
			return result;
		}

		public override JSONNode Remove(JSONNode aNode)
		{
			m_List.Remove(aNode);
			return aNode;
		}

		public override void Clear()
		{
			m_List.Clear();
		}

		public override JSONNode Clone()
		{
			JSONArray jSONArray = new JSONArray();
			jSONArray.m_List.Capacity = m_List.Capacity;
			foreach (JSONNode item in m_List)
			{
				if (item != null)
				{
					jSONArray.Add(item.Clone());
				}
				else
				{
					jSONArray.Add(null);
				}
			}
			return jSONArray;
		}

		internal override void WriteToStringBuilder(StringBuilder aSB, int aIndent, int aIndentInc, JSONTextMode aMode)
		{
			aSB.Append('[');
			int count = m_List.Count;
			if (inline)
			{
				aMode = JSONTextMode.Compact;
			}
			for (int i = 0; i < count; i++)
			{
				if (i > 0)
				{
					aSB.Append(',');
				}
				if (aMode == JSONTextMode.Indent)
				{
					aSB.AppendLine();
				}
				if (aMode == JSONTextMode.Indent)
				{
					aSB.Append(' ', aIndent + aIndentInc);
				}
				m_List[i].WriteToStringBuilder(aSB, aIndent + aIndentInc, aIndentInc, aMode);
			}
			if (aMode == JSONTextMode.Indent)
			{
				aSB.AppendLine().Append(' ', aIndent);
			}
			aSB.Append(']');
		}
	}
	public class JSONObject : JSONNode
	{
		private Dictionary<string, JSONNode> m_Dict = new Dictionary<string, JSONNode>();

		private bool inline = false;

		public override bool Inline
		{
			get
			{
				return inline;
			}
			set
			{
				inline = value;
			}
		}

		public override JSONNodeType Tag => JSONNodeType.Object;

		public override bool IsObject => true;

		public override JSONNode this[string aKey]
		{
			get
			{
				if (m_Dict.TryGetValue(aKey, out var value))
				{
					return value;
				}
				return new JSONLazyCreator(this, aKey);
			}
			set
			{
				if (value == null)
				{
					value = JSONNull.CreateOrGet();
				}
				if (m_Dict.ContainsKey(aKey))
				{
					m_Dict[aKey] = value;
				}
				else
				{
					m_Dict.Add(aKey, value);
				}
			}
		}

		public override JSONNode this[int aIndex]
		{
			get
			{
				if (aIndex < 0 || aIndex >= m_Dict.Count)
				{
					return null;
				}
				return m_Dict.ElementAt(aIndex).Value;
			}
			set
			{
				if (value == null)
				{
					value = JSONNull.CreateOrGet();
				}
				if (aIndex >= 0 && aIndex < m_Dict.Count)
				{
					string key = m_Dict.ElementAt(aIndex).Key;
					m_Dict[key] = value;
				}
			}
		}

		public override int Count => m_Dict.Count;

		public override IEnumerable<JSONNode> Children
		{
			get
			{
				foreach (KeyValuePair<string, JSONNode> item in m_Dict)
				{
					yield return item.Value;
				}
			}
		}

		public override Enumerator GetEnumerator()
		{
			return new Enumerator(m_Dict.GetEnumerator());
		}

		public override void Add(string aKey, JSONNode aItem)
		{
			if (aItem == null)
			{
				aItem = JSONNull.CreateOrGet();
			}
			if (aKey != null)
			{
				if (m_Dict.ContainsKey(aKey))
				{
					m_Dict[aKey] = aItem;
				}
				else
				{
					m_Dict.Add(aKey, aItem);
				}
			}
			else
			{
				m_Dict.Add(Guid.NewGuid().ToString(), aItem);
			}
		}

		public override JSONNode Remove(string aKey)
		{
			if (!m_Dict.ContainsKey(aKey))
			{
				return null;
			}
			JSONNode result = m_Dict[aKey];
			m_Dict.Remove(aKey);
			return result;
		}

		public override JSONNode Remove(int aIndex)
		{
			if (aIndex < 0 || aIndex >= m_Dict.Count)
			{
				return null;
			}
			KeyValuePair<string, JSONNode> keyValuePair = m_Dict.ElementAt(aIndex);
			m_Dict.Remove(keyValuePair.Key);
			return keyValuePair.Value;
		}

		public override JSONNode Remove(JSONNode aNode)
		{
			try
			{
				KeyValuePair<string, JSONNode> keyValuePair = m_Dict.Where((KeyValuePair<string, JSONNode> k) => k.Value == aNode).First();
				m_Dict.Remove(keyValuePair.Key);
				return aNode;
			}
			catch
			{
				return null;
			}
		}

		public override void Clear()
		{
			m_Dict.Clear();
		}

		public override JSONNode Clone()
		{
			JSONObject jSONObject = new JSONObject();
			foreach (KeyValuePair<string, JSONNode> item in m_Dict)
			{
				jSONObject.Add(item.Key, item.Value.Clone());
			}
			return jSONObject;
		}

		public override bool HasKey(string aKey)
		{
			return m_Dict.ContainsKey(aKey);
		}

		public override JSONNode GetValueOrDefault(string aKey, JSONNode aDefault)
		{
			if (m_Dict.TryGetValue(aKey, out var value))
			{
				return value;
			}
			return aDefault;
		}

		internal override void WriteToStringBuilder(StringBuilder aSB, int aIndent, int aIndentInc, JSONTextMode aMode)
		{
			aSB.Append('{');
			bool flag = true;
			if (inline)
			{
				aMode = JSONTextMode.Compact;
			}
			foreach (KeyValuePair<string, JSONNode> item in m_Dict)
			{
				if (!flag)
				{
					aSB.Append(',');
				}
				flag = false;
				if (aMode == JSONTextMode.Indent)
				{
					aSB.AppendLine();
				}
				if (aMode == JSONTextMode.Indent)
				{
					aSB.Append(' ', aIndent + aIndentInc);
				}
				aSB.Append('"').Append(JSONNode.Escape(item.Key)).Append('"');
				if (aMode == JSONTextMode.Compact)
				{
					aSB.Append(':');
				}
				else
				{
					aSB.Append(" : ");
				}
				item.Value.WriteToStringBuilder(aSB, aIndent + aIndentInc, aIndentInc, aMode);
			}
			if (aMode == JSONTextMode.Indent)
			{
				aSB.AppendLine().Append(' ', aIndent);
			}
			aSB.Append('}');
		}
	}
	public class JSONString : JSONNode
	{
		private string m_Data;

		public override JSONNodeType Tag => JSONNodeType.String;

		public override bool IsString => true;

		public override string Value
		{
			get
			{
				return m_Data;
			}
			set
			{
				m_Data = value;
			}
		}

		public override Enumerator GetEnumerator()
		{
			return default(Enumerator);
		}

		public JSONString(string aData)
		{
			m_Data = aData;
		}

		public override JSONNode Clone()
		{
			return new JSONString(m_Data);
		}

		internal override void WriteToStringBuilder(StringBuilder aSB, int aIndent, int aIndentInc, JSONTextMode aMode)
		{
			aSB.Append('"').Append(JSONNode.Escape(m_Data)).Append('"');
		}

		public override bool Equals(object obj)
		{
			if (base.Equals(obj))
			{
				return true;
			}
			if (obj is string text)
			{
				return m_Data == text;
			}
			JSONString jSONString = obj as JSONString;
			if (jSONString != null)
			{
				return m_Data == jSONString.m_Data;
			}
			return false;
		}

		public override int GetHashCode()
		{
			return m_Data.GetHashCode();
		}

		public override void Clear()
		{
			m_Data = "";
		}
	}
	public class JSONNumber : JSONNode
	{
		private double m_Data;

		public override JSONNodeType Tag => JSONNodeType.Number;

		public override bool IsNumber => true;

		public override string Value
		{
			get
			{
				return m_Data.ToString(CultureInfo.InvariantCulture);
			}
			set
			{
				if (double.TryParse(value, NumberStyles.Float, CultureInfo.InvariantCulture, out var result))
				{
					m_Data = result;
				}
			}
		}

		public override double AsDouble
		{
			get
			{
				return m_Data;
			}
			set
			{
				m_Data = value;
			}
		}

		public override long AsLong
		{
			get
			{
				return (long)m_Data;
			}
			set
			{
				m_Data = value;
			}
		}

		public override ulong AsULong
		{
			get
			{
				return (ulong)m_Data;
			}
			set
			{
				m_Data = value;
			}
		}

		public override Enumerator GetEnumerator()
		{
			return default(Enumerator);
		}

		public JSONNumber(double aData)
		{
			m_Data = aData;
		}

		public JSONNumber(string aData)
		{
			Value = aData;
		}

		public override JSONNode Clone()
		{
			return new JSONNumber(m_Data);
		}

		internal override void WriteToStringBuilder(StringBuilder aSB, int aIndent, int aIndentInc, JSONTextMode aMode)
		{
			aSB.Append(Value.ToString(CultureInfo.InvariantCulture));
		}

		private static bool IsNumeric(object value)
		{
			return value is int || value is uint || value is float || value is double || value is decimal || value is long || value is ulong || value is short || value is ushort || value is sbyte || value is byte;
		}

		public override bool Equals(object obj)
		{
			if (obj == null)
			{
				return false;
			}
			if (base.Equals(obj))
			{
				return true;
			}
			JSONNumber jSONNumber = obj as JSONNumber;
			if (jSONNumber != null)
			{
				return m_Data == jSONNumber.m_Data;
			}
			if (IsNumeric(obj))
			{
				return Convert.ToDouble(obj) == m_Data;
			}
			return false;
		}

		public override int GetHashCode()
		{
			return m_Data.GetHashCode();
		}

		public override void Clear()
		{
			m_Data = 0.0;
		}
	}
	public class JSONBool : JSONNode
	{
		private bool m_Data;

		public override JSONNodeType Tag => JSONNodeType.Boolean;

		public override bool IsBoolean => true;

		public override string Value
		{
			get
			{
				return m_Data.ToString();
			}
			set
			{
				if (bool.TryParse(value, out var result))
				{
					m_Data = result;
				}
			}
		}

		public override bool AsBool
		{
			get
			{
				return m_Data;
			}
			set
			{
				m_Data = value;
			}
		}

		public override Enumerator GetEnumerator()
		{
			return default(Enumerator);
		}

		public JSONBool(bool aData)
		{
			m_Data = aData;
		}

		public JSONBool(string aData)
		{
			Value = aData;
		}

		public override JSONNode Clone()
		{
			return new JSONBool(m_Data);
		}

		internal override void WriteToStringBuilder(StringBuilder aSB, int aIndent, int aIndentInc, JSONTextMode aMode)
		{
			aSB.Append(m_Data ? "true" : "false");
		}

		public override bool Equals(object obj)
		{
			if (obj == null)
			{
				return false;
			}
			if (obj is bool)
			{
				return m_Data == (bool)obj;
			}
			return false;
		}

		public override int GetHashCode()
		{
			return m_Data.GetHashCode();
		}

		public override void Clear()
		{
			m_Data = false;
		}
	}
	public class JSONNull : JSONNode
	{
		private static JSONNull m_StaticInstance = new JSONNull();

		public static bool reuseSameInstance = true;

		public override JSONNodeType Tag => JSONNodeType.NullValue;

		public override bool IsNull => true;

		public override string Value
		{
			get
			{
				return "null";
			}
			set
			{
			}
		}

		public override bool AsBool
		{
			get
			{
				return false;
			}
			set
			{
			}
		}

		public static JSONNull CreateOrGet()
		{
			if (reuseSameInstance)
			{
				return m_StaticInstance;
			}
			return new JSONNull();
		}

		private JSONNull()
		{
		}

		public override Enumerator GetEnumerator()
		{
			return default(Enumerator);
		}

		public override JSONNode Clone()
		{
			return CreateOrGet();
		}

		public override bool Equals(object obj)
		{
			if ((object)this == obj)
			{
				return true;
			}
			return obj is JSONNull;
		}

		public override int GetHashCode()
		{
			return 0;
		}

		internal override void WriteToStringBuilder(StringBuilder aSB, int aIndent, int aIndentInc, JSONTextMode aMode)
		{
			aSB.Append("null");
		}
	}
	internal class JSONLazyCreator : JSONNode
	{
		private JSONNode m_Node = null;

		private string m_Key = null;

		public override JSONNodeType Tag => JSONNodeType.None;

		public override JSONNode this[int aIndex]
		{
			get
			{
				return new JSONLazyCreator(this);
			}
			set
			{
				Set(new JSONArray()).Add(value);
			}
		}

		public override JSONNode this[string aKey]
		{
			get
			{
				return new JSONLazyCreator(this, aKey);
			}
			set
			{
				Set(new JSONObject()).Add(aKey, value);
			}
		}

		public override int AsInt
		{
			get
			{
				Set(new JSONNumber(0.0));
				return 0;
			}
			set
			{
				Set(new JSONNumber(value));
			}
		}

		public override float AsFloat
		{
			get
			{
				Set(new JSONNumber(0.0));
				return 0f;
			}
			set
			{
				Set(new JSONNumber(value));
			}
		}

		public override double AsDouble
		{
			get
			{
				Set(new JSONNumber(0.0));
				return 0.0;
			}
			set
			{
				Set(new JSONNumber(value));
			}
		}

		public override long AsLong
		{
			get
			{
				if (JSONNode.longAsString)
				{
					Set(new JSONString("0"));
				}
				else
				{
					Set(new JSONNumber(0.0));
				}
				return 0L;
			}
			set
			{
				if (JSONNode.longAsString)
				{
					Set(new JSONString(value.ToString(CultureInfo.InvariantCulture)));
				}
				else
				{
					Set(new JSONNumber(value));
				}
			}
		}

		public override ulong AsULong
		{
			get
			{
				if (JSONNode.longAsString)
				{
					Set(new JSONString("0"));
				}
				else
				{
					Set(new JSONNumber(0.0));
				}
				return 0uL;
			}
			set
			{
				if (JSONNode.longAsString)
				{
					Set(new JSONString(value.ToString(CultureInfo.InvariantCulture)));
				}
				else
				{
					Set(new JSONNumber(value));
				}
			}
		}

		public override bool AsBool
		{
			get
			{
				Set(new JSONBool(aData: false));
				return false;
			}
			set
			{
				Set(new JSONBool(value));
			}
		}

		public override JSONArray AsArray => Set(new JSONArray());

		public override JSONObject AsObject => Set(new JSONObject());

		public override Enumerator GetEnumerator()
		{
			return default(Enumerator);
		}

		public JSONLazyCreator(JSONNode aNode)
		{
			m_Node = aNode;
			m_Key = null;
		}

		public JSONLazyCreator(JSONNode aNode, string aKey)
		{
			m_Node = aNode;
			m_Key = aKey;
		}

		private T Set<T>(T aVal) where T : JSONNode
		{
			if (m_Key == null)
			{
				m_Node.Add(aVal);
			}
			else
			{
				m_Node.Add(m_Key, aVal);
			}
			m_Node = null;
			return aVal;
		}

		public override void Add(JSONNode aItem)
		{
			Set(new JSONArray()).Add(aItem);
		}

		public override void Add(string aKey, JSONNode aItem)
		{
			Set(new JSONObject()).Add(aKey, aItem);
		}

		public static bool operator ==(JSONLazyCreator a, object b)
		{
			if (b == null)
			{
				return true;
			}
			return (object)a == b;
		}

		public static bool operator !=(JSONLazyCreator a, object b)
		{
			return !(a == b);
		}

		public override bool Equals(object obj)
		{
			if (obj == null)
			{
				return true;
			}
			return (object)this == obj;
		}

		public override int GetHashCode()
		{
			return 0;
		}

		internal override void WriteToStringBuilder(StringBuilder aSB, int aIndent, int aIndentInc, JSONTextMode aMode)
		{
			aSB.Append("null");
		}
	}
	public static class JSON
	{
		public static JSONNode Parse(string aJSON)
		{
			return JSONNode.Parse(aJSON);
		}
	}
}
namespace Logger
{
	internal static class Log
	{
		private static ManualLogSource _logSource;

		internal static void Init(ManualLogSource logSource)
		{
			_logSource = logSource;
		}

		internal static void message(object data)
		{
			_logSource.LogMessage(data);
		}

		internal static void Debug(object data)
		{
			_logSource.LogDebug(data);
		}

		internal static void Error(object data)
		{
			_logSource.LogError(data);
		}

		internal static void Fatal(object data)
		{
			_logSource.LogFatal(data);
		}

		internal static void Info(object data)
		{
			StackFrame stackFrame = new StackFrame(1);
			MethodBase method = stackFrame.GetMethod();
			_logSource.LogInfo((object)("[" + method.Name + "]: " + data));
		}

		internal static void Message(object data)
		{
			message(data);
		}

		internal static void Warning(object data)
		{
			_logSource.LogWarning(data);
		}
	}
}
namespace Onyx_API
{
	public class API_Manager : MonoBehaviour
	{
		public static UnityEvent nextFixedUpdate = new UnityEvent();

		private static UnityEvent thisFixedUpdate;

		public static IEnumerator Init()
		{
			yield return (object)new WaitForFixedUpdate();
			GameObject apiManager = Object.Instantiate<GameObject>(new GameObject("API_Manager"));
			Object.DontDestroyOnLoad((Object)(object)apiManager);
			apiManager.AddComponent<API_Manager>();
		}

		private void Start()
		{
			Initializer.Init();
		}

		private void FixedUpdate()
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Expected O, but got Unknown
			UnityEvent obj = thisFixedUpdate;
			if (obj != null)
			{
				obj.Invoke();
			}
			thisFixedUpdate = nextFixedUpdate;
			nextFixedUpdate = new UnityEvent();
		}
	}
	[PublicAPI]
	[AttributeUsage(AttributeTargets.Method, AllowMultiple = true, Inherited = false)]
	[MeansImplicitUse]
	public class Initializer : Attribute
	{
		private class DescendingComp : IComparer<float>
		{
			public int Compare(float x, float y)
			{
				return -x.CompareTo(y);
			}
		}

		public List<Type> dependencies = new List<Type>();

		private MethodInfo _method;

		private Type _associatedType;

		public static void Init()
		{
			Queue<Initializer> queue = new Queue<Initializer>();
			foreach (Assembly scannableAssembly in GetScannableAssemblies())
			{
				Type[] types = GetTypes(scannableAssembly);
				foreach (Type type in types)
				{
					if (!type.IsClass)
					{
						continue;
					}
					MethodInfo[] methods = type.GetMethods(BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
					foreach (MethodInfo methodInfo in methods)
					{
						object[] customAttributes = methodInfo.GetCustomAttributes(inherit: false);
						foreach (object obj in customAttributes)
						{
							if (obj is Initializer)
							{
								Initializer initializer = obj as Initializer;
								initializer._method = methodInfo;
								initializer._associatedType = type;
								queue.Enqueue(initializer);
							}
						}
					}
				}
			}
			int num = 0;
			while (queue.Count > 0)
			{
				Initializer initializer2 = queue.Dequeue();
				if (!ResolvedDependencies(initializer2, queue))
				{
					queue.Enqueue(initializer2);
					num++;
					if (num > queue.Count)
					{
						Log.Error("Failed resolving Initializer dependencies, circular dependency");
						break;
					}
				}
				else
				{
					initializer2._method.Invoke(null, null);
				}
			}
		}

		private static bool ResolvedDependencies(Initializer toResolve, Queue<Initializer> initializers)
		{
			IEnumerable<Type> source = initializers.Select((Initializer initializer) => initializer._associatedType);
			foreach (Type dependency in toResolve.dependencies)
			{
				if (source.Contains(dependency))
				{
					return false;
				}
			}
			return true;
		}

		public Initializer(Type[] dependencies = null)
		{
			if (dependencies == null)
			{
				dependencies = new Type[0];
			}
			Type[] array = dependencies;
			List<Type> list = new List<Type>(array.Length);
			list.AddRange(array);
			this.dependencies = list;
		}

		public static IEnumerable<Assembly> GetScannableAssemblies()
		{
			List<string> b = new List<string>();
			foreach (KeyValuePair<string, PluginInfo> pluginInfo in Chainloader.PluginInfos)
			{
				string text = ((object)pluginInfo.Value).ToString();
				b.Add(text.Substring(0, text.IndexOf(" ")));
			}
			return from assembly in AppDomain.CurrentDomain.GetAssemblies()
				where b.Contains(assembly.GetName().Name)
				select assembly;
		}

		public static Type[] GetTypes(Assembly assembly)
		{
			Type[] types;
			try
			{
				types = assembly.GetTypes();
			}
			catch (ReflectionTypeLoadException ex)
			{
				Log.Error($"ScanAssembly:  {ex}");
				types = ex.Types;
				if (types == null)
				{
					return null;
				}
			}
			catch (Exception arg)
			{
				Log.Error($"ScanAssembly:  {arg}");
				return null;
			}
			return types;
		}
	}
	[BepInPlugin("com.Onyx.Onyx_API", "Onyx_API", "1.0.0")]
	public class Onyx_API : BaseUnityPlugin
	{
		public const string PluginGUID = "com.Onyx.Onyx_API";

		public const string PluginAuthor = "Onyx";

		public const string PluginName = "Onyx_API";

		public const string PluginVersion = "1.0.0";

		public void Awake()
		{
			Log.Init(((BaseUnityPlugin)this).Logger);
			((MonoBehaviour)this).StartCoroutine(API_Manager.Init());
		}
	}
	public static class Singletons
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static hook_Awake <0>__SetGameScript;
		}

		public static GameScript GameScript;

		[Initializer(null)]
		private static void Init()
		{
			//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_001c: Expected O, but got Unknown
			object obj = <>O.<0>__SetGameScript;
			if (obj == null)
			{
				hook_Awake val = SetGameScript;
				<>O.<0>__SetGameScript = val;
				obj = (object)val;
			}
			GameScript.Awake += (hook_Awake)obj;
		}

		private static void SetGameScript(orig_Awake orig, GameScript self)
		{
			orig.Invoke(self);
			GameScript = self;
		}
	}
	public static class Reflection
	{
		private const BindingFlags AllFlags = BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic;

		public static MethodInfo GetPropertyGetter(this Type type, string propName)
		{
			return type.GetProperty(propName, BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic).GetGetMethod(nonPublic: true);
		}

		public static MethodInfo GetPropertySetter(this Type type, string propName)
		{
			return type.GetProperty(propName, BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic).GetSetMethod(nonPublic: true);
		}
	}
}
namespace Onyx_API.Items
{
	public static class ItemCatalog
	{
		private static bool _initialized = false;

		private static readonly Dictionary<int, ItemDef> indexToDef = new Dictionary<int, ItemDef>();

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

		public static readonly HashSet<ItemDef> allItemDefs = new HashSet<ItemDef>();

		private static int lastItemIndex = 1000;

		public static bool Initialized
		{
			get
			{
				return _initialized;
			}
			private set
			{
				_initialized = value;
			}
		}

		[Initializer(new Type[] { typeof(ItemFlagCatalog) })]
		private static void Init()
		{
			Log.Info("Initializing ItemCatalog");
			string path = Path.Combine(Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "Json"), "Items.json");
			string aJSON = File.ReadAllText(path);
			JSONNode.Enumerator enumerator = JSON.Parse(aJSON)[0].GetEnumerator();
			while (enumerator.MoveNext())
			{
				JSONNode value = enumerator.Current.Value;
				HashSet<int> hashSet = new HashSet<int>();
				JSONNode.Enumerator enumerator2 = value["Flags"].GetEnumerator();
				while (enumerator2.MoveNext())
				{
					hashSet.Add(ItemFlagCatalog.FindItemFlag(enumerator2.Current.Value).Index);
				}
				int maxDurability = value["MaxDurability"] ?? ((JSONNode)(-1));
				RegisterItemDefInternal(new ItemDef(value["Name"])
				{
					flags = hashSet,
					maxDurability = maxDurability
				}, value["Index"]);
			}
			Initialized = true;
			Log.Info("Finished initializing ItemCatalog");
		}

		public static ItemDef GetItemDef(int itemIndex)
		{
			if (!Initialized)
			{
				throw new Exception("ItemCatalog is not Initialized yet");
			}
			if (indexToDef.TryGetValue(itemIndex, out var value))
			{
				return value;
			}
			throw new ArgumentException();
		}

		public static ItemDef FindItemDef(string itemName)
		{
			if (!Initialized)
			{
				throw new Exception("ItemCatalog is not Initialized yet");
			}
			if (nameToDef.TryGetValue(itemName, out var value))
			{
				return value;
			}
			throw new ArgumentException();
		}

		private static bool RegisterItemDefInternal(ItemDef itemDef, int index)
		{
			if (Initialized)
			{
				throw new Exception("ItemCatalog is already Initialized");
			}
			if (itemDef == null)
			{
				throw new ArgumentException("Itemdef cannot be null");
			}
			if (indexToDef.ContainsKey(index))
			{
				throw new ArgumentException("itemindex is already registered");
			}
			typeof(ItemDef).GetField("_intValue", BindingFlags.Instance | BindingFlags.NonPublic).SetValue(itemDef, index);
			indexToDef.Add(index, itemDef);
			nameToDef.Add(itemDef.name, itemDef);
			allItemDefs.Add(itemDef);
			return true;
		}

		public static bool RegisterItemDef(ItemDef itemDef)
		{
			lastItemIndex++;
			return RegisterItemDefInternal(itemDef, lastItemIndex);
		}
	}
	public class ItemDef
	{
		private int _intValue = -1;

		public string name;

		public string description;

		public readonly bool showStats;

		public HashSet<int> flags;

		public GameObject proijectilePrefab;

		public int maxDurability;

		public const int None = 0;

		public const int Wood = 1;

		public const int Wooden_Plank = 2;

		public const int Wooden_Stick = 3;

		public const int Ironite_Ore = 4;

		public const int Goldium_Ore = 5;

		public const int Diamonite_Ore = 6;

		public const int Raw_Meat = 7;

		public const int Cooked_Meat = 8;

		public const int Herb = 9;

		public const int Shroom = 10;

		public const int Root = 11;

		public const int Ironite_Bar = 12;

		public const int Goldium_Bar = 13;

		public const int Diamonite_Bar = 14;

		public const int HP_Potion = 15;

		public const int Mana_Potion = 16;

		public const int Vial_of_Poison = 17;

		public const int Monster_Bone = 18;

		public const int Monster_Hide = 19;

		public const int Monster_Pelt = 20;

		public const int Raw_Chicken = 21;

		public const int Cooked_Chicken = 22;

		public const int Spider_Web = 23;

		public const int Sword_Hilt = 24;

		public const int Wooden_Blade = 25;

		public const int Axe_Handle = 26;

		public const int Pick_Handle = 27;

		public const int Unstrung_Bow = 28;

		public const int String = 29;

		public const int Fire_Bug = 30;

		public const int Thunder_Bug = 31;

		public const int Ironite_Blade = 32;

		public const int Goldmium_Blade = 33;

		public const int Diamonite_Blade = 34;

		public const int Ironite_Great_Blade = 35;

		public const int Goldium_Great_Blade = 36;

		public const int Diamonite_Great_Blade = 37;

		public const int Stone = 38;

		public const int Refined_Stone = 39;

		public const int Stone_Blade = 40;

		public const int Stone_Great_Blade = 41;

		public const int Big_HP_Potion = 42;

		public const int Big_Mana_Potion = 43;

		public const int Mysterious_Potion = 44;

		public const int Big_Mysterious_Potion = 45;

		public const int Total_Biscuit = 46;

		public const int Coal = 47;

		public const int Firestarter = 48;

		public const int Mystery_Key = 49;

		public const int Bone_Blade = 50;

		public const int Refined_Bone = 51;

		public const int Bone_Arrow = 52;

		public const int Stone_Arrow = 53;

		public const int Ironite_Arrow = 54;

		public const int Goldium_Arrow = 55;

		public const int Diamonite_Arrow = 56;

		public const int Dragonite_Arrow = 57;

		public const int Adamantite_Arrow = 58;

		public const int Obsidian_Arrow = 59;

		public const int Crystalite_Fragment = 60;

		public const int Crystalite_Shard = 61;

		public const int Dragonite_Ore = 62;

		public const int Dragonite_Bar = 63;

		public const int Adamantite_Ore = 64;

		public const int Adamantite_Bar = 65;

		public const int Obsidian_Ore = 66;

		public const int Obsidian_Bar = 67;

		public const int Net = 68;

		public const int Fire_Gem_I = 69;

		public const int Thunder_Gem_I = 70;

		public const int Ice_Gem_I = 71;

		public const int Stone_Dagger = 72;

		public const int Bone_Dagger = 73;

		public const int Ironite_Dagger = 74;

		public const int Goldium_Dagger = 75;

		public const int Diamonite_Dagger = 76;

		public const int Tribal_Drum = 77;

		public const int Drum_of_Strength = 78;

		public const int Drum_of_Dexterity = 79;

		public const int Drum_of_Wisdom = 80;

		public const int Ice_Bug = 81;

		public const int Refined_Leather = 82;

		public const int Rugged_Leather = 83;

		public const int Tribal_Leather = 84;

		public const int Elegant_Leather = 85;

		public const int Royal_Leather = 86;

		public const int Luminous_Leather = 87;

		public const int Rugged_Fabric = 88;

		public const int Tribal_Fabric = 89;

		public const int Elegant__Fabric = 90;

		public const int Royal_Fabric = 91;

		public const int Luminous_Fabric = 92;

		public const int Refined_Cloth = 94;

		public const int Spirit_Gem = 95;

		public const int Wooden_Sword = 500;

		public const int Wooden_Axe = 501;

		public const int Wooden_Pick = 502;

		public const int Ironite_Sword = 503;

		public const int Ironite_Axe = 504;

		public const int Ironite_Pick = 505;

		public const int Goldium_Sword = 506;

		public const int Goldium_Axe = 507;

		public const int Goldium_Pick = 508;

		public const int Diamonite_Sword = 509;

		public const int Diamonite_Axe = 510;

		public const int Diamonite_Pick = 511;

		public const int Stone_Sword = 512;

		public const int Stone_Axe = 513;

		public const int Stone_Pick = 514;

		public const int Wooden_Bow = 515;

		public const int Bone_Sword = 516;

		public const int Bone_Axe = 517;

		public const int Bone_Pick = 518;

		public const int Wooden_Club = 519;

		public const int Lightbringer = 520;

		public const int Scourge_Blade = 521;

		public const int Dragonite_Pick = 522;

		public const int Wightslayer = 523;

		public const int Adamantite_Axe = 524;

		public const int Adamantite_Pick = 525;

		public const int Spellblade = 526;

		public const int Obsidian_Axe = 527;

		public const int Obsidian_Pick = 528;

		public const int Bug_Net = 529;

		public const int Crystal_Bow = 530;

		public const int Emerald_Katana = 531;

		public const int Emerald_Combat_Axe = 532;

		public const int Obsidian_Sword = 533;

		public const int Laser_Sword = 534;

		public const int Laser_Crossbow = 535;

		public const int Fire_Bow = 536;

		public const int Giant_Fish = 550;

		public const int Ironite_Great_Axe = 560;

		public const int Goldium_Great_Axe = 561;

		public const int Diamonite_Great_Axe = 562;

		public const int Stone_Great_Axe = 563;

		public const int Hellswrath = 564;

		public const int The_Philibuster = 565;

		public const int Jelly_Blade = 566;

		public const int Zweihander = 567;

		public const int Icebrand = 568;

		public const int Firebrand = 569;

		public const int Thunderbrand = 570;

		public const int Fireball = 600;

		public const int Bolt = 601;

		public const int Frostshard = 602;

		public const int Summon_Zombie = 603;

		public const int Ironite_Helm = 700;

		public const int Goldium_Helm = 701;

		public const int Diamonite_Helm = 702;

		public const int Stone_Helm = 703;

		public const int Bone_Helm = 704;

		public const int Rugged_Cap = 705;

		public const int Tribal_Cap = 706;

		public const int Elegant_Cap = 707;

		public const int Royal_Cap = 708;

		public const int Luminous_Cap = 709;

		public const int Rugged_Hood = 710;

		public const int Tribal_Hood = 711;

		public const int Elegant_Hood = 712;

		public const int Royal_Hood = 713;

		public const int Luminous_Hood = 714;

		public const int Ironite_Armor = 800;

		public const int Goldium_Armor = 801;

		public const int Diamonite_Armor = 802;

		public const int Stone_Armor = 803;

		public const int Bone_Armor = 804;

		public const int Rugged_Cloak = 805;

		public const int Tribal_Cloak = 806;

		public const int Elegant_Cloak = 807;

		public const int Royal_Cloak = 808;

		public const int Luminous_Cloak = 809;

		public const int Rugged_Robes = 810;

		public const int Tribal_Robes = 811;

		public const int Elegant_Robes = 812;

		public const int Royal_Robes = 813;

		public const int Luminous_Robes = 814;

		public const int Ironite_Shield = 900;

		public const int Goldium_Shield = 901;

		public const int Diamonite_Shield = 902;

		public const int Stone_Shield = 903;

		public const int Bone_Shield = 904;

		public const int Ryvenraths_Scale = 905;

		public const int Paladin_Guard = 906;

		public const int Scourge_Shield = 907;

		public const int Ring_of_Power = 950;

		public const int Ring_of_Wisdom = 951;

		public const int Ring_of_Nature = 952;

		public const int Ring_of_Life = 953;

		public const int Ring_of_Rage = 954;

		public const int Ring_of_Insanity = 955;

		public const int Archers_Ring = 956;

		public const int Ring_of_Balance = 957;

		public int Index
		{
			get
			{
				return _intValue;
			}
			private set
			{
				_intValue = value;
			}
		}

		public ItemDef(string name)
		{
			this.name = name;
			description = "";
			showStats = false;
			flags = new HashSet<int>();
			maxDurability = -1;
			base..ctor();
		}
	}
	public class ItemFlag(string name)
	{
		public string name = name;

		private int _intValue;

		public const int None = 0;

		public const int HeadArmor = 1;

		public const int BodyArmor = 2;

		public const int Shield = 3;

		public const int Ammo = 4;

		public const int Consumable = 5;

		public const int Usable = 6;

		public int Index
		{
			get
			{
				return _intValue;
			}
			private set
			{
				_intValue = value;
			}
		}
	}
	public static class ItemFlagCatalog
	{
		private static readonly Dictionary<int, ItemFlag> indexToFlag = new Dictionary<int, ItemFlag>();

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

		private static int lastItemFlagIndex = 10;

		public static bool Initialized = false;

		[Initializer(null)]
		private static void Init()
		{
			Log.Info("Initializing ItemFlagCatalog");
			string path = Path.Combine(Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "Json"), "ItemFlags.json");
			string aJSON = File.ReadAllText(path);
			JSONNode.Enumerator enumerator = JSON.Parse(aJSON)[0].GetEnumerator();
			while (enumerator.MoveNext())
			{
				JSONNode value = enumerator.Current.Value;
				RegisterItemFlagInternal(new ItemFlag(value["Name"]), value["Index"]);
			}
			Initialized = true;
			Log.Info("Finished initializing ItemFlagCatalog");
		}

		public static bool RegisterItemFlag(ItemFlag itemFlag)
		{
			lastItemFlagIndex++;
			return RegisterItemFlagInternal(itemFlag, lastItemFlagIndex);
		}

		private static bool RegisterItemFlagInternal(ItemFlag itemFlag, int index)
		{
			if (Initialized)
			{
				throw new Exception("ItemFlagCatalog is already Initialized");
			}
			typeof(ItemFlag).GetField("_intValue", BindingFlags.Instance | BindingFlags.NonPublic).SetValue(itemFlag, index);
			indexToFlag.Add(index, itemFlag);
			nameToFlag.Add(itemFlag.name, itemFlag);
			return true;
		}

		public static ItemFlag GetItemFlag(int index)
		{
			if (!Initialized)
			{
				throw new Exception("ItemFlagCatalog is not Initialized yet");
			}
			if (indexToFlag.TryGetValue(index, out var value))
			{
				return value;
			}
			throw new ArgumentException("Flag with index " + index + " does not exist");
		}

		public static ItemFlag FindItemFlag(string name)
		{
			if (!Initialized)
			{
				throw new Exception("ItemFlagCatalog is not Initialized yet");
			}
			if (nameToFlag.TryGetValue(name, out var value))
			{
				return value;
			}
			throw new ArgumentException("Flag with name " + name + " does not exist");
		}
	}
	public static class ItemPatches
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static Manipulator <0>__KinematicCharacterController_KinematicCharacterMotor_UpdatePhase1;

			public static Func<Item[], bool> <1>__test;
		}

		[Initializer(null)]
		private static void Init()
		{
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Expected O, but got Unknown
			Type nestedType = typeof(GameScript).GetNestedType("$UseItem$1677", BindingFlags.NonPublic).GetNestedType("$", BindingFlags.NonPublic);
			MethodInfo? method = nestedType.GetMethod("MoveNext");
			object obj = <>O.<0>__KinematicCharacterController_KinematicCharacterMotor_UpdatePhase1;
			if (obj == null)
			{
				Manipulator val = KinematicCharacterController_KinematicCharacterMotor_UpdatePhase1;
				<>O.<0>__KinematicCharacterController_KinematicCharacterMotor_UpdatePhase1 = val;
				obj = (object)val;
			}
			new ILHook((MethodBase)method, (Manipulator)obj);
		}

		private static void KinematicCharacterController_KinematicCharacterMotor_UpdatePhase1(ILContext il)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Expected O, but got Unknown
			ILCursor val = new ILCursor(il);
			ILLabel val2 = default(ILLabel);
			while (val.TryGotoNext((MoveType)0, new Func<Instruction, bool>[6]
			{
				(Instruction x) => ILPatternMatchingExt.MatchLdsfld(x, typeof(GameScript), "inventory"),
				(Instruction x) => ILPatternMatchingExt.MatchLdcI4(x, 23),
				(Instruction x) => ILPatternMatchingExt.MatchLdelemAny(x, ref val2),
				(Instruction x) => ILPatternMatchingExt.MatchLdfld(x, typeof(Item), "id"),
				(Instruction x) => ILPatternMatchingExt.MatchLdcI4(x, 52),
				(Instruction x) => ILPatternMatchingExt.MatchBlt(x, ref val2)
			}))
			{
				int index = val.Index;
				val.Index = index + 1;
				val.EmitDelegate<Func<Item[], bool>>((Func<Item[], bool>)test);
			}
			static bool test(Item[] inventory)
			{
				return ItemCatalog.GetItemDef(inventory[23].id).flags.Contains(4);
			}
		}
	}
}