feat(battle-engine): full Unity/VFX/god-object shims + expanded copy closure (2570 files)

Authored Unity primitive/object-model shim, VFX layer (control-flow-preserving, InstantVfx never invokes its action -- headless suppression), god-object stubs (GameMgr/EffectMgr/UIManager with faithfully-extracted nested enums), View/UI/Touch tree, LitJson+BetterList+Tuple copied, third-party stubs. Discovered Roslyn header-error masking: fixing class-header type errors unmasks body references, so the true copy closure is ~2570 files (was 782 under masking). Errors: masked-25720 -> 268; our shim files compile clean. Remaining: ~50 residual shim/external types, 24 NGUI UI-base overrides, static-type fixes, plus likely 1-2 more unmask waves.

SVSim.BattleEngine/Engine/LitJson/ArrayMetadata.cs

@@ -0,0 +1,52 @@
+using System;
+
+namespace LitJson;
+
+internal struct ArrayMetadata
+{
+	private Type element_type;
+
+	private bool is_array;
+
+	private bool is_list;
+
+	public Type ElementType
+	{
+		get
+		{
+			if (element_type == null)
+			{
+				return typeof(JsonData);
+			}
+			return element_type;
+		}
+		set
+		{
+			element_type = value;
+		}
+	}
+
+	public bool IsArray
+	{
+		get
+		{
+			return is_array;
+		}
+		set
+		{
+			is_array = value;
+		}
+	}
+
+	public bool IsList
+	{
+		get
+		{
+			return is_list;
+		}
+		set
+		{
+			is_list = value;
+		}
+	}
+}

SVSim.BattleEngine/Engine/LitJson/Condition.cs

@@ -0,0 +1,10 @@
+namespace LitJson;
+
+internal enum Condition
+{
+	InArray,
+	InObject,
+	NotAProperty,
+	Property,
+	Value
+}

SVSim.BattleEngine/Engine/LitJson/ExporterFunc.cs

@@ -0,0 +1,4 @@
+namespace LitJson;
+
+internal delegate void ExporterFunc(object obj, JsonWriter writer);
+public delegate void ExporterFunc<T>(T obj, JsonWriter writer);

SVSim.BattleEngine/Engine/LitJson/FsmContext.cs

@@ -0,0 +1,12 @@
+namespace LitJson;
+
+internal class FsmContext
+{
+	public bool Return;
+
+	public int NextState;
+
+	public Lexer L;
+
+	public int StateStack;
+}

SVSim.BattleEngine/Engine/LitJson/IJsonWrapper.cs

@@ -0,0 +1,48 @@
+using System.Collections;
+
+namespace LitJson;
+
+public interface IJsonWrapper : IList, ICollection, IEnumerable, IOrderedDictionary, IDictionary
+{
+	bool IsArray { get; }
+
+	bool IsBoolean { get; }
+
+	bool IsDouble { get; }
+
+	bool IsInt { get; }
+
+	bool IsLong { get; }
+
+	bool IsObject { get; }
+
+	bool IsString { get; }
+
+	bool GetBoolean();
+
+	double GetDouble();
+
+	int GetInt();
+
+	JsonType GetJsonType();
+
+	long GetLong();
+
+	string GetString();
+
+	void SetBoolean(bool val);
+
+	void SetDouble(double val);
+
+	void SetInt(int val);
+
+	void SetJsonType(JsonType type);
+
+	void SetLong(long val);
+
+	void SetString(string val);
+
+	string ToJson();
+
+	void ToJson(JsonWriter writer);
+}

SVSim.BattleEngine/Engine/LitJson/IOrderedDictionary.cs

@@ -0,0 +1,14 @@
+using System.Collections;
+
+namespace LitJson;
+
+public interface IOrderedDictionary : IDictionary, ICollection, IEnumerable
+{
+	object this[int index] { get; set; }
+
+	new IDictionaryEnumerator GetEnumerator();
+
+	void Insert(int index, object key, object value);
+
+	void RemoveAt(int index);
+}

SVSim.BattleEngine/Engine/LitJson/ImporterFunc.cs

@@ -0,0 +1,4 @@
+namespace LitJson;
+
+internal delegate object ImporterFunc(object input);
+public delegate TValue ImporterFunc<TJson, TValue>(TJson input);

SVSim.BattleEngine/Engine/LitJson/JsonData.cs

