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