@@ -0,0 +1,873 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.IO;
+
+namespace LitJson;
+
+public class JsonData : IJsonWrapper, IList, ICollection, IEnumerable, IOrderedDictionary, IDictionary, IEquatable<JsonData>
+{
+	private IList<JsonData> inst_array;
+
+	private bool inst_boolean;
+
+	private double inst_double;
+
+	private int inst_int;
+
+	private long inst_long;
+
+	private IDictionary<string, JsonData> inst_object;
+
+	private string inst_string;
+
+	private string json;
+
+	private JsonType type;
+
+	private IList<KeyValuePair<string, JsonData>> object_list;
+
+	public int Count => EnsureCollection().Count;
+
+	public bool IsArray => type == JsonType.Array;
+
+	public bool IsBoolean => type == JsonType.Boolean;
+
+	public bool IsDouble => type == JsonType.Double;
+
+	public bool IsInt => type == JsonType.Int;
+
+	public bool IsLong => type == JsonType.Long;
+
+	public bool IsObject => type == JsonType.Object;
+
+	public bool IsString => type == JsonType.String;
+
+	public ICollection<string> Keys
+	{
+		get
+		{
+			EnsureDictionary();
+			return inst_object.Keys;
+		}
+	}
+
+	public ICollection<JsonData> Values
+	{
+		get
+		{
+			EnsureDictionary();
+			return inst_object.Values;
+		}
+	}
+
+	int ICollection.Count => Count;
+
+	bool ICollection.IsSynchronized => EnsureCollection().IsSynchronized;
+
+	object ICollection.SyncRoot => EnsureCollection().SyncRoot;
+
+	bool IDictionary.IsFixedSize => EnsureDictionary().IsFixedSize;
+
+	bool IDictionary.IsReadOnly => EnsureDictionary().IsReadOnly;
+
+	ICollection IDictionary.Keys
+	{
+		get
+		{
+			EnsureDictionary();
+			IList<string> list = new List<string>();
+			foreach (KeyValuePair<string, JsonData> item in object_list)
+			{
+				list.Add(item.Key);
+			}
+			return (ICollection)list;
+		}
+	}
+
+	ICollection IDictionary.Values
+	{
+		get
+		{
+			EnsureDictionary();
+			IList<JsonData> list = new List<JsonData>();
+			foreach (KeyValuePair<string, JsonData> item in object_list)
+			{
+				list.Add(item.Value);
+			}
+			return (ICollection)list;
+		}
+	}
+
+	bool IJsonWrapper.IsArray => IsArray;
+
+	bool IJsonWrapper.IsBoolean => IsBoolean;
+
+	bool IJsonWrapper.IsDouble => IsDouble;
+
+	bool IJsonWrapper.IsInt => IsInt;
+
+	bool IJsonWrapper.IsLong => IsLong;
+
+	bool IJsonWrapper.IsObject => IsObject;
+
+	bool IJsonWrapper.IsString => IsString;
+
+	bool IList.IsFixedSize => EnsureList().IsFixedSize;
+
+	bool IList.IsReadOnly => EnsureList().IsReadOnly;
+
+	object IDictionary.this[object key]
+	{
+		get
+		{
+			return EnsureDictionary()[key];
+		}
+		set
+		{
+			if (!(key is string))
+			{
+				throw new ArgumentException("The key has to be a string");
+			}
+			JsonData value2 = ToJsonData(value);
+			this[(string)key] = value2;
+		}
+	}
+
+	object IOrderedDictionary.this[int idx]
+	{
+		get
+		{
+			EnsureDictionary();
+			return object_list[idx].Value;
+		}
+		set
+		{
+			EnsureDictionary();
+			JsonData value2 = ToJsonData(value);
+			KeyValuePair<string, JsonData> keyValuePair = object_list[idx];
+			inst_object[keyValuePair.Key] = value2;
+			KeyValuePair<string, JsonData> value3 = new KeyValuePair<string, JsonData>(keyValuePair.Key, value2);
+			object_list[idx] = value3;
+		}
+	}
+
+	object IList.this[int index]
+	{
+		get
+		{
+			return EnsureList()[index];
+		}
+		set
+		{
+			EnsureList();
+			JsonData value2 = ToJsonData(value);
+			this[index] = value2;
+		}
+	}
+
+	public JsonData this[string prop_name]
+	{
+		get
+		{
+			EnsureDictionary();
+			return inst_object[prop_name];
+		}
+		set
+		{
+			EnsureDictionary();
+			KeyValuePair<string, JsonData> keyValuePair = new KeyValuePair<string, JsonData>(prop_name, value);
+			if (inst_object.ContainsKey(prop_name))
+			{
+				for (int i = 0; i < object_list.Count; i++)
+				{
+					if (object_list[i].Key == prop_name)
+					{
+						object_list[i] = keyValuePair;
+						break;
+					}
+				}
+			}
+			else
+			{
+				object_list.Add(keyValuePair);
+			}
+			inst_object[prop_name] = value;
+			json = null;
+		}
+	}
+
+	public JsonData this[int index]
+	{
+		get
+		{
+			EnsureCollection();
+			if (type == JsonType.Array)
+			{
+				return inst_array[index];
+			}
+			return object_list[index].Value;
+		}
+		set
+		{
+			EnsureCollection();
+			if (type == JsonType.Array)
+			{
+				inst_array[index] = value;
+			}
+			else
+			{
+				KeyValuePair<string, JsonData> keyValuePair = object_list[index];
+				KeyValuePair<string, JsonData> value2 = new KeyValuePair<string, JsonData>(keyValuePair.Key, value);
+				object_list[index] = value2;
+				inst_object[keyValuePair.Key] = value;
+			}
+			json = null;
+		}
+	}
+
+	public JsonData()
+	{
+	}
+
+	public JsonData(bool boolean)
+	{
+		type = JsonType.Boolean;
+		inst_boolean = boolean;
+	}
+
+	public JsonData(double number)
+	{
+		type = JsonType.Double;
+		inst_double = number;
+	}
+
+	public JsonData(int number)
+	{
+		type = JsonType.Int;
+		inst_int = number;
+	}
+
+	public JsonData(long number)
+	{
+		type = JsonType.Long;
+		inst_long = number;
+	}
+
+	public JsonData(object obj)
+	{
+		if (obj is bool)
+		{
+			type = JsonType.Boolean;
+			inst_boolean = (bool)obj;
+			return;
+		}
+		if (obj is double)
+		{
+			type = JsonType.Double;
+			inst_double = (double)obj;
+			return;
+		}
+		if (obj is int)
+		{
+			type = JsonType.Int;
+			inst_int = (int)obj;
+			return;
+		}
+		if (obj is long)
+		{
+			type = JsonType.Long;
+			inst_long = (long)obj;
+			return;
+		}
+		if (obj is string)
+		{
+			type = JsonType.String;
+			inst_string = (string)obj;
+			return;
+		}
+		throw new ArgumentException("Unable to wrap the given object with JsonData");
+	}
+
+	public JsonData(string str)
+	{
+		type = JsonType.String;
+		inst_string = str;
+	}
+
+	public static implicit operator JsonData(bool data)
+	{
+		return new JsonData(data);
+	}
+
+	public static implicit operator JsonData(double data)
+	{
+		return new JsonData(data);
+	}
+
+	public static implicit operator JsonData(int data)
+	{
+		return new JsonData(data);
+	}
+
+	public static implicit operator JsonData(long data)
+	{
+		return new JsonData(data);
+	}
+
+	public static implicit operator JsonData(string data)
+	{
+		return new JsonData(data);
+	}
+
+	public static explicit operator bool(JsonData data)
+	{
+		if (data.type != JsonType.Boolean)
+		{
+			throw new InvalidCastException("Instance of JsonData doesn't hold a double");
+		}
+		return data.inst_boolean;
+	}
+
+	public static explicit operator double(JsonData data)
+	{
+		if (data.type != JsonType.Double)
+		{
+			throw new InvalidCastException("Instance of JsonData doesn't hold a double");
+		}
+		return data.inst_double;
+	}
+
+	public static explicit operator int(JsonData data)
+	{
+		if (data.type != JsonType.Int)
+		{
+			throw new InvalidCastException("Instance of JsonData doesn't hold an int");
+		}
+		return data.inst_int;
+	}
+
+	public static explicit operator long(JsonData data)
+	{
+		if (data.type != JsonType.Long)
+		{
+			throw new InvalidCastException("Instance of JsonData doesn't hold an int");
+		}
+		return data.inst_long;
+	}
+
+	public static explicit operator string(JsonData data)
+	{
+		if (data.type != JsonType.String)
+		{
+			throw new InvalidCastException("Instance of JsonData doesn't hold a string");
+		}
+		return data.inst_string;
+	}
+
+	void ICollection.CopyTo(Array array, int index)
+	{
+		EnsureCollection().CopyTo(array, index);
+	}
+
+	void IDictionary.Add(object key, object value)
+	{
+		JsonData value2 = ToJsonData(value);
+		EnsureDictionary().Add(key, value2);
+		KeyValuePair<string, JsonData> item = new KeyValuePair<string, JsonData>((string)key, value2);
+		object_list.Add(item);
+		json = null;
+	}
+
+	void IDictionary.Clear()
+	{
+		EnsureDictionary().Clear();
+		object_list.Clear();
+		json = null;
+	}
+
+	bool IDictionary.Contains(object key)
+	{
+		return EnsureDictionary().Contains(key);
+	}
+
+	IDictionaryEnumerator IDictionary.GetEnumerator()
+	{
+		return ((IOrderedDictionary)this).GetEnumerator();
+	}
+
+	void IDictionary.Remove(object key)
+	{
+		EnsureDictionary().Remove(key);
+		for (int i = 0; i < object_list.Count; i++)
+		{
+			if (object_list[i].Key == (string)key)
+			{
+				object_list.RemoveAt(i);
+				break;
+			}
+		}
+		json = null;
+	}
+
+	IEnumerator IEnumerable.GetEnumerator()
+	{
+		return EnsureCollection().GetEnumerator();
+	}
+
+	bool IJsonWrapper.GetBoolean()
+	{
+		if (type != JsonType.Boolean)
+		{
+			throw new InvalidOperationException("JsonData instance doesn't hold a boolean");
+		}
+		return inst_boolean;
+	}
+
+	double IJsonWrapper.GetDouble()
+	{
+		if (type != JsonType.Double)
+		{
+			throw new InvalidOperationException("JsonData instance doesn't hold a double");
+		}
+		return inst_double;
+	}
+
+	int IJsonWrapper.GetInt()
+	{
+		if (type != JsonType.Int)
+		{
+			throw new InvalidOperationException("JsonData instance doesn't hold an int");
+		}
+		return inst_int;
+	}
+
+	long IJsonWrapper.GetLong()
+	{
+		if (type != JsonType.Long)
+		{
+			throw new InvalidOperationException("JsonData instance doesn't hold a long");
+		}
+		return inst_long;
+	}
+
+	string IJsonWrapper.GetString()
+	{
+		if (type != JsonType.String)
+		{
+			throw new InvalidOperationException("JsonData instance doesn't hold a string");
+		}
+		return inst_string;
+	}
+
+	void IJsonWrapper.SetBoolean(bool val)
+	{
+		type = JsonType.Boolean;
+		inst_boolean = val;
+		json = null;
+	}
+
+	void IJsonWrapper.SetDouble(double val)
+	{
+		type = JsonType.Double;
+		inst_double = val;
+		json = null;
+	}
+
+	void IJsonWrapper.SetInt(int val)
+	{
+		type = JsonType.Int;
+		inst_int = val;
+		json = null;
+	}
+
+	void IJsonWrapper.SetLong(long val)
+	{
+		type = JsonType.Long;
+		inst_long = val;
+		json = null;
+	}
+
+	void IJsonWrapper.SetString(string val)
+	{
+		type = JsonType.String;
+		inst_string = val;
+		json = null;
+	}
+
+	string IJsonWrapper.ToJson()
+	{
+		return ToJson();
+	}
+
+	void IJsonWrapper.ToJson(JsonWriter writer)
+	{
+		ToJson(writer);
+	}
+
+	int IList.Add(object value)
+	{
+		return Add(value);
+	}
+
+	void IList.Clear()
+	{
+		EnsureList().Clear();
+		json = null;
+	}
+
+	bool IList.Contains(object value)
+	{
+		return EnsureList().Contains(value);
+	}
+
+	int IList.IndexOf(object value)
+	{
+		return EnsureList().IndexOf(value);
+	}
+
+	void IList.Insert(int index, object value)
+	{
+		EnsureList().Insert(index, value);
+		json = null;
+	}
+
+	void IList.Remove(object value)
+	{
+		EnsureList().Remove(value);
+		json = null;
+	}
+
+	void IList.RemoveAt(int index)
+	{
+		EnsureList().RemoveAt(index);
+		json = null;
+	}
+
+	IDictionaryEnumerator IOrderedDictionary.GetEnumerator()
+	{
+		EnsureDictionary();
+		return new OrderedDictionaryEnumerator(object_list.GetEnumerator());
+	}
+
+	void IOrderedDictionary.Insert(int idx, object key, object value)
+	{
+		string text = (string)key;
+		JsonData value2 = (this[text] = ToJsonData(value));
+		KeyValuePair<string, JsonData> item = new KeyValuePair<string, JsonData>(text, value2);
+		object_list.Insert(idx, item);
+	}
+
+	void IOrderedDictionary.RemoveAt(int idx)
+	{
+		EnsureDictionary();
+		inst_object.Remove(object_list[idx].Key);
+		object_list.RemoveAt(idx);
+	}
+
+	private ICollection EnsureCollection()
+	{
+		if (type == JsonType.Array)
+		{
+			return (ICollection)inst_array;
+		}
+		if (type == JsonType.Object)
+		{
+			return (ICollection)inst_object;
+		}
+		throw new InvalidOperationException("The JsonData instance has to be initialized first");
+	}
+
+	private IDictionary EnsureDictionary()
+	{
+		if (type == JsonType.Object)
+		{
+			return (IDictionary)inst_object;
+		}
+		if (type != JsonType.None)
+		{
+			throw new InvalidOperationException("Instance of JsonData is not a dictionary");
+		}
+		type = JsonType.Object;
+		inst_object = new Dictionary<string, JsonData>();
+		object_list = new List<KeyValuePair<string, JsonData>>();
+		return (IDictionary)inst_object;
+	}
+
+	private IList EnsureList()
+	{
+		if (type == JsonType.Array)
+		{
+			return (IList)inst_array;
+		}
+		if (type != JsonType.None)
+		{
+			throw new InvalidOperationException("Instance of JsonData is not a list");
+		}
+		type = JsonType.Array;
+		inst_array = new List<JsonData>();
+		return (IList)inst_array;
+	}
+
+	private JsonData ToJsonData(object obj)
+	{
+		if (obj == null)
+		{
+			return null;
+		}
+		if (obj is JsonData)
+		{
+			return (JsonData)obj;
+		}
+		return new JsonData(obj);
+	}
+
+	private static void WriteJson(IJsonWrapper obj, JsonWriter writer)
+	{
+		if (obj == null)
+		{
+			writer.Write(null);
+		}
+		else if (obj.IsString)
+		{
+			writer.Write(obj.GetString());
+		}
+		else if (obj.IsBoolean)
+		{
+			writer.Write(obj.GetBoolean());
+		}
+		else if (obj.IsDouble)
+		{
+			writer.Write(obj.GetDouble());
+		}
+		else if (obj.IsInt)
+		{
+			writer.Write(obj.GetInt());
+		}
+		else if (obj.IsLong)
+		{
+			writer.Write(obj.GetLong());
+		}
+		else if (obj.IsArray)
+		{
+			writer.WriteArrayStart();
+			foreach (JsonData item in (IEnumerable)obj)
+			{
+				WriteJson(item, writer);
+			}
+			writer.WriteArrayEnd();
+		}
+		else
+		{
+			if (!obj.IsObject)
+			{
+				return;
+			}
+			writer.WriteObjectStart();
+			foreach (DictionaryEntry item2 in (IDictionary)obj)
+			{
+				writer.WritePropertyName((string)item2.Key);
+				WriteJson((JsonData)item2.Value, writer);
+			}
+			writer.WriteObjectEnd();
+		}
+	}
+
+	public int Add(object value)
+	{
+		JsonData value2 = ToJsonData(value);
+		json = null;
+		return EnsureList().Add(value2);
+	}
+
+	public void Clear()
+	{
+		if (IsObject)
+		{
+			((IDictionary)this).Clear();
+		}
+		else if (IsArray)
+		{
+			((IList)this).Clear();
+		}
+	}
+
+	public bool Equals(JsonData x)
+	{
+		if (x == null)
+		{
+			return false;
+		}
+		if (x.type != type)
+		{
+			return false;
+		}
+		return type switch
+		{
+			JsonType.None => true, 
+			JsonType.Object => inst_object.Equals(x.inst_object), 
+			JsonType.Array => inst_array.Equals(x.inst_array), 
+			JsonType.String => inst_string.Equals(x.inst_string), 
+			JsonType.Int => inst_int.Equals(x.inst_int), 
+			JsonType.Long => inst_long.Equals(x.inst_long), 
+			JsonType.Double => inst_double.Equals(x.inst_double), 
+			JsonType.Boolean => inst_boolean.Equals(x.inst_boolean), 
+			_ => false, 
+		};
+	}
+
+	public JsonType GetJsonType()
+	{
+		return type;
+	}
+
+	public void SetJsonType(JsonType type)
+	{
+		if (this.type != type)
+		{
+			switch (type)
+			{
+			case JsonType.Object:
+				inst_object = new Dictionary<string, JsonData>();
+				object_list = new List<KeyValuePair<string, JsonData>>();
+				break;
+			case JsonType.Array:
+				inst_array = new List<JsonData>();
+				break;
+			case JsonType.String:
+				inst_string = null;
+				break;
+			case JsonType.Int:
+				inst_int = 0;
+				break;
+			case JsonType.Long:
+				inst_long = 0L;
+				break;
+			case JsonType.Double:
+				inst_double = 0.0;
+				break;
+			case JsonType.Boolean:
+				inst_boolean = false;
+				break;
+			}
+			this.type = type;
+		}
+	}
+
+	public string ToJson()
+	{
+		if (json != null)
+		{
+			return json;
+		}
+		StringWriter stringWriter = new StringWriter();
+		JsonWriter jsonWriter = new JsonWriter(stringWriter);
+		jsonWriter.Validate = false;
+		WriteJson(this, jsonWriter);
+		json = stringWriter.ToString();
+		return json;
+	}
+
+	public void ToJson(JsonWriter writer)
+	{
+		bool validate = writer.Validate;
+		writer.Validate = false;
+		WriteJson(this, writer);
+		writer.Validate = validate;
+	}
+
+	public override string ToString()
+	{
+		return type switch
+		{
+			JsonType.Array => "JsonData array", 
+			JsonType.Boolean => inst_boolean.ToString(), 
+			JsonType.Double => inst_double.ToString(), 
+			JsonType.Int => inst_int.ToString(), 
+			JsonType.Long => inst_long.ToString(), 
+			JsonType.Object => "JsonData object", 
+			JsonType.String => inst_string, 
+			_ => "Uninitialized JsonData", 
+		};
+	}
+
+	public int ToInt()
+	{
+		switch (type)
+		{
+		case JsonType.Int:
+			return inst_int;
+		case JsonType.Double:
+			return Convert.ToInt32(inst_double);
+		case JsonType.Long:
+			return Convert.ToInt32(inst_long);
+		case JsonType.String:
+			return Convert.ToInt32(inst_string);
+		case JsonType.Boolean:
+			return Convert.ToInt32(inst_boolean);
+		default:
+			Debug.LogError("JsonData ToInt error");
+			return 0;
+		}
+	}
+
+	public long ToLong()
+	{
+		switch (type)
+		{
+		case JsonType.Int:
+			return Convert.ToInt64(inst_int);
+		case JsonType.Double:
+			return Convert.ToInt64(inst_double);
+		case JsonType.Long:
+			return inst_long;
+		case JsonType.String:
+			return Convert.ToInt64(inst_string);
+		case JsonType.Boolean:
+			return Convert.ToInt64(inst_boolean);
+		default:
+			Debug.LogError("JsonData ToLong error");
+			return 0L;
+		}
+	}
+
+	public double ToDouble()
+	{
+		switch (type)
+		{
+		case JsonType.Int:
+			return Convert.ToDouble(inst_int);
+		case JsonType.Double:
+			return inst_double;
+		case JsonType.Long:
+			return Convert.ToDouble(inst_long);
+		case JsonType.String:
+			return Convert.ToDouble(inst_string);
+		case JsonType.Boolean:
+			return Convert.ToDouble(inst_boolean);
+		default:
+			Debug.LogError("JsonData ToDouble error");
+			return 0.0;
+		}
+	}
+
+	public bool ToBoolean()
+	{
+		switch (type)
+		{
+		case JsonType.Int:
+			return Convert.ToBoolean(inst_int);
+		case JsonType.Double:
+			return Convert.ToBoolean(inst_double);
+		case JsonType.Long:
+			return Convert.ToBoolean(inst_long);
+		case JsonType.String:
+			return Convert.ToBoolean(inst_string);
+		case JsonType.Boolean:
+			return inst_boolean;
+		default:
+			Debug.LogError("JsonData ToBoolean error");
+			return false;
+		}
+	}
+}

SVSim.BattleEngine/Engine/LitJson/JsonException.cs

@@ -0,0 +1,40 @@
+using System;
+
+namespace LitJson;
+
+public class JsonException : Exception
+{
+	public JsonException()
+	{
+	}
+
+	internal JsonException(ParserToken token)
+		: base($"Invalid token '{token}' in input string")
+	{
+	}
+
+	internal JsonException(ParserToken token, Exception inner_exception)
+		: base($"Invalid token '{token}' in input string", inner_exception)
+	{
+	}
+
+	internal JsonException(int c)
+		: base($"Invalid character '{(char)c}' in input string")
+	{
+	}
+
+	internal JsonException(int c, Exception inner_exception)
+		: base($"Invalid character '{(char)c}' in input string", inner_exception)
+	{
+	}
+
+	public JsonException(string message)
+		: base(message)
+	{
+	}
+
+	public JsonException(string message, Exception inner_exception)
+		: base(message, inner_exception)
+	{
+	}
+}

SVSim.BattleEngine/Engine/LitJson/JsonMapper.cs

@@ -0,0 +1,748 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Reflection;
+
+namespace LitJson;
+
+public class JsonMapper
+{
+	private static int max_nesting_depth;
+
+	private static IFormatProvider datetime_format;
+
+	private static IDictionary<Type, ExporterFunc> base_exporters_table;
+
+	private static IDictionary<Type, ExporterFunc> custom_exporters_table;
+
+	private static IDictionary<Type, IDictionary<Type, ImporterFunc>> base_importers_table;
+
+	private static IDictionary<Type, IDictionary<Type, ImporterFunc>> custom_importers_table;
+
+	private static IDictionary<Type, ArrayMetadata> array_metadata;
+
+	private static readonly object array_metadata_lock;
+
+	private static IDictionary<Type, IDictionary<Type, MethodInfo>> conv_ops;
+
+	private static readonly object conv_ops_lock;
+
+	private static IDictionary<Type, ObjectMetadata> object_metadata;
+
+	private static readonly object object_metadata_lock;
+
+	private static IDictionary<Type, IList<PropertyMetadata>> type_properties;
+
+	private static readonly object type_properties_lock;
+
+	private static JsonWriter static_writer;
+
+	private static readonly object static_writer_lock;
+
+	static JsonMapper()
+	{
+		array_metadata_lock = new object();
+		conv_ops_lock = new object();
+		object_metadata_lock = new object();
+		type_properties_lock = new object();
+		static_writer_lock = new object();
+		max_nesting_depth = 100;
+		array_metadata = new Dictionary<Type, ArrayMetadata>();
+		conv_ops = new Dictionary<Type, IDictionary<Type, MethodInfo>>();
+		object_metadata = new Dictionary<Type, ObjectMetadata>();
+		type_properties = new Dictionary<Type, IList<PropertyMetadata>>();
+		static_writer = new JsonWriter();
+		datetime_format = DateTimeFormatInfo.InvariantInfo;
+		base_exporters_table = new Dictionary<Type, ExporterFunc>();
+		custom_exporters_table = new Dictionary<Type, ExporterFunc>();
+		base_importers_table = new Dictionary<Type, IDictionary<Type, ImporterFunc>>();
+		custom_importers_table = new Dictionary<Type, IDictionary<Type, ImporterFunc>>();
+		RegisterBaseExporters();
+		RegisterBaseImporters();
+	}
+
+	private static bool HasInterface(Type type, string name)
+	{
+		Type[] interfaces = type.GetInterfaces();
+		for (int i = 0; i < interfaces.Length; i++)
+		{
+			if (interfaces[i].FullName.Equals(name, StringComparison.OrdinalIgnoreCase))
+			{
+				return true;
+			}
+		}
+		return false;
+	}
+
+	public static PropertyInfo[] GetPublicInstanceProperties(Type type)
+	{
+		return type.GetProperties();
+	}
+
+	private static void AddArrayMetadata(Type type)
+	{
+		if (array_metadata.ContainsKey(type))
+		{
+			return;
+		}
+		ArrayMetadata value = new ArrayMetadata
+		{
+			IsArray = type.IsArray
+		};
+		if (HasInterface(type, "System.Collections.IList"))
+		{
+			value.IsList = true;
+		}
+		PropertyInfo[] publicInstanceProperties = GetPublicInstanceProperties(type);
+		foreach (PropertyInfo propertyInfo in publicInstanceProperties)
+		{
+			if (!(propertyInfo.Name != "Item"))
+			{
+				ParameterInfo[] indexParameters = propertyInfo.GetIndexParameters();
+				if (indexParameters.Length == 1 && indexParameters[0].ParameterType == typeof(int))
+				{
+					value.ElementType = propertyInfo.PropertyType;
+				}
+			}
+		}
+		lock (array_metadata_lock)
+		{
+			try
+			{
+				array_metadata.Add(type, value);
+			}
+			catch (ArgumentException)
+			{
+			}
+		}
+	}
+
+	private static void AddObjectMetadata(Type type)
+	{
+		if (object_metadata.ContainsKey(type))
+		{
+			return;
+		}
+		ObjectMetadata value = default(ObjectMetadata);
+		if (HasInterface(type, "System.Collections.IDictionary"))
+		{
+			value.IsDictionary = true;
+		}
+		value.Properties = new Dictionary<string, PropertyMetadata>(StringComparer.OrdinalIgnoreCase);
+		PropertyInfo[] publicInstanceProperties = GetPublicInstanceProperties(type);
+		foreach (PropertyInfo propertyInfo in publicInstanceProperties)
+		{
+			if (propertyInfo.Name == "Item")
+			{
+				ParameterInfo[] indexParameters = propertyInfo.GetIndexParameters();
+				if (indexParameters.Length == 1 && indexParameters[0].ParameterType == typeof(string))
+				{
+					value.ElementType = propertyInfo.PropertyType;
+				}
+			}
+			else
+			{
+				PropertyMetadata value2 = new PropertyMetadata
+				{
+					Info = propertyInfo,
+					Type = propertyInfo.PropertyType
+				};
+				value.Properties.Add(propertyInfo.Name, value2);
+			}
+		}
+		FieldInfo[] fields = type.GetFields();
+		foreach (FieldInfo fieldInfo in fields)
+		{
+			PropertyMetadata value3 = new PropertyMetadata
+			{
+				Info = fieldInfo,
+				IsField = true,
+				Type = fieldInfo.FieldType
+			};
+			if (!value.Properties.ContainsKey(fieldInfo.Name))
+			{
+				value.Properties.Add(fieldInfo.Name, value3);
+			}
+		}
+		lock (object_metadata_lock)
+		{
+			try
+			{
+				object_metadata.Add(type, value);
+			}
+			catch (ArgumentException)
+			{
+			}
+		}
+	}
+
+	private static void AddTypeProperties(Type type)
+	{
+		if (type_properties.ContainsKey(type))
+		{
+			return;
+		}
+		IList<PropertyMetadata> list = new List<PropertyMetadata>();
+		PropertyInfo[] publicInstanceProperties = GetPublicInstanceProperties(type);
+		foreach (PropertyInfo propertyInfo in publicInstanceProperties)
+		{
+			if (!(propertyInfo.Name == "Item"))
+			{
+				list.Add(new PropertyMetadata
+				{
+					Info = propertyInfo,
+					IsField = false
+				});
+			}
+		}
+		FieldInfo[] fields = type.GetFields();
+		foreach (FieldInfo info in fields)
+		{
+			list.Add(new PropertyMetadata
+			{
+				Info = info,
+				IsField = true
+			});
+		}
+		lock (type_properties_lock)
+		{
+			try
+			{
+				type_properties.Add(type, list);
+			}
+			catch (ArgumentException)
+			{
+			}
+		}
+	}
+
+	private static MethodInfo GetConvOp(Type t1, Type t2)
+	{
+		lock (conv_ops_lock)
+		{
+			if (!conv_ops.ContainsKey(t1))
+			{
+				conv_ops.Add(t1, new Dictionary<Type, MethodInfo>());
+			}
+		}
+		if (conv_ops[t1].ContainsKey(t2))
+		{
+			return conv_ops[t1][t2];
+		}
+		MethodInfo method = t1.GetMethod("op_Implicit", new Type[1] { t2 });
+		lock (conv_ops_lock)
+		{
+			try
+			{
+				conv_ops[t1].Add(t2, method);
+				return method;
+			}
+			catch (ArgumentException)
+			{
+				return conv_ops[t1][t2];
+			}
+		}
+	}
+
+	private static object ReadValue(Type inst_type, JsonReader reader)
+	{
+		reader.Read();
+		if (reader.Token == JsonToken.ArrayEnd)
+		{
+			return null;
+		}
+		if (reader.Token == JsonToken.Null)
+		{
+			if (!inst_type.IsClass)
+			{
+				throw new JsonException($"Can't assign null to an instance of type {inst_type}");
+			}
+			return null;
+		}
+		if (reader.Token == JsonToken.Double || reader.Token == JsonToken.Int || reader.Token == JsonToken.Long || reader.Token == JsonToken.String || reader.Token == JsonToken.Boolean)
+		{
+			Type type = reader.Value.GetType();
+			if (inst_type.IsAssignableFrom(type))
+			{
+				return reader.Value;
+			}
+			if (custom_importers_table.ContainsKey(type) && custom_importers_table[type].ContainsKey(inst_type))
+			{
+				return custom_importers_table[type][inst_type](reader.Value);
+			}
+			if (base_importers_table.ContainsKey(type) && base_importers_table[type].ContainsKey(inst_type))
+			{
+				return base_importers_table[type][inst_type](reader.Value);
+			}
+			if (inst_type.IsEnum)
+			{
+				return Enum.ToObject(inst_type, reader.Value);
+			}
+			MethodInfo convOp = GetConvOp(inst_type, type);
+			if (convOp != null)
+			{
+				return convOp.Invoke(null, new object[1] { reader.Value });
+			}
+			throw new JsonException($"Can't assign value '{reader.Value}' (type {type}) to type {inst_type}");
+		}
+		object obj = null;
+		if (reader.Token == JsonToken.ArrayStart)
+		{
+			if (inst_type.FullName == "System.Object")
+			{
+				inst_type = typeof(object[]);
+			}
+			AddArrayMetadata(inst_type);
+			ArrayMetadata arrayMetadata = array_metadata[inst_type];
+			if (!arrayMetadata.IsArray && !arrayMetadata.IsList)
+			{
+				throw new JsonException($"Type {inst_type} can't act as an array");
+			}
+			IList list;
+			Type elementType;
+			if (!arrayMetadata.IsArray)
+			{
+				list = (IList)Activator.CreateInstance(inst_type);
+				elementType = arrayMetadata.ElementType;
+			}
+			else
+			{
+				list = new List<object>();
+				elementType = inst_type.GetElementType();
+			}
+			while (true)
+			{
+				object obj2 = ReadValue(elementType, reader);
+				if (obj2 == null && reader.Token == JsonToken.ArrayEnd)
+				{
+					break;
+				}
+				list.Add(obj2);
+			}
+			if (arrayMetadata.IsArray)
+			{
+				int count = list.Count;
+				obj = Array.CreateInstance(elementType, count);
+				for (int i = 0; i < count; i++)
+				{
+					((Array)obj).SetValue(list[i], i);
+				}
+			}
+			else
+			{
+				obj = list;
+			}
+		}
+		else if (reader.Token == JsonToken.ObjectStart)
+		{
+			if (inst_type == typeof(object))
+			{
+				inst_type = typeof(Dictionary<string, object>);
+			}
+			AddObjectMetadata(inst_type);
+			ObjectMetadata objectMetadata = object_metadata[inst_type];
+			obj = Activator.CreateInstance(inst_type);
+			while (true)
+			{
+				reader.Read();
+				if (reader.Token == JsonToken.ObjectEnd)
+				{
+					break;
+				}
+				string text = (string)reader.Value;
+				if (objectMetadata.Properties.ContainsKey(text))
+				{
+					PropertyMetadata propertyMetadata = objectMetadata.Properties[text];
+					if (propertyMetadata.IsField)
+					{
+						((FieldInfo)propertyMetadata.Info).SetValue(obj, ReadValue(propertyMetadata.Type, reader));
+						continue;
+					}
+					PropertyInfo propertyInfo = (PropertyInfo)propertyMetadata.Info;
+					if (propertyInfo.CanWrite)
+					{
+						propertyInfo.SetValue(obj, ReadValue(propertyMetadata.Type, reader), null);
+					}
+					else
+					{
+						ReadValue(propertyMetadata.Type, reader);
+					}
+				}
+				else if (!objectMetadata.IsDictionary)
+				{
+					if (!reader.SkipNonMembers)
+					{
+						throw new JsonException($"The type {inst_type} doesn't have the property '{text}'");
+					}
+					ReadSkip(reader);
+				}
+				else
+				{
+					((IDictionary)obj).Add(text, ReadValue(objectMetadata.ElementType, reader));
+				}
+			}
+		}
+		return obj;
+	}
+
+	private static IJsonWrapper ReadValue(WrapperFactory factory, JsonReader reader)
+	{
+		reader.Read();
+		if (reader.Token == JsonToken.ArrayEnd || reader.Token == JsonToken.Null)
+		{
+			return null;
+		}
+		IJsonWrapper jsonWrapper = factory();
+		if (reader.Token == JsonToken.String)
+		{
+			jsonWrapper.SetString((string)reader.Value);
+			return jsonWrapper;
+		}
+		if (reader.Token == JsonToken.Double)
+		{
+			jsonWrapper.SetDouble((double)reader.Value);
+			return jsonWrapper;
+		}
+		if (reader.Token == JsonToken.Int)
+		{
+			jsonWrapper.SetInt((int)reader.Value);
+			return jsonWrapper;
+		}
+		if (reader.Token == JsonToken.Long)
+		{
+			jsonWrapper.SetLong((long)reader.Value);
+			return jsonWrapper;
+		}
+		if (reader.Token == JsonToken.Boolean)
+		{
+			jsonWrapper.SetBoolean((bool)reader.Value);
+			return jsonWrapper;
+		}
+		if (reader.Token == JsonToken.ArrayStart)
+		{
+			jsonWrapper.SetJsonType(JsonType.Array);
+			while (true)
+			{
+				IJsonWrapper jsonWrapper2 = ReadValue(factory, reader);
+				if (jsonWrapper2 == null && reader.Token == JsonToken.ArrayEnd)
+				{
+					break;
+				}
+				jsonWrapper.Add(jsonWrapper2);
+			}
+		}
+		else if (reader.Token == JsonToken.ObjectStart)
+		{
+			jsonWrapper.SetJsonType(JsonType.Object);
+			while (true)
+			{
+				reader.Read();
+				if (reader.Token == JsonToken.ObjectEnd)
+				{
+					break;
+				}
+				string key = (string)reader.Value;
+				jsonWrapper[key] = ReadValue(factory, reader);
+			}
+		}
+		return jsonWrapper;
+	}
+
+	private static void ReadSkip(JsonReader reader)
+	{
+		ToWrapper(() => new JsonMockWrapper(), reader);
+	}
+
+	private static void RegisterBaseExporters()
+	{
+		base_exporters_table[typeof(byte)] = delegate(object obj, JsonWriter writer)
+		{
+			writer.Write(Convert.ToInt32((byte)obj));
+		};
+		base_exporters_table[typeof(char)] = delegate(object obj, JsonWriter writer)
+		{
+			writer.Write(Convert.ToString((char)obj));
+		};
+		base_exporters_table[typeof(DateTime)] = delegate(object obj, JsonWriter writer)
+		{
+			writer.Write(Convert.ToString((DateTime)obj, datetime_format));
+		};
+		base_exporters_table[typeof(decimal)] = delegate(object obj, JsonWriter writer)
+		{
+			writer.Write((decimal)obj);
+		};
+		base_exporters_table[typeof(sbyte)] = delegate(object obj, JsonWriter writer)
+		{
+			writer.Write(Convert.ToInt32((sbyte)obj));
+		};
+		base_exporters_table[typeof(short)] = delegate(object obj, JsonWriter writer)
+		{
+			writer.Write(Convert.ToInt32((short)obj));
+		};
+		base_exporters_table[typeof(ushort)] = delegate(object obj, JsonWriter writer)
+		{
+			writer.Write(Convert.ToInt32((ushort)obj));
+		};
+		base_exporters_table[typeof(uint)] = delegate(object obj, JsonWriter writer)
+		{
+			writer.Write(Convert.ToUInt64((uint)obj));
+		};
+		base_exporters_table[typeof(ulong)] = delegate(object obj, JsonWriter writer)
+		{
+			writer.Write((ulong)obj);
+		};
+	}
+
+	private static void RegisterBaseImporters()
+	{
+		ImporterFunc importer = (object input) => Convert.ToByte((int)input);
+		RegisterImporter(base_importers_table, typeof(int), typeof(byte), importer);
+		importer = (object input) => Convert.ToUInt64((int)input);
+		RegisterImporter(base_importers_table, typeof(int), typeof(ulong), importer);
+		importer = (object input) => Convert.ToSByte((int)input);
+		RegisterImporter(base_importers_table, typeof(int), typeof(sbyte), importer);
+		importer = (object input) => Convert.ToInt16((int)input);
+		RegisterImporter(base_importers_table, typeof(int), typeof(short), importer);
+		importer = (object input) => Convert.ToUInt16((int)input);
+		RegisterImporter(base_importers_table, typeof(int), typeof(ushort), importer);
+		importer = (object input) => Convert.ToUInt32((int)input);
+		RegisterImporter(base_importers_table, typeof(int), typeof(uint), importer);
+		importer = (object input) => Convert.ToSingle((int)input);
+		RegisterImporter(base_importers_table, typeof(int), typeof(float), importer);
+		importer = (object input) => Convert.ToDouble((int)input);
+		RegisterImporter(base_importers_table, typeof(int), typeof(double), importer);
+		importer = (object input) => Convert.ToDecimal((double)input);
+		RegisterImporter(base_importers_table, typeof(double), typeof(decimal), importer);
+		importer = (object input) => Convert.ToUInt32((long)input);
+		RegisterImporter(base_importers_table, typeof(long), typeof(uint), importer);
+		importer = (object input) => Convert.ToChar((string)input);
+		RegisterImporter(base_importers_table, typeof(string), typeof(char), importer);
+		importer = (object input) => Convert.ToDateTime((string)input, datetime_format);
+		RegisterImporter(base_importers_table, typeof(string), typeof(DateTime), importer);
+	}
+
+	private static void RegisterImporter(IDictionary<Type, IDictionary<Type, ImporterFunc>> table, Type json_type, Type value_type, ImporterFunc importer)
+	{
+		if (!table.ContainsKey(json_type))
+		{
+			table.Add(json_type, new Dictionary<Type, ImporterFunc>());
+		}
+		table[json_type][value_type] = importer;
+	}
+
+	private static void WriteValue(object obj, JsonWriter writer, bool writer_is_private, int depth)
+	{
+		if (depth > max_nesting_depth)
+		{
+			throw new JsonException($"Max allowed object depth reached while trying to export from type {obj.GetType()}");
+		}
+		if (obj == null)
+		{
+			writer.Write(null);
+			return;
+		}
+		if (obj is IJsonWrapper)
+		{
+			if (writer_is_private)
+			{
+				writer.TextWriter.Write(((IJsonWrapper)obj).ToJson());
+			}
+			else
+			{
+				((IJsonWrapper)obj).ToJson(writer);
+			}
+			return;
+		}
+		if (obj is string)
+		{
+			writer.Write((string)obj);
+			return;
+		}
+		if (obj is double)
+		{
+			writer.Write((double)obj);
+			return;
+		}
+		if (obj is int)
+		{
+			writer.Write((int)obj);
+			return;
+		}
+		if (obj is bool)
+		{
+			writer.Write((bool)obj);
+			return;
+		}
+		if (obj is long)
+		{
+			writer.Write((long)obj);
+			return;
+		}
+		if (obj is Array)
+		{
+			writer.WriteArrayStart();
+			foreach (object item in (Array)obj)
+			{
+				WriteValue(item, writer, writer_is_private, depth + 1);
+			}
+			writer.WriteArrayEnd();
+			return;
+		}
+		if (obj is IList)
+		{
+			writer.WriteArrayStart();
+			foreach (object item2 in (IList)obj)
+			{
+				WriteValue(item2, writer, writer_is_private, depth + 1);
+			}
+			writer.WriteArrayEnd();
+			return;
+		}
+		if (obj is IDictionary)
+		{
+			writer.WriteObjectStart();
+			foreach (DictionaryEntry item3 in (IDictionary)obj)
+			{
+				writer.WritePropertyName((string)item3.Key);
+				WriteValue(item3.Value, writer, writer_is_private, depth + 1);
+			}
+			writer.WriteObjectEnd();
+			return;
+		}
+		Type type = obj.GetType();
+		if (custom_exporters_table.ContainsKey(type))
+		{
+			custom_exporters_table[type](obj, writer);
+			return;
+		}
+		if (base_exporters_table.ContainsKey(type))
+		{
+			base_exporters_table[type](obj, writer);
+			return;
+		}
+		if (obj is Enum)
+		{
+			Type underlyingType = Enum.GetUnderlyingType(type);
+			if (underlyingType == typeof(long) || underlyingType == typeof(uint) || underlyingType == typeof(ulong))
+			{
+				writer.Write((ulong)obj);
+			}
+			else
+			{
+				writer.Write((int)obj);
+			}
+			return;
+		}
+		AddTypeProperties(type);
+		IList<PropertyMetadata> list = type_properties[type];
+		writer.WriteObjectStart();
+		foreach (PropertyMetadata item4 in list)
+		{
+			if (item4.IsField)
+			{
+				writer.WritePropertyName(item4.Info.Name);
+				WriteValue(((FieldInfo)item4.Info).GetValue(obj), writer, writer_is_private, depth + 1);
+				continue;
+			}
+			PropertyInfo propertyInfo = (PropertyInfo)item4.Info;
+			if (propertyInfo.CanRead)
+			{
+				writer.WritePropertyName(item4.Info.Name);
+				WriteValue(propertyInfo.GetValue(obj, null), writer, writer_is_private, depth + 1);
+			}
+		}
+		writer.WriteObjectEnd();
+	}
+
+	public static string ToJson(object obj)
+	{
+		lock (static_writer_lock)
+		{
+			static_writer.Reset();
+			WriteValue(obj, static_writer, writer_is_private: true, 0);
+			return static_writer.ToString();
+		}
+	}
+
+	public static void ToJson(object obj, JsonWriter writer)
+	{
+		WriteValue(obj, writer, writer_is_private: false, 0);
+	}
+
+	public static JsonData ToObject(JsonReader reader)
+	{
+		return (JsonData)ToWrapper(() => new JsonData(), reader);
+	}
+
+	public static JsonData ToObject(TextReader reader)
+	{
+		JsonReader reader2 = new JsonReader(reader);
+		return (JsonData)ToWrapper(() => new JsonData(), reader2);
+	}
+
+	public static JsonData ToObject(string json)
+	{
+		return (JsonData)ToWrapper(() => new JsonData(), json);
+	}
+
+	public static T ToObject<T>(JsonReader reader)
+	{
+		return (T)ReadValue(typeof(T), reader);
+	}
+
+	public static T ToObject<T>(TextReader reader)
+	{
+		JsonReader reader2 = new JsonReader(reader);
+		return (T)ReadValue(typeof(T), reader2);
+	}
+
+	public static T ToObject<T>(string json)
+	{
+		JsonReader reader = new JsonReader(json);
+		return (T)ReadValue(typeof(T), reader);
+	}
+
+	public static object ToObject(Type toType, string json)
+	{
+		JsonReader reader = new JsonReader(json);
+		return ReadValue(toType, reader);
+	}
+
+	public static IJsonWrapper ToWrapper(WrapperFactory factory, JsonReader reader)
+	{
+		return ReadValue(factory, reader);
+	}
+
+	public static IJsonWrapper ToWrapper(WrapperFactory factory, string json)
+	{
+		JsonReader reader = new JsonReader(json);
+		return ReadValue(factory, reader);
+	}
+
+	public static void RegisterExporter<T>(ExporterFunc<T> exporter)
+	{
+		ExporterFunc value = delegate(object obj, JsonWriter writer)
+		{
+			exporter((T)obj, writer);
+		};
+		custom_exporters_table[typeof(T)] = value;
+	}
+
+	public static void RegisterImporter<TJson, TValue>(ImporterFunc<TJson, TValue> importer)
+	{
+		ImporterFunc importer2 = (object input) => importer((TJson)input);
+		RegisterImporter(custom_importers_table, typeof(TJson), typeof(TValue), importer2);
+	}
+
+	public static void UnregisterExporters()
+	{
+		custom_exporters_table.Clear();
+	}
+
+	public static void UnregisterImporters()
+	{
+		custom_importers_table.Clear();
+	}
+}

SVSim.BattleEngine/Engine/LitJson/JsonMockWrapper.cs

@@ -0,0 +1,210 @@
+using System;
+using System.Collections;
+
+namespace LitJson;
+
+public class JsonMockWrapper : IJsonWrapper, IList, ICollection, IEnumerable, IOrderedDictionary, IDictionary
+{
+	public bool IsArray => false;
+
+	public bool IsBoolean => false;
+
+	public bool IsDouble => false;
+
+	public bool IsInt => false;
+
+	public bool IsLong => false;
+
+	public bool IsObject => false;
+
+	public bool IsString => false;
+
+	bool IList.IsFixedSize => true;
+
+	bool IList.IsReadOnly => true;
+
+	object IList.this[int index]
+	{
+		get
+		{
+			return null;
+		}
+		set
+		{
+		}
+	}
+
+	int ICollection.Count => 0;
+
+	bool ICollection.IsSynchronized => false;
+
+	object ICollection.SyncRoot => null;
+
+	bool IDictionary.IsFixedSize => true;
+
+	bool IDictionary.IsReadOnly => true;
+
+	ICollection IDictionary.Keys => null;
+
+	ICollection IDictionary.Values => null;
+
+	object IDictionary.this[object key]
+	{
+		get
+		{
+			return null;
+		}
+		set
+		{
+		}
+	}
+
+	object IOrderedDictionary.this[int idx]
+	{
+		get
+		{
+			return null;
+		}
+		set
+		{
+		}
+	}
+
+	public bool GetBoolean()
+	{
+		return false;
+	}
+
+	public double GetDouble()
+	{
+		return 0.0;
+	}
+
+	public int GetInt()
+	{
+		return 0;
+	}
+
+	public JsonType GetJsonType()
+	{
+		return JsonType.None;
+	}
+
+	public long GetLong()
+	{
+		return 0L;
+	}
+
+	public string GetString()
+	{
+		return "";
+	}
+
+	public void SetBoolean(bool val)
+	{
+	}
+
+	public void SetDouble(double val)
+	{
+	}
+
+	public void SetInt(int val)
+	{
+	}
+
+	public void SetJsonType(JsonType type)
+	{
+	}
+
+	public void SetLong(long val)
+	{
+	}
+
+	public void SetString(string val)
+	{
+	}
+
+	public string ToJson()
+	{
+		return "";
+	}
+
+	public void ToJson(JsonWriter writer)
+	{
+	}
+
+	int IList.Add(object value)
+	{
+		return 0;
+	}
+
+	void IList.Clear()
+	{
+	}
+
+	bool IList.Contains(object value)
+	{
+		return false;
+	}
+
+	int IList.IndexOf(object value)
+	{
+		return -1;
+	}
+
+	void IList.Insert(int i, object v)
+	{
+	}
+
+	void IList.Remove(object value)
+	{
+	}
+
+	void IList.RemoveAt(int index)
+	{
+	}
+
+	void ICollection.CopyTo(Array array, int index)
+	{
+	}
+
+	IEnumerator IEnumerable.GetEnumerator()
+	{
+		return null;
+	}
+
+	void IDictionary.Add(object k, object v)
+	{
+	}
+
+	void IDictionary.Clear()
+	{
+	}
+
+	bool IDictionary.Contains(object key)
+	{
+		return false;
+	}
+
+	void IDictionary.Remove(object key)
+	{
+	}
+
+	IDictionaryEnumerator IDictionary.GetEnumerator()
+	{
+		return null;
+	}
+
+	IDictionaryEnumerator IOrderedDictionary.GetEnumerator()
+	{
+		return null;
+	}
+
+	void IOrderedDictionary.Insert(int i, object k, object v)
+	{
+	}
+
+	void IOrderedDictionary.RemoveAt(int i)
+	{
+	}
+}

SVSim.BattleEngine/Engine/LitJson/JsonReader.cs

@@ -0,0 +1,366 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+
+namespace LitJson;
+
+public class JsonReader
+{
+	private static IDictionary<int, IDictionary<int, int[]>> parse_table;
+
+	private Stack<int> automaton_stack;
+
+	private int current_input;
+
+	private int current_symbol;
+
+	private bool end_of_json;
+
+	private bool end_of_input;
+
+	private Lexer lexer;
+
+	private bool parser_in_string;
+
+	private bool parser_return;
+
+	private bool read_started;
+
+	private TextReader reader;
+
+	private bool reader_is_owned;
+
+	private bool skip_non_members;
+
+	private object token_value;
+
+	private JsonToken token;
+
+	public bool AllowComments
+	{
+		get
+		{
+			return lexer.AllowComments;
+		}
+		set
+		{
+			lexer.AllowComments = value;
+		}
+	}
+
+	public bool AllowSingleQuotedStrings
+	{
+		get
+		{
+			return lexer.AllowSingleQuotedStrings;
+		}
+		set
+		{
+			lexer.AllowSingleQuotedStrings = value;
+		}
+	}
+
+	public bool SkipNonMembers
+	{
+		get
+		{
+			return skip_non_members;
+		}
+		set
+		{
+			skip_non_members = value;
+		}
+	}
+
+	public bool EndOfInput => end_of_input;
+
+	public bool EndOfJson => end_of_json;
+
+	public JsonToken Token => token;
+
+	public object Value => token_value;
+
+	static JsonReader()
+	{
+		PopulateParseTable();
+	}
+
+	public JsonReader(string json_text)
+		: this(new StringReader(json_text), owned: true)
+	{
+	}
+
+	public JsonReader(TextReader reader)
+		: this(reader, owned: false)
+	{
+	}
+
+	private JsonReader(TextReader reader, bool owned)
+	{
+		if (reader == null)
+		{
+			throw new ArgumentNullException("reader");
+		}
+		parser_in_string = false;
+		parser_return = false;
+		read_started = false;
+		automaton_stack = new Stack<int>();
+		automaton_stack.Push(65553);
+		automaton_stack.Push(65543);
+		lexer = new Lexer(reader);
+		end_of_input = false;
+		end_of_json = false;
+		skip_non_members = true;
+		this.reader = reader;
+		reader_is_owned = owned;
+	}
+
+	private static void PopulateParseTable()
+	{
+		parse_table = new Dictionary<int, IDictionary<int, int[]>>();
+		TableAddRow(ParserToken.Array);
+		TableAddCol(ParserToken.Array, 91, 91, 65549);
+		TableAddRow(ParserToken.ArrayPrime);
+		TableAddCol(ParserToken.ArrayPrime, 34, 65550, 65551, 93);
+		TableAddCol(ParserToken.ArrayPrime, 91, 65550, 65551, 93);
+		TableAddCol(ParserToken.ArrayPrime, 93, 93);
+		TableAddCol(ParserToken.ArrayPrime, 123, 65550, 65551, 93);
+		TableAddCol(ParserToken.ArrayPrime, 65537, 65550, 65551, 93);
+		TableAddCol(ParserToken.ArrayPrime, 65538, 65550, 65551, 93);
+		TableAddCol(ParserToken.ArrayPrime, 65539, 65550, 65551, 93);
+		TableAddCol(ParserToken.ArrayPrime, 65540, 65550, 65551, 93);
+		TableAddRow(ParserToken.Object);
+		TableAddCol(ParserToken.Object, 123, 123, 65545);
+		TableAddRow(ParserToken.ObjectPrime);
+		TableAddCol(ParserToken.ObjectPrime, 34, 65546, 65547, 125);
+		TableAddCol(ParserToken.ObjectPrime, 125, 125);
+		TableAddRow(ParserToken.Pair);
+		TableAddCol(ParserToken.Pair, 34, 65552, 58, 65550);
+		TableAddRow(ParserToken.PairRest);
+		TableAddCol(ParserToken.PairRest, 44, 44, 65546, 65547);
+		TableAddCol(ParserToken.PairRest, 125, 65554);
+		TableAddRow(ParserToken.String);
+		TableAddCol(ParserToken.String, 34, 34, 65541, 34);
+		TableAddRow(ParserToken.Text);
+		TableAddCol(ParserToken.Text, 91, 65548);
+		TableAddCol(ParserToken.Text, 123, 65544);
+		TableAddRow(ParserToken.Value);
+		TableAddCol(ParserToken.Value, 34, 65552);
+		TableAddCol(ParserToken.Value, 91, 65548);
+		TableAddCol(ParserToken.Value, 123, 65544);
+		TableAddCol(ParserToken.Value, 65537, 65537);
+		TableAddCol(ParserToken.Value, 65538, 65538);
+		TableAddCol(ParserToken.Value, 65539, 65539);
+		TableAddCol(ParserToken.Value, 65540, 65540);
+		TableAddRow(ParserToken.ValueRest);
+		TableAddCol(ParserToken.ValueRest, 44, 44, 65550, 65551);
+		TableAddCol(ParserToken.ValueRest, 93, 65554);
+	}
+
+	private static void TableAddCol(ParserToken row, int col, params int[] symbols)
+	{
+		parse_table[(int)row].Add(col, symbols);
+	}
+
+	private static void TableAddRow(ParserToken rule)
+	{
+		parse_table.Add((int)rule, new Dictionary<int, int[]>());
+	}
+
+	private void ProcessNumber(string number)
+	{
+		int result2;
+		long result3;
+		if ((number.IndexOf('.') != -1 || number.IndexOf('e') != -1 || number.IndexOf('E') != -1) && double.TryParse(number, out var result))
+		{
+			token = JsonToken.Double;
+			token_value = result;
+		}
+		else if (int.TryParse(number, out result2))
+		{
+			token = JsonToken.Int;
+			token_value = result2;
+		}
+		else if (long.TryParse(number, out result3))
+		{
+			token = JsonToken.Long;
+			token_value = result3;
+		}
+		else
+		{
+			token = JsonToken.Int;
+			token_value = 0;
+		}
+	}
+
+	private void ProcessSymbol()
+	{
+		if (current_symbol == 91)
+		{
+			token = JsonToken.ArrayStart;
+			parser_return = true;
+		}
+		else if (current_symbol == 93)
+		{
+			token = JsonToken.ArrayEnd;
+			parser_return = true;
+		}
+		else if (current_symbol == 123)
+		{
+			token = JsonToken.ObjectStart;
+			parser_return = true;
+		}
+		else if (current_symbol == 125)
+		{
+			token = JsonToken.ObjectEnd;
+			parser_return = true;
+		}
+		else if (current_symbol == 34)
+		{
+			if (parser_in_string)
+			{
+				parser_in_string = false;
+				parser_return = true;
+				return;
+			}
+			if (token == JsonToken.None)
+			{
+				token = JsonToken.String;
+			}
+			parser_in_string = true;
+		}
+		else if (current_symbol == 65541)
+		{
+			token_value = lexer.StringValue;
+		}
+		else if (current_symbol == 65539)
+		{
+			token = JsonToken.Boolean;
+			token_value = false;
+			parser_return = true;
+		}
+		else if (current_symbol == 65540)
+		{
+			token = JsonToken.Null;
+			parser_return = true;
+		}
+		else if (current_symbol == 65537)
+		{
+			ProcessNumber(lexer.StringValue);
+			parser_return = true;
+		}
+		else if (current_symbol == 65546)
+		{
+			token = JsonToken.PropertyName;
+		}
+		else if (current_symbol == 65538)
+		{
+			token = JsonToken.Boolean;
+			token_value = true;
+			parser_return = true;
+		}
+	}
+
+	private bool ReadToken()
+	{
+		if (end_of_input)
+		{
+			return false;
+		}
+		lexer.NextToken();
+		if (lexer.EndOfInput)
+		{
+			Close();
+			return false;
+		}
+		current_input = lexer.Token;
+		return true;
+	}
+
+	public void Close()
+	{
+		if (!end_of_input)
+		{
+			end_of_input = true;
+			end_of_json = true;
+			if (reader_is_owned)
+			{
+				reader.Dispose();
+			}
+			reader = null;
+		}
+	}
+
+	public bool Read()
+	{
+		if (end_of_input)
+		{
+			return false;
+		}
+		if (end_of_json)
+		{
+			end_of_json = false;
+			automaton_stack.Clear();
+			automaton_stack.Push(65553);
+			automaton_stack.Push(65543);
+		}
+		parser_in_string = false;
+		parser_return = false;
+		token = JsonToken.None;
+		token_value = null;
+		if (!read_started)
+		{
+			read_started = true;
+			if (!ReadToken())
+			{
+				return false;
+			}
+		}
+		while (true)
+		{
+			if (parser_return)
+			{
+				if (automaton_stack.Peek() == 65553)
+				{
+					end_of_json = true;
+				}
+				return true;
+			}
+			current_symbol = automaton_stack.Pop();
+			ProcessSymbol();
+			if (current_symbol == current_input)
+			{
+				if (!ReadToken())
+				{
+					break;
+				}
+				continue;
+			}
+			int[] array;
+			try
+			{
+				array = parse_table[current_symbol][current_input];
+			}
+			catch (KeyNotFoundException inner_exception)
+			{
+				throw new JsonException((ParserToken)current_input, inner_exception);
+			}
+			if (array[0] != 65554)
+			{
+				for (int num = array.Length - 1; num >= 0; num--)
+				{
+					automaton_stack.Push(array[num]);
+				}
+			}
+		}
+		if (automaton_stack.Peek() != 65553)
+		{
+			throw new JsonException("Input doesn't evaluate to proper JSON text");
+		}
+		if (parser_return)
+		{
+			return true;
+		}
+		return false;
+	}
+}

SVSim.BattleEngine/Engine/LitJson/JsonToken.cs

@@ -0,0 +1,17 @@
+namespace LitJson;
+
+public enum JsonToken
+{
+	None,
+	ObjectStart,
+	PropertyName,
+	ObjectEnd,
+	ArrayStart,
+	ArrayEnd,
+	Int,
+	Long,
+	Double,
+	String,
+	Boolean,
+	Null
+}

SVSim.BattleEngine/Engine/LitJson/JsonType.cs

@@ -0,0 +1,13 @@
+namespace LitJson;
+
+public enum JsonType
+{
+	None,
+	Object,
+	Array,
+	String,
+	Int,
+	Long,
+	Double,
+	Boolean
+}

SVSim.BattleEngine/Engine/LitJson/JsonWriter.cs

@@ -0,0 +1,435 @@
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Text;
+
+namespace LitJson;
+
+public class JsonWriter
+{
+	private static NumberFormatInfo number_format;
+
+	private WriterContext context;
+
+	private Stack<WriterContext> ctx_stack;
+
+	private bool has_reached_end;
+
+	private char[] hex_seq;
+
+	private int indentation;
+
+	private int indent_value;
+
+	private StringBuilder inst_string_builder;
+
+	private bool pretty_print;
+
+	private bool validate;
+
+	private TextWriter writer;
+
+	public int IndentValue
+	{
+		get
+		{
+			return indent_value;
+		}
+		set
+		{
+			indentation = indentation / indent_value * value;
+			indent_value = value;
+		}
+	}
+
+	public bool PrettyPrint
+	{
+		get
+		{
+			return pretty_print;
+		}
+		set
+		{
+			pretty_print = value;
+		}
+	}
+
+	public TextWriter TextWriter => writer;
+
+	public bool Validate
+	{
+		get
+		{
+			return validate;
+		}
+		set
+		{
+			validate = value;
+		}
+	}
+
+	static JsonWriter()
+	{
+		number_format = NumberFormatInfo.InvariantInfo;
+	}
+
+	public JsonWriter()
+	{
+		inst_string_builder = new StringBuilder();
+		writer = new StringWriter(inst_string_builder);
+		Init();
+	}
+
+	public JsonWriter(StringBuilder sb)
+		: this(new StringWriter(sb))
+	{
+	}
+
+	public JsonWriter(TextWriter writer)
+	{
+		if (writer == null)
+		{
+			throw new ArgumentNullException("writer");
+		}
+		this.writer = writer;
+		Init();
+	}
+
+	private void DoValidation(Condition cond)
+	{
+		if (!context.ExpectingValue)
+		{
+			context.Count++;
+		}
+		if (!validate)
+		{
+			return;
+		}
+		if (has_reached_end)
+		{
+			throw new JsonException("A complete JSON symbol has already been written");
+		}
+		switch (cond)
+		{
+		case Condition.InArray:
+			if (!context.InArray)
+			{
+				throw new JsonException("Can't close an array here");
+			}
+			break;
+		case Condition.InObject:
+			if (!context.InObject || context.ExpectingValue)
+			{
+				throw new JsonException("Can't close an object here");
+			}
+			break;
+		case Condition.NotAProperty:
+			if (context.InObject && !context.ExpectingValue)
+			{
+				throw new JsonException("Expected a property");
+			}
+			break;
+		case Condition.Property:
+			if (!context.InObject || context.ExpectingValue)
+			{
+				throw new JsonException("Can't add a property here");
+			}
+			break;
+		case Condition.Value:
+			if (!context.InArray && (!context.InObject || !context.ExpectingValue))
+			{
+				throw new JsonException("Can't add a value here");
+			}
+			break;
+		}
+	}
+
+	private void Init()
+	{
+		has_reached_end = false;
+		hex_seq = new char[4];
+		indentation = 0;
+		indent_value = 4;
+		pretty_print = false;
+		validate = true;
+		ctx_stack = new Stack<WriterContext>();
+		context = new WriterContext();
+		ctx_stack.Push(context);
+	}
+
+	private static void IntToHex(int n, char[] hex)
+	{
+		for (int i = 0; i < 4; i++)
+		{
+			int num = n % 16;
+			if (num < 10)
+			{
+				hex[3 - i] = (char)(48 + num);
+			}
+			else
+			{
+				hex[3 - i] = (char)(65 + (num - 10));
+			}
+			n >>= 4;
+		}
+	}
+
+	private void Indent()
+	{
+		if (pretty_print)
+		{
+			indentation += indent_value;
+		}
+	}
+
+	private void Put(string str)
+	{
+		if (pretty_print && !context.ExpectingValue)
+		{
+			for (int i = 0; i < indentation; i++)
+			{
+				writer.Write(' ');
+			}
+		}
+		writer.Write(str);
+	}
+
+	private void PutNewline()
+	{
+		PutNewline(add_comma: true);
+	}
+
+	private void PutNewline(bool add_comma)
+	{
+		if (add_comma && !context.ExpectingValue && context.Count > 1)
+		{
+			writer.Write(',');
+		}
+		if (pretty_print && !context.ExpectingValue)
+		{
+			writer.Write('\n');
+		}
+	}
+
+	private void PutString(string str)
+	{
+		Put(string.Empty);
+		writer.Write('"');
+		int length = str.Length;
+		for (int i = 0; i < length; i++)
+		{
+			switch (str[i])
+			{
+			case '\n':
+				writer.Write("\\n");
+				continue;
+			case '\r':
+				writer.Write("\\r");
+				continue;
+			case '\t':
+				writer.Write("\\t");
+				continue;
+			case '"':
+			case '\\':
+				writer.Write('\\');
+				writer.Write(str[i]);
+				continue;
+			case '\f':
+				writer.Write("\\f");
+				continue;
+			case '\b':
+				writer.Write("\\b");
+				continue;
+			}
+			if (str[i] >= ' ' && str[i] <= '~')
+			{
+				writer.Write(str[i]);
+				continue;
+			}
+			IntToHex(str[i], hex_seq);
+			writer.Write("\\u");
+			writer.Write(hex_seq);
+		}
+		writer.Write('"');
+	}
+
+	private void Unindent()
+	{
+		if (pretty_print)
+		{
+			indentation -= indent_value;
+		}
+	}
+
+	public override string ToString()
+	{
+		if (inst_string_builder == null)
+		{
+			return string.Empty;
+		}
+		return inst_string_builder.ToString();
+	}
+
+	public void Reset()
+	{
+		has_reached_end = false;
+		ctx_stack.Clear();
+		context = new WriterContext();
+		ctx_stack.Push(context);
+		if (inst_string_builder != null)
+		{
+			inst_string_builder.Remove(0, inst_string_builder.Length);
+		}
+	}
+
+	public void Write(bool boolean)
+	{
+		DoValidation(Condition.Value);
+		PutNewline();
+		Put(boolean ? "true" : "false");
+		context.ExpectingValue = false;
+	}
+
+	public void Write(decimal number)
+	{
+		DoValidation(Condition.Value);
+		PutNewline();
+		Put(Convert.ToString(number, number_format));
+		context.ExpectingValue = false;
+	}
+
+	public void Write(double number)
+	{
+		DoValidation(Condition.Value);
+		PutNewline();
+		string text = Convert.ToString(number, number_format);
+		Put(text);
+		if (text.IndexOf('.') == -1 && text.IndexOf('E') == -1)
+		{
+			writer.Write(".0");
+		}
+		context.ExpectingValue = false;
+	}
+
+	public void Write(int number)
+	{
+		DoValidation(Condition.Value);
+		PutNewline();
+		Put(Convert.ToString(number, number_format));
+		context.ExpectingValue = false;
+	}
+
+	public void Write(long number)
+	{
+		DoValidation(Condition.Value);
+		PutNewline();
+		Put(Convert.ToString(number, number_format));
+		context.ExpectingValue = false;
+	}
+
+	public void Write(string str)
+	{
+		DoValidation(Condition.Value);
+		PutNewline();
+		if (str == null)
+		{
+			Put("null");
+		}
+		else
+		{
+			PutString(str);
+		}
+		context.ExpectingValue = false;
+	}
+
+	public void Write(ulong number)
+	{
+		DoValidation(Condition.Value);
+		PutNewline();
+		Put(Convert.ToString(number, number_format));
+		context.ExpectingValue = false;
+	}
+
+	public void WriteArrayEnd()
+	{
+		DoValidation(Condition.InArray);
+		PutNewline(add_comma: false);
+		ctx_stack.Pop();
+		if (ctx_stack.Count == 1)
+		{
+			has_reached_end = true;
+		}
+		else
+		{
+			context = ctx_stack.Peek();
+			context.ExpectingValue = false;
+		}
+		Unindent();
+		Put("]");
+	}
+
+	public void WriteArrayStart()
+	{
+		DoValidation(Condition.NotAProperty);
+		PutNewline();
+		Put("[");
+		context = new WriterContext();
+		context.InArray = true;
+		ctx_stack.Push(context);
+		Indent();
+	}
+
+	public void WriteObjectEnd()
+	{
+		DoValidation(Condition.InObject);
+		PutNewline(add_comma: false);
+		ctx_stack.Pop();
+		if (ctx_stack.Count == 1)
+		{
+			has_reached_end = true;
+		}
+		else
+		{
+			context = ctx_stack.Peek();
+			context.ExpectingValue = false;
+		}
+		Unindent();
+		Put("}");
+	}
+
+	public void WriteObjectStart()
+	{
+		DoValidation(Condition.NotAProperty);
+		PutNewline();
+		Put("{");
+		context = new WriterContext();
+		context.InObject = true;
+		ctx_stack.Push(context);
+		Indent();
+	}
+
+	public void WritePropertyName(string property_name)
+	{
+		DoValidation(Condition.Property);
+		PutNewline();
+		PutString(property_name);
+		if (pretty_print)
+		{
+			if (property_name.Length > context.Padding)
+			{
+				context.Padding = property_name.Length;
+			}
+			for (int num = context.Padding - property_name.Length; num >= 0; num--)
+			{
+				writer.Write(' ');
+			}
+			writer.Write(": ");
+		}
+		else
+		{
+			writer.Write(':');
+		}
+		context.ExpectingValue = true;
+	}
+}

SVSim.BattleEngine/Engine/LitJson/Lexer.cs

@@ -0,0 +1,753 @@
+using System;
+using System.IO;
+using System.Text;
+
+namespace LitJson;
+
+internal class Lexer
+{
+	private delegate bool StateHandler(FsmContext ctx);
+
+	private static int[] fsm_return_table;
+
+	private static StateHandler[] fsm_handler_table;
+
+	private bool allow_comments;
+
+	private bool allow_single_quoted_strings;
+
+	private bool end_of_input;
+
+	private FsmContext fsm_context;
+
+	private int input_buffer;
+
+	private int input_char;
+
+	private TextReader reader;
+
+	private int state;
+
+	private StringBuilder string_buffer;
+
+	private string string_value;
+
+	private int token;
+
+	private int unichar;
+
+	public bool AllowComments
+	{
+		get
+		{
+			return allow_comments;
+		}
+		set
+		{
+			allow_comments = value;
+		}
+	}
+
+	public bool AllowSingleQuotedStrings
+	{
+		get
+		{
+			return allow_single_quoted_strings;
+		}
+		set
+		{
+			allow_single_quoted_strings = value;
+		}
+	}
+
+	public bool EndOfInput => end_of_input;
+
+	public int Token => token;
+
+	public string StringValue => string_value;
+
+	static Lexer()
+	{
+		PopulateFsmTables();
+	}
+
+	public Lexer(TextReader reader)
+	{
+		allow_comments = true;
+		allow_single_quoted_strings = true;
+		input_buffer = 0;
+		string_buffer = new StringBuilder(128);
+		state = 1;
+		end_of_input = false;
+		this.reader = reader;
+		fsm_context = new FsmContext();
+		fsm_context.L = this;
+	}
+
+	private static int HexValue(int digit)
+	{
+		switch (digit)
+		{
+		case 65:
+		case 97:
+			return 10;
+		case 66:
+		case 98:
+			return 11;
+		case 67:
+		case 99:
+			return 12;
+		case 68:
+		case 100:
+			return 13;
+		case 69:
+		case 101:
+			return 14;
+		case 70:
+		case 102:
+			return 15;
+		default:
+			return digit - 48;
+		}
+	}
+
+	private static void PopulateFsmTables()
+	{
+		fsm_handler_table = new StateHandler[28]
+		{
+			State1, State2, State3, State4, State5, State6, State7, State8, State9, State10,
+			State11, State12, State13, State14, State15, State16, State17, State18, State19, State20,
+			State21, State22, State23, State24, State25, State26, State27, State28
+		};
+		fsm_return_table = new int[28]
+		{
+			65542, 0, 65537, 65537, 0, 65537, 0, 65537, 0, 0,
+			65538, 0, 0, 0, 65539, 0, 0, 65540, 65541, 65542,
+			0, 0, 65541, 65542, 0, 0, 0, 0
+		};
+	}
+
+	private static char ProcessEscChar(int esc_char)
+	{
+		switch (esc_char)
+		{
+		case 34:
+		case 39:
+		case 47:
+		case 92:
+			return Convert.ToChar(esc_char);
+		case 110:
+			return '\n';
+		case 116:
+			return '\t';
+		case 114:
+			return '\r';
+		case 98:
+			return '\b';
+		case 102:
+			return '\f';
+		default:
+			return '?';
+		}
+	}
+
+	private static bool State1(FsmContext ctx)
+	{
+		while (ctx.L.GetChar())
+		{
+			if (ctx.L.input_char == 32 || (ctx.L.input_char >= 9 && ctx.L.input_char <= 13))
+			{
+				continue;
+			}
+			if (ctx.L.input_char >= 49 && ctx.L.input_char <= 57)
+			{
+				ctx.L.string_buffer.Append((char)ctx.L.input_char);
+				ctx.NextState = 3;
+				return true;
+			}
+			switch (ctx.L.input_char)
+			{
+			case 34:
+				ctx.NextState = 19;
+				ctx.Return = true;
+				return true;
+			case 44:
+			case 58:
+			case 91:
+			case 93:
+			case 123:
+			case 125:
+				ctx.NextState = 1;
+				ctx.Return = true;
+				return true;
+			case 45:
+				ctx.L.string_buffer.Append((char)ctx.L.input_char);
+				ctx.NextState = 2;
+				return true;
+			case 48:
+				ctx.L.string_buffer.Append((char)ctx.L.input_char);
+				ctx.NextState = 4;
+				return true;
+			case 102:
+				ctx.NextState = 12;
+				return true;
+			case 110:
+				ctx.NextState = 16;
+				return true;
+			case 116:
+				ctx.NextState = 9;
+				return true;
+			case 39:
+				if (!ctx.L.allow_single_quoted_strings)
+				{
+					return false;
+				}
+				ctx.L.input_char = 34;
+				ctx.NextState = 23;
+				ctx.Return = true;
+				return true;
+			case 47:
+				if (!ctx.L.allow_comments)
+				{
+					return false;
+				}
+				ctx.NextState = 25;
+				return true;
+			default:
+				return false;
+			}
+		}
+		return true;
+	}
+
+	private static bool State2(FsmContext ctx)
+	{
+		ctx.L.GetChar();
+		if (ctx.L.input_char >= 49 && ctx.L.input_char <= 57)
+		{
+			ctx.L.string_buffer.Append((char)ctx.L.input_char);
+			ctx.NextState = 3;
+			return true;
+		}
+		if (ctx.L.input_char == 48)
+		{
+			ctx.L.string_buffer.Append((char)ctx.L.input_char);
+			ctx.NextState = 4;
+			return true;
+		}
+		return false;
+	}
+
+	private static bool State3(FsmContext ctx)
+	{
+		while (ctx.L.GetChar())
+		{
+			if (ctx.L.input_char >= 48 && ctx.L.input_char <= 57)
+			{
+				ctx.L.string_buffer.Append((char)ctx.L.input_char);
+				continue;
+			}
+			if (ctx.L.input_char == 32 || (ctx.L.input_char >= 9 && ctx.L.input_char <= 13))
+			{
+				ctx.Return = true;
+				ctx.NextState = 1;
+				return true;
+			}
+			switch (ctx.L.input_char)
+			{
+			case 44:
+			case 93:
+			case 125:
+				ctx.L.UngetChar();
+				ctx.Return = true;
+				ctx.NextState = 1;
+				return true;
+			case 46:
+				ctx.L.string_buffer.Append((char)ctx.L.input_char);
+				ctx.NextState = 5;
+				return true;
+			case 69:
+			case 101:
+				ctx.L.string_buffer.Append((char)ctx.L.input_char);
+				ctx.NextState = 7;
+				return true;
+			default:
+				return false;
+			}
+		}
+		return true;
+	}
+
+	private static bool State4(FsmContext ctx)
+	{
+		ctx.L.GetChar();
+		if (ctx.L.input_char == 32 || (ctx.L.input_char >= 9 && ctx.L.input_char <= 13))
+		{
+			ctx.Return = true;
+			ctx.NextState = 1;
+			return true;
+		}
+		switch (ctx.L.input_char)
+		{
+		case 44:
+		case 93:
+		case 125:
+			ctx.L.UngetChar();
+			ctx.Return = true;
+			ctx.NextState = 1;
+			return true;
+		case 46:
+			ctx.L.string_buffer.Append((char)ctx.L.input_char);
+			ctx.NextState = 5;
+			return true;
+		case 69:
+		case 101:
+			ctx.L.string_buffer.Append((char)ctx.L.input_char);
+			ctx.NextState = 7;
+			return true;
+		default:
+			return false;
+		}
+	}
+
+	private static bool State5(FsmContext ctx)
+	{
+		ctx.L.GetChar();
+		if (ctx.L.input_char >= 48 && ctx.L.input_char <= 57)
+		{
+			ctx.L.string_buffer.Append((char)ctx.L.input_char);
+			ctx.NextState = 6;
+			return true;
+		}
+		return false;
+	}
+
+	private static bool State6(FsmContext ctx)
+	{
+		while (ctx.L.GetChar())
+		{
+			if (ctx.L.input_char >= 48 && ctx.L.input_char <= 57)
+			{
+				ctx.L.string_buffer.Append((char)ctx.L.input_char);
+				continue;
+			}
+			if (ctx.L.input_char == 32 || (ctx.L.input_char >= 9 && ctx.L.input_char <= 13))
+			{
+				ctx.Return = true;
+				ctx.NextState = 1;
+				return true;
+			}
+			switch (ctx.L.input_char)
+			{
+			case 44:
+			case 93:
+			case 125:
+				ctx.L.UngetChar();
+				ctx.Return = true;
+				ctx.NextState = 1;
+				return true;
+			case 69:
+			case 101:
+				ctx.L.string_buffer.Append((char)ctx.L.input_char);
+				ctx.NextState = 7;
+				return true;
+			default:
+				return false;
+			}
+		}
+		return true;
+	}
+
+	private static bool State7(FsmContext ctx)
+	{
+		ctx.L.GetChar();
+		if (ctx.L.input_char >= 48 && ctx.L.input_char <= 57)
+		{
+			ctx.L.string_buffer.Append((char)ctx.L.input_char);
+			ctx.NextState = 8;
+			return true;
+		}
+		int num = ctx.L.input_char;
+		if (num == 43 || num == 45)
+		{
+			ctx.L.string_buffer.Append((char)ctx.L.input_char);
+			ctx.NextState = 8;
+			return true;
+		}
+		return false;
+	}
+
+	private static bool State8(FsmContext ctx)
+	{
+		while (ctx.L.GetChar())
+		{
+			if (ctx.L.input_char >= 48 && ctx.L.input_char <= 57)
+			{
+				ctx.L.string_buffer.Append((char)ctx.L.input_char);
+				continue;
+			}
+			if (ctx.L.input_char == 32 || (ctx.L.input_char >= 9 && ctx.L.input_char <= 13))
+			{
+				ctx.Return = true;
+				ctx.NextState = 1;
+				return true;
+			}
+			int num = ctx.L.input_char;
+			if (num == 44 || num == 93 || num == 125)
+			{
+				ctx.L.UngetChar();
+				ctx.Return = true;
+				ctx.NextState = 1;
+				return true;
+			}
+			return false;
+		}
+		return true;
+	}
+
+	private static bool State9(FsmContext ctx)
+	{
+		ctx.L.GetChar();
+		if (ctx.L.input_char == 114)
+		{
+			ctx.NextState = 10;
+			return true;
+		}
+		return false;
+	}
+
+	private static bool State10(FsmContext ctx)
+	{
+		ctx.L.GetChar();
+		if (ctx.L.input_char == 117)
+		{
+			ctx.NextState = 11;
+			return true;
+		}
+		return false;
+	}
+
+	private static bool State11(FsmContext ctx)
+	{
+		ctx.L.GetChar();
+		if (ctx.L.input_char == 101)
+		{
+			ctx.Return = true;
+			ctx.NextState = 1;
+			return true;
+		}
+		return false;
+	}
+
+	private static bool State12(FsmContext ctx)
+	{
+		ctx.L.GetChar();
+		if (ctx.L.input_char == 97)
+		{
+			ctx.NextState = 13;
+			return true;
+		}
+		return false;
+	}
+
+	private static bool State13(FsmContext ctx)
+	{
+		ctx.L.GetChar();
+		if (ctx.L.input_char == 108)
+		{
+			ctx.NextState = 14;
+			return true;
+		}
+		return false;
+	}
+
+	private static bool State14(FsmContext ctx)
+	{
+		ctx.L.GetChar();
+		if (ctx.L.input_char == 115)
+		{
+			ctx.NextState = 15;
+			return true;
+		}
+		return false;
+	}
+
+	private static bool State15(FsmContext ctx)
+	{
+		ctx.L.GetChar();
+		if (ctx.L.input_char == 101)
+		{
+			ctx.Return = true;
+			ctx.NextState = 1;
+			return true;
+		}
+		return false;
+	}
+
+	private static bool State16(FsmContext ctx)
+	{
+		ctx.L.GetChar();
+		if (ctx.L.input_char == 117)
+		{
+			ctx.NextState = 17;
+			return true;
+		}
+		return false;
+	}
+
+	private static bool State17(FsmContext ctx)
+	{
+		ctx.L.GetChar();
+		if (ctx.L.input_char == 108)
+		{
+			ctx.NextState = 18;
+			return true;
+		}
+		return false;
+	}
+
+	private static bool State18(FsmContext ctx)
+	{
+		ctx.L.GetChar();
+		if (ctx.L.input_char == 108)
+		{
+			ctx.Return = true;
+			ctx.NextState = 1;
+			return true;
+		}
+		return false;
+	}
+
+	private static bool State19(FsmContext ctx)
+	{
+		while (ctx.L.GetChar())
+		{
+			switch (ctx.L.input_char)
+			{
+			case 34:
+				ctx.L.UngetChar();
+				ctx.Return = true;
+				ctx.NextState = 20;
+				return true;
+			case 92:
+				ctx.StateStack = 19;
+				ctx.NextState = 21;
+				return true;
+			}
+			ctx.L.string_buffer.Append((char)ctx.L.input_char);
+		}
+		return true;
+	}
+
+	private static bool State20(FsmContext ctx)
+	{
+		ctx.L.GetChar();
+		if (ctx.L.input_char == 34)
+		{
+			ctx.Return = true;
+			ctx.NextState = 1;
+			return true;
+		}
+		return false;
+	}
+
+	private static bool State21(FsmContext ctx)
+	{
+		ctx.L.GetChar();
+		switch (ctx.L.input_char)
+		{
+		case 117:
+			ctx.NextState = 22;
+			return true;
+		case 34:
+		case 39:
+		case 47:
+		case 92:
+		case 98:
+		case 102:
+		case 110:
+		case 114:
+		case 116:
+			ctx.L.string_buffer.Append(ProcessEscChar(ctx.L.input_char));
+			ctx.NextState = ctx.StateStack;
+			return true;
+		default:
+			return false;
+		}
+	}
+
+	private static bool State22(FsmContext ctx)
+	{
+		int num = 0;
+		int num2 = 4096;
+		ctx.L.unichar = 0;
+		while (ctx.L.GetChar())
+		{
+			if ((ctx.L.input_char >= 48 && ctx.L.input_char <= 57) || (ctx.L.input_char >= 65 && ctx.L.input_char <= 70) || (ctx.L.input_char >= 97 && ctx.L.input_char <= 102))
+			{
+				ctx.L.unichar += HexValue(ctx.L.input_char) * num2;
+				num++;
+				num2 /= 16;
+				if (num == 4)
+				{
+					ctx.L.string_buffer.Append(Convert.ToChar(ctx.L.unichar));
+					ctx.NextState = ctx.StateStack;
+					return true;
+				}
+				continue;
+			}
+			return false;
+		}
+		return true;
+	}
+
+	private static bool State23(FsmContext ctx)
+	{
+		while (ctx.L.GetChar())
+		{
+			switch (ctx.L.input_char)
+			{
+			case 39:
+				ctx.L.UngetChar();
+				ctx.Return = true;
+				ctx.NextState = 24;
+				return true;
+			case 92:
+				ctx.StateStack = 23;
+				ctx.NextState = 21;
+				return true;
+			}
+			ctx.L.string_buffer.Append((char)ctx.L.input_char);
+		}
+		return true;
+	}
+
+	private static bool State24(FsmContext ctx)
+	{
+		ctx.L.GetChar();
+		if (ctx.L.input_char == 39)
+		{
+			ctx.L.input_char = 34;
+			ctx.Return = true;
+			ctx.NextState = 1;
+			return true;
+		}
+		return false;
+	}
+
+	private static bool State25(FsmContext ctx)
+	{
+		ctx.L.GetChar();
+		switch (ctx.L.input_char)
+		{
+		case 42:
+			ctx.NextState = 27;
+			return true;
+		case 47:
+			ctx.NextState = 26;
+			return true;
+		default:
+			return false;
+		}
+	}
+
+	private static bool State26(FsmContext ctx)
+	{
+		while (ctx.L.GetChar())
+		{
+			if (ctx.L.input_char == 10)
+			{
+				ctx.NextState = 1;
+				return true;
+			}
+		}
+		return true;
+	}
+
+	private static bool State27(FsmContext ctx)
+	{
+		while (ctx.L.GetChar())
+		{
+			if (ctx.L.input_char == 42)
+			{
+				ctx.NextState = 28;
+				return true;
+			}
+		}
+		return true;
+	}
+
+	private static bool State28(FsmContext ctx)
+	{
+		while (ctx.L.GetChar())
+		{
+			if (ctx.L.input_char != 42)
+			{
+				if (ctx.L.input_char == 47)
+				{
+					ctx.NextState = 1;
+					return true;
+				}
+				ctx.NextState = 27;
+				return true;
+			}
+		}
+		return true;
+	}
+
+	private bool GetChar()
+	{
+		if ((input_char = NextChar()) != -1)
+		{
+			return true;
+		}
+		end_of_input = true;
+		return false;
+	}
+
+	private int NextChar()
+	{
+		if (input_buffer != 0)
+		{
+			int result = input_buffer;
+			input_buffer = 0;
+			return result;
+		}
+		return reader.Read();
+	}
+
+	public bool NextToken()
+	{
+		fsm_context.Return = false;
+		while (true)
+		{
+			if (!fsm_handler_table[state - 1](fsm_context))
+			{
+				throw new JsonException(input_char);
+			}
+			if (end_of_input)
+			{
+				return false;
+			}
+			if (fsm_context.Return)
+			{
+				break;
+			}
+			state = fsm_context.NextState;
+		}
+		string_value = string_buffer.ToString();
+		string_buffer.Remove(0, string_buffer.Length);
+		token = fsm_return_table[state - 1];
+		if (token == 65542)
+		{
+			token = input_char;
+		}
+		state = fsm_context.NextState;
+		return true;
+	}
+
+	private void UngetChar()
+	{
+		input_buffer = input_char;
+	}
+}

SVSim.BattleEngine/Engine/LitJson/ObjectMetadata.cs

@@ -0,0 +1,53 @@
+using System;
+using System.Collections.Generic;
+
+namespace LitJson;
+
+internal struct ObjectMetadata
+{
+	private Type element_type;
+
+	private bool is_dictionary;
+
+	private IDictionary<string, PropertyMetadata> properties;
+
+	public Type ElementType
+	{
+		get
+		{
+			if (element_type == null)
+			{
+				return typeof(JsonData);
+			}
+			return element_type;
+		}
+		set
+		{
+			element_type = value;
+		}
+	}
+
+	public bool IsDictionary
+	{
+		get
+		{
+			return is_dictionary;
+		}
+		set
+		{
+			is_dictionary = value;
+		}
+	}
+
+	public IDictionary<string, PropertyMetadata> Properties
+	{
+		get
+		{
+			return properties;
+		}
+		set
+		{
+			properties = value;
+		}
+	}
+}

SVSim.BattleEngine/Engine/LitJson/OrderedDictionaryEnumerator.cs

@@ -0,0 +1,39 @@
+using System.Collections;
+using System.Collections.Generic;
+
+namespace LitJson;
+
+internal class OrderedDictionaryEnumerator : IDictionaryEnumerator, IEnumerator
+{
+	private IEnumerator<KeyValuePair<string, JsonData>> list_enumerator;
+
+	public object Current => Entry;
+
+	public DictionaryEntry Entry
+	{
+		get
+		{
+			KeyValuePair<string, JsonData> current = list_enumerator.Current;
+			return new DictionaryEntry(current.Key, current.Value);
+		}
+	}
+
+	public object Key => list_enumerator.Current.Key;
+
+	public object Value => list_enumerator.Current.Value;
+
+	public OrderedDictionaryEnumerator(IEnumerator<KeyValuePair<string, JsonData>> enumerator)
+	{
+		list_enumerator = enumerator;
+	}
+
+	public bool MoveNext()
+	{
+		return list_enumerator.MoveNext();
+	}
+
+	public void Reset()
+	{
+		list_enumerator.Reset();
+	}
+}

SVSim.BattleEngine/Engine/LitJson/ParserToken.cs

@@ -0,0 +1,24 @@
+namespace LitJson;
+
+internal enum ParserToken
+{
+	None = 65536,
+	Number,
+	True,
+	False,
+	Null,
+	CharSeq,
+	Char,
+	Text,
+	Object,
+	ObjectPrime,
+	Pair,
+	PairRest,
+	Array,
+	ArrayPrime,
+	Value,
+	ValueRest,
+	String,
+	End,
+	Epsilon
+}

SVSim.BattleEngine/Engine/LitJson/PropertyMetadata.cs

@@ -0,0 +1,13 @@
+using System;
+using System.Reflection;
+
+namespace LitJson;
+
+internal struct PropertyMetadata
+{
+	public MemberInfo Info;
+
+	public bool IsField;
+
+	public Type Type;
+}

SVSim.BattleEngine/Engine/LitJson/WrapperFactory.cs

@@ -0,0 +1,3 @@
+namespace LitJson;
+
+public delegate IJsonWrapper WrapperFactory();

SVSim.BattleEngine/Engine/LitJson/WriterContext.cs

@@ -0,0 +1,14 @@
+namespace LitJson;
+
+internal class WriterContext
+{
+	public int Count;
+
+	public bool InArray;
+
+	public bool InObject;
+
+	public bool ExpectingValue;
+
+	public int Padding;
+}