Init

.vsconfig

@@ -0,0 +1,6 @@
+{
+  "version": "1.0",
+  "components": [ 
+    "Microsoft.VisualStudio.Workload.ManagedGame"
+  ]
+} 

Assets/Common.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: faae8d0ea0ba4ed4a91f5b5ad0bb1691
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Common/EduCoderWebSupport.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 36f1756d6a2232e4abb136594e8c7817
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Common/EduCoderWebSupport/WebConnectSample.cs

@@ -0,0 +1,30 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.UI;
+
+public class WebConnectSample : MonoBehaviour
+{
+    public Text recTxt;
+    private void Awake()
+    {
+        //注册接收方法
+        EduCoderTool.WebConnecter.Singleton.dataHandle += ReceiveWebMsg;
+    }
+
+    //接收从平台发送过来的数据
+    void ReceiveWebMsg(string data)
+    {
+        Debug.Log("ReceiveWebMsg:" + data);
+        recTxt.text = data;
+
+    }
+
+
+    //提交成绩，一共有3个方法，这里展示了常用的提交分数的方法
+    public void ButtonClick()
+    {
+        EduCoderTool.WebConnecter.Singleton.SendResultToWeb(true, 90);
+    }
+
+}

Assets/Common/EduCoderWebSupport/WebConnectSample.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 0550a7372904fc74ea3f3607c91bac07
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Common/EduCoderWebSupport/WebConnecter.cs

@@ -0,0 +1,110 @@
+
+using UnityEngine;
+using System;
+using System.Runtime.InteropServices;
+using Newtonsoft.Json;
+using System.Collections.Generic;
+
+namespace EduCoderTool
+{
+    /*
+     * web端通讯中转器
+     * @author lz
+     **/
+    public class WebConnecter : MonoBehaviour
+    {
+
+        private static WebConnecter instance = null;
+        /// <summary>
+        /// 单例
+        /// </summary>
+        public static WebConnecter Singleton
+        {
+            get
+            {
+                if(instance == null)
+                {
+                    instance = GameObject.FindObjectOfType<WebConnecter>();
+                    if(instance == null)
+                    {
+                        GameObject go = new GameObject("WebConnecter");
+                        instance = go.AddComponent<WebConnecter>();
+                    }
+                }
+                return instance;
+            }
+        }
+
+        //引用jslib的方法
+        [DllImport("__Internal")]
+        private static extern void SendMsgToWeb(string str);
+
+
+
+
+        //接收数据
+        public Action<string> dataHandle;
+
+
+        void Awake()
+        {
+            if(instance == null)
+            {
+                instance = this;
+            }else
+            {
+                Destroy(gameObject);
+            }
+        }
+
+
+        /// <summary>
+        /// 接收web端发送数据
+        /// </summary>
+        /// <param name="jsonStr"></param>
+        public void RecData(string jsonStr)
+        {
+            dataHandle?.Invoke(jsonStr);
+        }
+
+        /// <summary>
+        /// 发送数据到web端
+        /// </summary>
+        /// <param name="data"></param>
+        public void SendDataToWeb(string data)
+        {
+
+            Debug.LogFormat(">>>>>> unity send web data{0}",data);
+            if (Application.platform == RuntimePlatform.WebGLPlayer)
+            {
+                SendMsgToWeb(data);
+            }
+            
+        }
+
+
+        public void SendResultToWeb(bool success)
+        {
+            Dictionary<string, string> data = new Dictionary<string, string>();
+            data.Add("GameState", success ? "Success" : "Fail");
+            data.Add("Data", "");
+            string json = JsonConvert.SerializeObject(data);
+            SendDataToWeb(json);
+        }
+
+
+        public void SendResultToWeb(bool success, double score)
+        {
+            Dictionary<string, object> data = new Dictionary<string, object>();
+            data.Add("GameState", success ? "Success" : "Fail");
+            data.Add("Data", score);
+            string json = JsonConvert.SerializeObject(data);
+            SendDataToWeb(json);
+        }
+
+
+
+
+    }
+}
+

Assets/Common/EduCoderWebSupport/WebConnecter.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 10074c141627f60429a6f308121944bc
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Common/LitJson.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: cd489e0c66d79b2478ba2041dc5f406c
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Common/LitJson/AssemblyInfo.cs.in

@@ -0,0 +1,18 @@
+using System;
+using System.Reflection;
+using System.Runtime.CompilerServices;
+
+
+[assembly: CLSCompliant (true)]
+
+[assembly: AssemblyTitle ("LitJson")]
+[assembly: AssemblyDescription ("LitJSON library")]
+[assembly: AssemblyConfiguration ("")]
+[assembly: AssemblyCompany ("")]
+[assembly: AssemblyProduct ("LitJSON")]
+[assembly: AssemblyCopyright (
+    "The authors disclaim copyright to this source code")]
+[assembly: AssemblyTrademark ("")]
+[assembly: AssemblyCulture ("")]
+
+[assembly: AssemblyVersion ("@ASSEMBLY_VERSION@")]

Assets/Common/LitJson/AssemblyInfo.cs.in.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 48f2d02bcf2b5d1489fee3fe08f7bc1e
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Common/LitJson/IJsonWrapper.cs

@@ -0,0 +1,60 @@
+#region Header
+/**
+ * IJsonWrapper.cs
+ *   Interface that represents a type capable of handling all kinds of JSON
+ *   data. This is mainly used when mapping objects through JsonMapper, and
+ *   it's implemented by JsonData.
+ *
+ * The authors disclaim copyright to this source code. For more details, see
+ * the COPYING file included with this distribution.
+ **/
+#endregion
+
+
+using System.Collections;
+using System.Collections.Specialized;
+
+
+namespace LitJson
+{
+    public enum JsonType
+    {
+        None,
+
+        Object,
+        Array,
+        String,
+        Int,
+        Long,
+        Double,
+        Boolean
+    }
+
+    public interface IJsonWrapper : IList, IOrderedDictionary
+    {
+        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);
+    }
+}

Assets/Common/LitJson/IJsonWrapper.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 98d83e7ddf776ee4caab28ce78c08b65
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Common/LitJson/JsonData.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 518d4c0bd84586948ae90e79bc4578dd
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Common/LitJson/JsonException.cs

@@ -0,0 +1,65 @@
+#region Header
+/**
+ * JsonException.cs
+ *   Base class throwed by LitJSON when a parsing error occurs.
+ *
+ * The authors disclaim copyright to this source code. For more details, see
+ * the COPYING file included with this distribution.
+ **/
+#endregion
+
+
+using System;
+
+
+namespace LitJson
+{
+    public class JsonException :
+#if NETSTANDARD1_5
+        Exception
+#else
+        ApplicationException
+#endif
+    {
+        public JsonException () : base ()
+        {
+        }
+
+        internal JsonException (ParserToken token) :
+            base (String.Format (
+                    "Invalid token '{0}' in input string", token))
+        {
+        }
+
+        internal JsonException (ParserToken token,
+                                Exception inner_exception) :
+            base (String.Format (
+                    "Invalid token '{0}' in input string", token),
+                inner_exception)
+        {
+        }
+
+        internal JsonException (int c) :
+            base (String.Format (
+                    "Invalid character '{0}' in input string", (char) c))
+        {
+        }
+
+        internal JsonException (int c, Exception inner_exception) :
+            base (String.Format (
+                    "Invalid character '{0}' in input string", (char) c),
+                inner_exception)
+        {
+        }
+
+
+        public JsonException (string message) : base (message)
+        {
+        }
+
+        public JsonException (string message, Exception inner_exception) :
+            base (message, inner_exception)
+        {
+        }
+    }
+}

Assets/Common/LitJson/JsonException.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 7c7f5180f8d2e0d4081a62956ac06a30
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Common/LitJson/JsonMapper.cs

@@ -0,0 +1,987 @@
+#region Header
+/**
+ * JsonMapper.cs
+ *   JSON to .Net object and object to JSON conversions.
+ *
+ * The authors disclaim copyright to this source code. For more details, see
+ * the COPYING file included with this distribution.
+ **/
+#endregion
+
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Reflection;
+
+
+namespace LitJson
+{
+    internal struct PropertyMetadata
+    {
+        public MemberInfo Info;
+        public bool       IsField;
+        public Type       Type;
+    }
+
+
+    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; }
+        }
+    }
+
+
+    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; }
+        }
+    }
+
+
+    internal delegate void ExporterFunc    (object obj, JsonWriter writer);
+    public   delegate void ExporterFunc<T> (T obj, JsonWriter writer);
+
+    internal delegate object ImporterFunc                (object input);
+    public   delegate TValue ImporterFunc<TJson, TValue> (TJson input);
+
+    public delegate IJsonWrapper WrapperFactory ();
+
+
+    public class JsonMapper
+    {
+        #region Fields
+        private static readonly int max_nesting_depth;
+
+        private static readonly IFormatProvider datetime_format;
+
+        private static readonly IDictionary<Type, ExporterFunc> base_exporters_table;
+        private static readonly IDictionary<Type, ExporterFunc> custom_exporters_table;
+
+        private static readonly IDictionary<Type,
+                IDictionary<Type, ImporterFunc>> base_importers_table;
+        private static readonly IDictionary<Type,
+                IDictionary<Type, ImporterFunc>> custom_importers_table;
+
+        private static readonly IDictionary<Type, ArrayMetadata> array_metadata;
+        private static readonly object array_metadata_lock = new Object ();
+
+        private static readonly IDictionary<Type,
+                IDictionary<Type, MethodInfo>> conv_ops;
+        private static readonly object conv_ops_lock = new Object ();
+
+        private static readonly IDictionary<Type, ObjectMetadata> object_metadata;
+        private static readonly object object_metadata_lock = new Object ();
+
+        private static readonly IDictionary<Type,
+                IList<PropertyMetadata>> type_properties;
+        private static readonly object type_properties_lock = new Object ();
+
+        private static readonly JsonWriter      static_writer;
+        private static readonly object static_writer_lock = new Object ();
+        #endregion
+
+
+        #region Constructors
+        static JsonMapper ()
+        {
+            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 ();
+        }
+        #endregion
+
+
+        #region Private Methods
+        private static void AddArrayMetadata (Type type)
+        {
+            if (array_metadata.ContainsKey (type))
+                return;
+
+            ArrayMetadata data = new ArrayMetadata ();
+
+            data.IsArray = type.IsArray;
+
+            if (type.GetInterface ("System.Collections.IList") != null)
+                data.IsList = true;
+
+            foreach (PropertyInfo p_info in type.GetProperties ()) {
+                if (p_info.Name != "Item")
+                    continue;
+
+                ParameterInfo[] parameters = p_info.GetIndexParameters ();
+
+                if (parameters.Length != 1)
+                    continue;
+
+                if (parameters[0].ParameterType == typeof (int))
+                    data.ElementType = p_info.PropertyType;
+            }
+
+            lock (array_metadata_lock) {
+                try {
+                    array_metadata.Add (type, data);
+                } catch (ArgumentException) {
+                    return;
+                }
+            }
+        }
+
+        private static void AddObjectMetadata (Type type)
+        {
+            if (object_metadata.ContainsKey (type))
+                return;
+
+            ObjectMetadata data = new ObjectMetadata ();
+
+            if (type.GetInterface ("System.Collections.IDictionary") != null)
+                data.IsDictionary = true;
+
+            data.Properties = new Dictionary<string, PropertyMetadata> ();
+
+            foreach (PropertyInfo p_info in type.GetProperties ()) {
+                if (p_info.Name == "Item") {
+                    ParameterInfo[] parameters = p_info.GetIndexParameters ();
+
+                    if (parameters.Length != 1)
+                        continue;
+
+                    if (parameters[0].ParameterType == typeof (string))
+                        data.ElementType = p_info.PropertyType;
+
+                    continue;
+                }
+
+                PropertyMetadata p_data = new PropertyMetadata ();
+                p_data.Info = p_info;
+                p_data.Type = p_info.PropertyType;
+
+                data.Properties.Add (p_info.Name, p_data);
+            }
+
+            foreach (FieldInfo f_info in type.GetFields ()) {
+                PropertyMetadata p_data = new PropertyMetadata ();
+                p_data.Info = f_info;
+                p_data.IsField = true;
+                p_data.Type = f_info.FieldType;
+
+                data.Properties.Add (f_info.Name, p_data);
+            }
+
+            lock (object_metadata_lock) {
+                try {
+                    object_metadata.Add (type, data);
+                } catch (ArgumentException) {
+                    return;
+                }
+            }
+        }
+
+        private static void AddTypeProperties (Type type)
+        {
+            if (type_properties.ContainsKey (type))
+                return;
+
+            IList<PropertyMetadata> props = new List<PropertyMetadata> ();
+
+            foreach (PropertyInfo p_info in type.GetProperties ()) {
+                if (p_info.Name == "Item")
+                    continue;
+
+                PropertyMetadata p_data = new PropertyMetadata ();
+                p_data.Info = p_info;
+                p_data.IsField = false;
+                props.Add (p_data);
+            }
+
+            foreach (FieldInfo f_info in type.GetFields ()) {
+                PropertyMetadata p_data = new PropertyMetadata ();
+                p_data.Info = f_info;
+                p_data.IsField = true;
+
+                props.Add (p_data);
+            }
+
+            lock (type_properties_lock) {
+                try {
+                    type_properties.Add (type, props);
+                } catch (ArgumentException) {
+                    return;
+                }
+            }
+        }
+
+        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 op = t1.GetMethod (
+                "op_Implicit", new Type[] { t2 });
+
+            lock (conv_ops_lock) {
+                try {
+                    conv_ops[t1].Add (t2, op);
+                } catch (ArgumentException) {
+                    return conv_ops[t1][t2];
+                }
+            }
+
+            return op;
+        }
+
+        private static object ReadValue (Type inst_type, JsonReader reader)
+        {
+            reader.Read ();
+
+            if (reader.Token == JsonToken.ArrayEnd)
+                return null;
+
+            Type underlying_type = Nullable.GetUnderlyingType(inst_type);
+            Type value_type = underlying_type ?? inst_type;
+
+            if (reader.Token == JsonToken.Null) {
+                #if NETSTANDARD1_5
+                if (inst_type.IsClass() || underlying_type != null) {
+                    return null;
+                }
+                #else
+                if (inst_type.IsClass || underlying_type != null) {
+                    return null;
+                }
+                #endif
+
+                throw new JsonException (String.Format (
+                            "Can't assign null to an instance of type {0}",
+                            inst_type));
+            }
+
+            if (reader.Token == JsonToken.Double ||
+                reader.Token == JsonToken.Int ||
+                reader.Token == JsonToken.Long ||
+                reader.Token == JsonToken.String ||
+                reader.Token == JsonToken.Boolean) {
+
+                Type json_type = reader.Value.GetType ();
+
+                if (value_type.IsAssignableFrom (json_type))
+                    return reader.Value;
+
+                // If there's a custom importer that fits, use it
+                if (custom_importers_table.ContainsKey (json_type) &&
+                    custom_importers_table[json_type].ContainsKey (
+                        value_type)) {
+
+                    ImporterFunc importer =
+                        custom_importers_table[json_type][value_type];
+
+                    return importer (reader.Value);
+                }
+
+                // Maybe there's a base importer that works
+                if (base_importers_table.ContainsKey (json_type) &&
+                    base_importers_table[json_type].ContainsKey (
+                        value_type)) {
+
+                    ImporterFunc importer =
+                        base_importers_table[json_type][value_type];
+
+                    return importer (reader.Value);
+                }
+
+                // Maybe it's an enum
+                #if NETSTANDARD1_5
+                if (value_type.IsEnum())
+                    return Enum.ToObject (value_type, reader.Value);
+                #else
+                if (value_type.IsEnum)
+                    return Enum.ToObject (value_type, reader.Value);
+                #endif
+                // Try using an implicit conversion operator
+                MethodInfo conv_op = GetConvOp (value_type, json_type);
+
+                if (conv_op != null)
+                    return conv_op.Invoke (null,
+                                           new object[] { reader.Value });
+
+                // No luck
+                throw new JsonException (String.Format (
+                        "Can't assign value '{0}' (type {1}) to type {2}",
+                        reader.Value, json_type, inst_type));
+            }
+
+            object instance = null;
+
+            if (reader.Token == JsonToken.ArrayStart) {
+
+                AddArrayMetadata (inst_type);
+                ArrayMetadata t_data = array_metadata[inst_type];
+
+                if (! t_data.IsArray && ! t_data.IsList)
+                    throw new JsonException (String.Format (
+                            "Type {0} can't act as an array",
+                            inst_type));
+
+                IList list;
+                Type elem_type;
+
+                if (! t_data.IsArray) {
+                    list = (IList) Activator.CreateInstance (inst_type);
+                    elem_type = t_data.ElementType;
+                } else {
+                    list = new ArrayList ();
+                    elem_type = inst_type.GetElementType ();
+                }
+
+                list.Clear();
+
+                while (true) {
+                    object item = ReadValue (elem_type, reader);
+                    if (item == null && reader.Token == JsonToken.ArrayEnd)
+                        break;
+
+                    list.Add (item);
+                }
+
+                if (t_data.IsArray) {
+                    int n = list.Count;
+                    instance = Array.CreateInstance (elem_type, n);
+
+                    for (int i = 0; i < n; i++)
+                        ((Array) instance).SetValue (list[i], i);
+                } else
+                    instance = list;
+
+            } else if (reader.Token == JsonToken.ObjectStart) {
+                AddObjectMetadata (value_type);
+                ObjectMetadata t_data = object_metadata[value_type];
+
+                instance = Activator.CreateInstance (value_type);
+
+                while (true) {
+                    reader.Read ();
+
+                    if (reader.Token == JsonToken.ObjectEnd)
+                        break;
+
+                    string property = (string) reader.Value;
+
+                    if (t_data.Properties.ContainsKey (property)) {
+                        PropertyMetadata prop_data =
+                            t_data.Properties[property];
+
+                        if (prop_data.IsField) {
+                            ((FieldInfo) prop_data.Info).SetValue (
+                                instance, ReadValue (prop_data.Type, reader));
+                        } else {
+                            PropertyInfo p_info =
+                                (PropertyInfo) prop_data.Info;
+
+                            if (p_info.CanWrite)
+                                p_info.SetValue (
+                                    instance,
+                                    ReadValue (prop_data.Type, reader),
+                                    null);
+                            else
+                                ReadValue (prop_data.Type, reader);
+                        }
+
+                    } else {
+                        if (! t_data.IsDictionary) {
+
+                            if (! reader.SkipNonMembers) {
+                                throw new JsonException (String.Format (
+                                        "The type {0} doesn't have the " +
+                                        "property '{1}'",
+                                        inst_type, property));
+                            } else {
+                                ReadSkip (reader);
+                                continue;
+                            }
+                        }
+
+                        ((IDictionary) instance).Add (
+                            property, ReadValue (
+                                t_data.ElementType, reader));
+                    }
+
+                }
+
+            }
+
+            return instance;
+        }
+
+        private static IJsonWrapper ReadValue (WrapperFactory factory,
+                                               JsonReader reader)
+        {
+            reader.Read ();
+
+            if (reader.Token == JsonToken.ArrayEnd ||
+                reader.Token == JsonToken.Null)
+                return null;
+
+            IJsonWrapper instance = factory ();
+
+            if (reader.Token == JsonToken.String) {
+                instance.SetString ((string) reader.Value);
+                return instance;
+            }
+
+            if (reader.Token == JsonToken.Double) {
+                instance.SetDouble ((double) reader.Value);
+                return instance;
+            }
+
+            if (reader.Token == JsonToken.Int) {
+                instance.SetInt ((int) reader.Value);
+                return instance;
+            }
+
+            if (reader.Token == JsonToken.Long) {
+                instance.SetLong ((long) reader.Value);
+                return instance;
+            }
+
+            if (reader.Token == JsonToken.Boolean) {
+                instance.SetBoolean ((bool) reader.Value);
+                return instance;
+            }
+
+            if (reader.Token == JsonToken.ArrayStart) {
+                instance.SetJsonType (JsonType.Array);
+
+                while (true) {
+                    IJsonWrapper item = ReadValue (factory, reader);
+                    if (item == null && reader.Token == JsonToken.ArrayEnd)
+                        break;
+
+                    ((IList) instance).Add (item);
+                }
+            }
+            else if (reader.Token == JsonToken.ObjectStart) {
+                instance.SetJsonType (JsonType.Object);
+
+                while (true) {
+                    reader.Read ();
+
+                    if (reader.Token == JsonToken.ObjectEnd)
+                        break;
+
+                    string property = (string) reader.Value;
+
+                    ((IDictionary) instance)[property] = ReadValue (
+                        factory, reader);
+                }
+
+            }
+
+            return instance;
+        }
+
+        private static void ReadSkip (JsonReader reader)
+        {
+            ToWrapper (
+                delegate { return 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);
+                };
+
+            base_exporters_table[typeof(DateTimeOffset)] =
+                delegate (object obj, JsonWriter writer) {
+                    writer.Write(((DateTimeOffset)obj).ToString("yyyy-MM-ddTHH:mm:ss.fffffffzzz", datetime_format));
+                };
+        }
+
+        private static void RegisterBaseImporters ()
+        {
+            ImporterFunc importer;
+
+            importer = delegate (object input) {
+                return Convert.ToByte ((int) input);
+            };
+            RegisterImporter (base_importers_table, typeof (int),
+                              typeof (byte), importer);
+
+            importer = delegate (object input) {
+                return Convert.ToUInt64 ((int) input);
+            };
+            RegisterImporter (base_importers_table, typeof (int),
+                              typeof (ulong), importer);
+
+            importer = delegate (object input) {
+                return Convert.ToInt64((int)input);
+            };
+            RegisterImporter(base_importers_table, typeof(int),
+                              typeof(long), importer);
+
+            importer = delegate (object input) {
+                return Convert.ToSByte ((int) input);
+            };
+            RegisterImporter (base_importers_table, typeof (int),
+                              typeof (sbyte), importer);
+
+            importer = delegate (object input) {
+                return Convert.ToInt16 ((int) input);
+            };
+            RegisterImporter (base_importers_table, typeof (int),
+                              typeof (short), importer);
+
+            importer = delegate (object input) {
+                return Convert.ToUInt16 ((int) input);
+            };
+            RegisterImporter (base_importers_table, typeof (int),
+                              typeof (ushort), importer);
+
+            importer = delegate (object input) {
+                return Convert.ToUInt32 ((int) input);
+            };
+            RegisterImporter (base_importers_table, typeof (int),
+                              typeof (uint), importer);
+
+            importer = delegate (object input) {
+                return Convert.ToSingle ((int) input);
+            };
+            RegisterImporter (base_importers_table, typeof (int),
+                              typeof (float), importer);
+
+            importer = delegate (object input) {
+                return Convert.ToDouble ((int) input);
+            };
+            RegisterImporter (base_importers_table, typeof (int),
+                              typeof (double), importer);
+
+            importer = delegate (object input) {
+                return Convert.ToDecimal ((double) input);
+            };
+            RegisterImporter (base_importers_table, typeof (double),
+                              typeof (decimal), importer);
+
+            importer = delegate (object input) {
+                return Convert.ToSingle((double)input);
+            };
+            RegisterImporter(base_importers_table, typeof(double),
+                typeof(float), importer);
+
+            importer = delegate (object input) {
+                return Convert.ToUInt32 ((long) input);
+            };
+            RegisterImporter (base_importers_table, typeof (long),
+                              typeof (uint), importer);
+
+            importer = delegate (object input) {
+                return Convert.ToChar ((string) input);
+            };
+            RegisterImporter (base_importers_table, typeof (string),
+                              typeof (char), importer);
+
+            importer = delegate (object input) {
+                return Convert.ToDateTime ((string) input, datetime_format);
+            };
+            RegisterImporter (base_importers_table, typeof (string),
+                              typeof (DateTime), importer);
+
+            importer = delegate (object input) {
+                return DateTimeOffset.Parse((string)input, datetime_format);
+            };
+            RegisterImporter(base_importers_table, typeof(string),
+                typeof(DateTimeOffset), 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 (
+                    String.Format ("Max allowed object depth reached while " +
+                                   "trying to export from type {0}",
+                                   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 Single)
+            {
+                writer.Write((float)obj);
+                return;
+            }
+
+            if (obj is Int32) {
+                writer.Write ((int) obj);
+                return;
+            }
+
+            if (obj is Boolean) {
+                writer.Write ((bool) obj);
+                return;
+            }
+
+            if (obj is Int64) {
+                writer.Write ((long) obj);
+                return;
+            }
+
+            if (obj is Array) {
+                writer.WriteArrayStart ();
+
+                foreach (object elem in (Array) obj)
+                    WriteValue (elem, writer, writer_is_private, depth + 1);
+
+                writer.WriteArrayEnd ();
+
+                return;
+            }
+
+            if (obj is IList) {
+                writer.WriteArrayStart ();
+                foreach (object elem in (IList) obj)
+                    WriteValue (elem, writer, writer_is_private, depth + 1);
+                writer.WriteArrayEnd ();
+
+                return;
+            }
+
+            if (obj is IDictionary dictionary) {
+                writer.WriteObjectStart ();
+                foreach (DictionaryEntry entry in dictionary) {
+                    var propertyName = entry.Key is string key ?
+                        key
+                        : Convert.ToString(entry.Key, CultureInfo.InvariantCulture);
+                    writer.WritePropertyName (propertyName);
+                    WriteValue (entry.Value, writer, writer_is_private,
+                                depth + 1);
+                }
+                writer.WriteObjectEnd ();
+
+                return;
+            }
+
+            Type obj_type = obj.GetType ();
+
+            // See if there's a custom exporter for the object
+            if (custom_exporters_table.ContainsKey (obj_type)) {
+                ExporterFunc exporter = custom_exporters_table[obj_type];
+                exporter (obj, writer);
+
+                return;
+            }
+
+            // If not, maybe there's a base exporter
+            if (base_exporters_table.ContainsKey (obj_type)) {
+                ExporterFunc exporter = base_exporters_table[obj_type];
+                exporter (obj, writer);
+
+                return;
+            }
+
+            // Last option, let's see if it's an enum
+            if (obj is Enum) {
+                Type e_type = Enum.GetUnderlyingType (obj_type);
+
+                if (e_type == typeof (long))
+                    writer.Write ((long) obj);
+                else if (e_type == typeof (uint))
+                    writer.Write ((uint) obj);
+                else if (e_type == typeof (ulong))
+                    writer.Write ((ulong) obj);
+                else if (e_type == typeof(ushort))
+                    writer.Write ((ushort)obj);
+                else if (e_type == typeof(short))
+                    writer.Write ((short)obj);
+                else if (e_type == typeof(byte))
+                    writer.Write ((byte)obj);
+                else if (e_type == typeof(sbyte))
+                    writer.Write ((sbyte)obj);
+                else
+                    writer.Write ((int) obj);
+
+                return;
+            }
+
+            // Okay, so it looks like the input should be exported as an
+            // object
+            AddTypeProperties (obj_type);
+            IList<PropertyMetadata> props = type_properties[obj_type];
+
+            writer.WriteObjectStart ();
+            foreach (PropertyMetadata p_data in props) {
+                if (p_data.IsField) {
+                    writer.WritePropertyName (p_data.Info.Name);
+                    WriteValue (((FieldInfo) p_data.Info).GetValue (obj),
+                                writer, writer_is_private, depth + 1);
+                }
+                else {
+                    PropertyInfo p_info = (PropertyInfo) p_data.Info;
+
+                    if (p_info.CanRead) {
+                        writer.WritePropertyName (p_data.Info.Name);
+                        WriteValue (p_info.GetValue (obj, null),
+                                    writer, writer_is_private, depth + 1);
+                    }
+                }
+            }
+            writer.WriteObjectEnd ();
+        }
+        #endregion
+
+
+        public static string ToJson (object obj)
+        {
+            lock (static_writer_lock) {
+                static_writer.Reset ();
+
+                WriteValue (obj, static_writer, true, 0);
+
+                return static_writer.ToString ();
+            }
+        }
+
+        public static void ToJson (object obj, JsonWriter writer)
+        {
+            WriteValue (obj, writer, false, 0);
+        }
+
+        public static JsonData ToObject (JsonReader reader)
+        {
+            return (JsonData) ToWrapper (
+                delegate { return new JsonData (); }, reader);
+        }
+
+        public static JsonData ToObject (TextReader reader)
+        {
+            JsonReader json_reader = new JsonReader (reader);
+
+            return (JsonData) ToWrapper (
+                delegate { return new JsonData (); }, json_reader);
+        }
+
+        public static JsonData ToObject (string json)
+        {
+            return (JsonData) ToWrapper (
+                delegate { return new JsonData (); }, json);
+        }
+
+        public static T ToObject<T> (JsonReader reader)
+        {
+            return (T) ReadValue (typeof (T), reader);
+        }
+
+        public static T ToObject<T> (TextReader reader)
+        {
+            JsonReader json_reader = new JsonReader (reader);
+
+            return (T) ReadValue (typeof (T), json_reader);
+        }
+
+        public static T ToObject<T> (string json)
+        {
+            JsonReader reader = new JsonReader (json);
+
+            return (T) ReadValue (typeof (T), reader);
+        }
+
+        public static object ToObject(string json, Type ConvertType )
+        {
+            JsonReader reader = new JsonReader(json);
+
+            return ReadValue(ConvertType, 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 exporter_wrapper =
+                delegate (object obj, JsonWriter writer) {
+                    exporter ((T) obj, writer);
+                };
+
+            custom_exporters_table[typeof (T)] = exporter_wrapper;
+        }
+
+        public static void RegisterImporter<TJson, TValue> (
+            ImporterFunc<TJson, TValue> importer)
+        {
+            ImporterFunc importer_wrapper =
+                delegate (object input) {
+                    return importer ((TJson) input);
+                };
+
+            RegisterImporter (custom_importers_table, typeof (TJson),
+                              typeof (TValue), importer_wrapper);
+        }
+
+        public static void UnregisterExporters ()
+        {
+            custom_exporters_table.Clear ();
+        }
+
+        public static void UnregisterImporters ()
+        {
+            custom_importers_table.Clear ();
+        }
+    }
+}

Assets/Common/LitJson/JsonMapper.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: b2b4a8fd67beec447976745d45a8c487
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Common/LitJson/JsonMockWrapper.cs

@@ -0,0 +1,105 @@
+#region Header
+/**
+ * JsonMockWrapper.cs
+ *   Mock object implementing IJsonWrapper, to facilitate actions like
+ *   skipping data more efficiently.
+ *
+ * The authors disclaim copyright to this source code. For more details, see
+ * the COPYING file included with this distribution.
+ **/
+#endregion
+
+
+using System;
+using System.Collections;
+using System.Collections.Specialized;
+
+
+namespace LitJson
+{
+    public class JsonMockWrapper : IJsonWrapper
+    {
+        public bool IsArray   { get { return false; } }
+        public bool IsBoolean { get { return false; } }
+        public bool IsDouble  { get { return false; } }
+        public bool IsInt     { get { return false; } }
+        public bool IsLong    { get { return false; } }
+        public bool IsObject  { get { return false; } }
+        public bool IsString  { get { return false; } }
+
+        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) {}
+
+
+        bool IList.IsFixedSize { get { return true; } }
+        bool IList.IsReadOnly  { get { return true; } }
+
+        object IList.this[int index] {
+            get { return null; }
+            set {}
+        }
+
+        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)     {}
+
+
+        int    ICollection.Count          { get { return 0; } }
+        bool   ICollection.IsSynchronized { get { return false; } }
+        object ICollection.SyncRoot       { get { return null; } }
+
+        void ICollection.CopyTo (Array array, int index) {}
+
+
+        IEnumerator IEnumerable.GetEnumerator () { return null; }
+
+
+        bool IDictionary.IsFixedSize { get { return true; } }
+        bool IDictionary.IsReadOnly  { get { return true; } }
+
+        ICollection IDictionary.Keys   { get { return null; } }
+        ICollection IDictionary.Values { get { return null; } }
+
+        object IDictionary.this[object key] {
+            get { return null; }
+            set {}
+        }
+
+        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; }
+
+
+        object IOrderedDictionary.this[int idx] {
+            get { return null; }
+            set {}
+        }
+
+        IDictionaryEnumerator IOrderedDictionary.GetEnumerator () {
+            return null;
+        }
+        void IOrderedDictionary.Insert   (int i, object k, object v) {}
+        void IOrderedDictionary.RemoveAt (int i) {}
+    }
+}

Assets/Common/LitJson/JsonMockWrapper.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 9ee110280ce4fa642b2dc680e607098f
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Common/LitJson/JsonReader.cs

@@ -0,0 +1,478 @@
+#region Header
+/**
+ * JsonReader.cs
+ *   Stream-like access to JSON text.
+ *
+ * The authors disclaim copyright to this source code. For more details, see
+ * the COPYING file included with this distribution.
+ **/
+#endregion
+
+
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Text;
+
+
+namespace LitJson
+{
+    public enum JsonToken
+    {
+        None,
+
+        ObjectStart,
+        PropertyName,
+        ObjectEnd,
+
+        ArrayStart,
+        ArrayEnd,
+
+        Int,
+        Long,
+        Double,
+
+        String,
+
+        Boolean,
+        Null
+    }
+
+
+    public class JsonReader
+    {
+        #region Fields
+        private static readonly 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;
+        #endregion
+
+
+        #region Public Properties
+        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 {
+            get { return end_of_input; }
+        }
+
+        public bool EndOfJson {
+            get { return end_of_json; }
+        }
+
+        public JsonToken Token {
+            get { return token; }
+        }
+
+        public object Value {
+            get { return token_value; }
+        }
+        #endregion
+
+
+        #region Constructors
+        static JsonReader ()
+        {
+            parse_table = PopulateParseTable ();
+        }
+
+        public JsonReader (string json_text) :
+            this (new StringReader (json_text), true)
+        {
+        }
+
+        public JsonReader (TextReader reader) :
+            this (reader, 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 ((int) ParserToken.End);
+            automaton_stack.Push ((int) ParserToken.Text);
+
+            lexer = new Lexer (reader);
+
+            end_of_input = false;
+            end_of_json  = false;
+
+            skip_non_members = true;
+
+            this.reader = reader;
+            reader_is_owned = owned;
+        }
+        #endregion
+
+
+        #region Static Methods
+        private static IDictionary<int, IDictionary<int, int[]>> PopulateParseTable ()
+        {
+            // See section A.2. of the manual for details
+            IDictionary<int, IDictionary<int, int[]>> parse_table = new Dictionary<int, IDictionary<int, int[]>> ();
+
+            TableAddRow (parse_table, ParserToken.Array);
+            TableAddCol (parse_table, ParserToken.Array, '[',
+                            '[',
+                            (int) ParserToken.ArrayPrime);
+
+            TableAddRow (parse_table, ParserToken.ArrayPrime);
+            TableAddCol (parse_table, ParserToken.ArrayPrime, '"',
+                            (int) ParserToken.Value,
+
+                            (int) ParserToken.ValueRest,
+                            ']');
+            TableAddCol (parse_table, ParserToken.ArrayPrime, '[',
+                            (int) ParserToken.Value,
+                            (int) ParserToken.ValueRest,
+                            ']');
+            TableAddCol (parse_table, ParserToken.ArrayPrime, ']',
+                            ']');
+            TableAddCol (parse_table, ParserToken.ArrayPrime, '{',
+                            (int) ParserToken.Value,
+                            (int) ParserToken.ValueRest,
+                            ']');
+            TableAddCol (parse_table, ParserToken.ArrayPrime, (int) ParserToken.Number,
+                            (int) ParserToken.Value,
+                            (int) ParserToken.ValueRest,
+                            ']');
+            TableAddCol (parse_table, ParserToken.ArrayPrime, (int) ParserToken.True,
+                            (int) ParserToken.Value,
+                            (int) ParserToken.ValueRest,
+                            ']');
+            TableAddCol (parse_table, ParserToken.ArrayPrime, (int) ParserToken.False,
+                            (int) ParserToken.Value,
+                            (int) ParserToken.ValueRest,
+                            ']');
+            TableAddCol (parse_table, ParserToken.ArrayPrime, (int) ParserToken.Null,
+                            (int) ParserToken.Value,
+                            (int) ParserToken.ValueRest,
+                            ']');
+
+            TableAddRow (parse_table, ParserToken.Object);
+            TableAddCol (parse_table, ParserToken.Object, '{',
+                            '{',
+                            (int) ParserToken.ObjectPrime);
+
+            TableAddRow (parse_table, ParserToken.ObjectPrime);
+            TableAddCol (parse_table, ParserToken.ObjectPrime, '"',
+                            (int) ParserToken.Pair,
+                            (int) ParserToken.PairRest,
+                            '}');
+            TableAddCol (parse_table, ParserToken.ObjectPrime, '}',
+                            '}');
+
+            TableAddRow (parse_table, ParserToken.Pair);
+            TableAddCol (parse_table, ParserToken.Pair, '"',
+                            (int) ParserToken.String,
+                            ':',
+                            (int) ParserToken.Value);
+
+            TableAddRow (parse_table, ParserToken.PairRest);
+            TableAddCol (parse_table, ParserToken.PairRest, ',',
+                            ',',
+                            (int) ParserToken.Pair,
+                            (int) ParserToken.PairRest);
+            TableAddCol (parse_table, ParserToken.PairRest, '}',
+                            (int) ParserToken.Epsilon);
+
+            TableAddRow (parse_table, ParserToken.String);
+            TableAddCol (parse_table, ParserToken.String, '"',
+                            '"',
+                            (int) ParserToken.CharSeq,
+                            '"');
+
+            TableAddRow (parse_table, ParserToken.Text);
+            TableAddCol (parse_table, ParserToken.Text, '[',
+                            (int) ParserToken.Array);
+            TableAddCol (parse_table, ParserToken.Text, '{',
+                            (int) ParserToken.Object);
+
+            TableAddRow (parse_table, ParserToken.Value);
+            TableAddCol (parse_table, ParserToken.Value, '"',
+                            (int) ParserToken.String);
+            TableAddCol (parse_table, ParserToken.Value, '[',
+                            (int) ParserToken.Array);
+            TableAddCol (parse_table, ParserToken.Value, '{',
+                            (int) ParserToken.Object);
+            TableAddCol (parse_table, ParserToken.Value, (int) ParserToken.Number,
+                            (int) ParserToken.Number);
+            TableAddCol (parse_table, ParserToken.Value, (int) ParserToken.True,
+                            (int) ParserToken.True);
+            TableAddCol (parse_table, ParserToken.Value, (int) ParserToken.False,
+                            (int) ParserToken.False);
+            TableAddCol (parse_table, ParserToken.Value, (int) ParserToken.Null,
+                            (int) ParserToken.Null);
+
+            TableAddRow (parse_table, ParserToken.ValueRest);
+            TableAddCol (parse_table, ParserToken.ValueRest, ',',
+                            ',',
+                            (int) ParserToken.Value,
+                            (int) ParserToken.ValueRest);
+            TableAddCol (parse_table, ParserToken.ValueRest, ']',
+                            (int) ParserToken.Epsilon);
+
+            return parse_table;
+        }
+
+        private static void TableAddCol (IDictionary<int, IDictionary<int, int[]>> parse_table, ParserToken row, int col,
+                                         params int[] symbols)
+        {
+            parse_table[(int) row].Add (col, symbols);
+        }
+
+        private static void TableAddRow (IDictionary<int, IDictionary<int, int[]>> parse_table, ParserToken rule)
+        {
+            parse_table.Add ((int) rule, new Dictionary<int, int[]> ());
+        }
+        #endregion
+
+
+        #region Private Methods
+        private void ProcessNumber (string number)
+        {
+            if (number.IndexOf ('.') != -1 ||
+                number.IndexOf ('e') != -1 ||
+                number.IndexOf ('E') != -1) {
+
+                double n_double;
+                if (double.TryParse (number, NumberStyles.Any, CultureInfo.InvariantCulture, out n_double)) {
+                    token = JsonToken.Double;
+                    token_value = n_double;
+
+                    return;
+                }
+            }
+
+            int n_int32;
+            if (int.TryParse (number, NumberStyles.Integer, CultureInfo.InvariantCulture, out n_int32)) {
+                token = JsonToken.Int;
+                token_value = n_int32;
+
+                return;
+            }
+
+            long n_int64;
+            if (long.TryParse (number, NumberStyles.Integer, CultureInfo.InvariantCulture, out n_int64)) {
+                token = JsonToken.Long;
+                token_value = n_int64;
+
+                return;
+            }
+
+            ulong n_uint64;
+            if (ulong.TryParse(number, NumberStyles.Integer, CultureInfo.InvariantCulture, out n_uint64))
+            {
+                token = JsonToken.Long;
+                token_value = n_uint64;
+
+                return;
+            }
+
+            // Shouldn't happen, but just in case, return something
+            token = JsonToken.Int;
+            token_value = 0;
+        }
+
+        private void ProcessSymbol ()
+        {
+            if (current_symbol == '[')  {
+                token = JsonToken.ArrayStart;
+                parser_return = true;
+
+            } else if (current_symbol == ']')  {
+                token = JsonToken.ArrayEnd;
+                parser_return = true;
+
+            } else if (current_symbol == '{')  {
+                token = JsonToken.ObjectStart;
+                parser_return = true;
+
+            } else if (current_symbol == '}')  {
+                token = JsonToken.ObjectEnd;
+                parser_return = true;
+
+            } else if (current_symbol == '"')  {
+                if (parser_in_string) {
+                    parser_in_string = false;
+
+                    parser_return = true;
+
+                } else {
+                    if (token == JsonToken.None)
+                        token = JsonToken.String;
+
+                    parser_in_string = true;
+                }
+
+            } else if (current_symbol == (int) ParserToken.CharSeq) {
+                token_value = lexer.StringValue;
+
+            } else if (current_symbol == (int) ParserToken.False)  {
+                token = JsonToken.Boolean;
+                token_value = false;
+                parser_return = true;
+
+            } else if (current_symbol == (int) ParserToken.Null)  {
+                token = JsonToken.Null;
+                parser_return = true;
+
+            } else if (current_symbol == (int) ParserToken.Number)  {
+                ProcessNumber (lexer.StringValue);
+
+                parser_return = true;
+
+            } else if (current_symbol == (int) ParserToken.Pair)  {
+                token = JsonToken.PropertyName;
+
+            } else if (current_symbol == (int) ParserToken.True)  {
+                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;
+        }
+        #endregion
+
+
+        public void Close ()
+        {
+            if (end_of_input)
+                return;
+
+            end_of_input = true;
+            end_of_json  = true;
+
+            if (reader_is_owned)
+            {
+                using(reader){}
+            }
+
+            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 ((int) ParserToken.End);
+                automaton_stack.Push ((int) ParserToken.Text);
+            }
+
+            parser_in_string = false;
+            parser_return    = false;
+
+            token       = JsonToken.None;
+            token_value = null;
+
+            if (! read_started) {
+                read_started = true;
+
+                if (! ReadToken ())
+                    return false;
+            }
+
+
+            int[] entry_symbols;
+
+            while (true) {
+                if (parser_return) {
+                    if (automaton_stack.Peek () == (int) ParserToken.End)
+                        end_of_json = true;
+
+                    return true;
+                }
+
+                current_symbol = automaton_stack.Pop ();
+
+                ProcessSymbol ();
+
+                if (current_symbol == current_input) {
+                    if (! ReadToken ()) {
+                        if (automaton_stack.Peek () != (int) ParserToken.End)
+                            throw new JsonException (
+                                "Input doesn't evaluate to proper JSON text");
+
+                        if (parser_return)
+                            return true;
+
+                        return false;
+                    }
+
+                    continue;
+                }
+
+                try {
+
+                    entry_symbols =
+                        parse_table[current_symbol][current_input];
+
+                } catch (KeyNotFoundException e) {
+                    throw new JsonException ((ParserToken) current_input, e);
+                }
+
+                if (entry_symbols[0] == (int) ParserToken.Epsilon)
+                    continue;
+
+                for (int i = entry_symbols.Length - 1; i >= 0; i--)
+                    automaton_stack.Push (entry_symbols[i]);
+            }
+        }
+
+    }
+}

Assets/Common/LitJson/JsonReader.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 03591da5264230e409bff392d2d625f8
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Common/LitJson/JsonWriter.cs

@@ -0,0 +1,484 @@
+#region Header
+/**
+ * JsonWriter.cs
+ *   Stream-like facility to output JSON text.
+ *
+ * The authors disclaim copyright to this source code. For more details, see
+ * the COPYING file included with this distribution.
+ **/
+#endregion
+
+
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Text;
+
+
+namespace LitJson
+{
+    internal enum Condition
+    {
+        InArray,
+        InObject,
+        NotAProperty,
+        Property,
+        Value
+    }
+
+    internal class WriterContext
+    {
+        public int  Count;
+        public bool InArray;
+        public bool InObject;
+        public bool ExpectingValue;
+        public int  Padding;
+    }
+
+    public class JsonWriter
+    {
+        #region Fields
+        private static readonly 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 bool                 lower_case_properties;
+        private TextWriter           writer;
+        #endregion
+
+
+        #region Properties
+        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 {
+            get { return writer; }
+        }
+
+        public bool Validate {
+            get { return validate; }
+            set { validate = value; }
+        }
+
+        public bool LowerCaseProperties {
+            get { return lower_case_properties; }
+            set { lower_case_properties = value; }
+        }
+        #endregion
+
+
+        #region Constructors
+        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 ();
+        }
+        #endregion
+
+
+        #region Private Methods
+        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;
+            lower_case_properties = false;
+
+            ctx_stack = new Stack<WriterContext> ();
+            context = new WriterContext ();
+            ctx_stack.Push (context);
+        }
+
+        private static void IntToHex (int n, char[] hex)
+        {
+            int num;
+
+            for (int i = 0; i < 4; i++) {
+                num = n % 16;
+
+                if (num < 10)
+                    hex[3 - i] = (char) ('0' + num);
+                else
+                    hex[3 - i] = (char) ('A' + (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 (true);
+        }
+
+        private void PutNewline (bool add_comma)
+        {
+            if (add_comma && ! context.ExpectingValue &&
+                context.Count > 1)
+                writer.Write (',');
+
+            if (pretty_print && ! context.ExpectingValue)
+                writer.Write (Environment.NewLine);
+        }
+
+        private void PutString (string str)
+        {
+            Put (String.Empty);
+
+            writer.Write ('"');
+
+            int n = str.Length;
+            for (int i = 0; i < n; 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 ((int) str[i] >= 32 && (int) str[i] <= 126) {
+                    writer.Write (str[i]);
+                    continue;
+                }
+
+                // Default, turn into a \uXXXX sequence
+                IntToHex ((int) str[i], hex_seq);
+                writer.Write ("\\u");
+                writer.Write (hex_seq);
+            }
+
+            writer.Write ('"');
+        }
+
+        private void Unindent ()
+        {
+            if (pretty_print)
+                indentation -= indent_value;
+        }
+        #endregion
+
+
+        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 str = Convert.ToString (number, number_format);
+            Put (str);
+
+            if (str.IndexOf ('.') == -1 &&
+                str.IndexOf ('E') == -1)
+                writer.Write (".0");
+
+            context.ExpectingValue = false;
+        }
+
+        public void Write(float number)
+        {
+            DoValidation(Condition.Value);
+            PutNewline();
+
+            string str = Convert.ToString(number, number_format);
+            Put(str);
+
+            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;
+        }
+
+        [CLSCompliant(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 (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 (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 ();
+            string propertyName = (property_name == null || !lower_case_properties)
+                ? property_name
+                : property_name.ToLowerInvariant();
+
+            PutString (propertyName);
+
+            if (pretty_print) {
+                if (propertyName.Length > context.Padding)
+                    context.Padding = propertyName.Length;
+
+                for (int i = context.Padding - propertyName.Length;
+                     i >= 0; i--)
+                    writer.Write (' ');
+
+                writer.Write (": ");
+            } else
+                writer.Write (':');
+
+            context.ExpectingValue = true;
+        }
+    }
+}

Assets/Common/LitJson/JsonWriter.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 5e91a0bcafe7b4349bdea405fc158fc9
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Common/LitJson/Lexer.cs

@@ -0,0 +1,912 @@
+#region Header
+/**
+ * Lexer.cs
+ *   JSON lexer implementation based on a finite state machine.
+ *
+ * The authors disclaim copyright to this source code. For more details, see
+ * the COPYING file included with this distribution.
+ **/
+#endregion
+
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Text;
+
+
+namespace LitJson
+{
+    internal class FsmContext
+    {
+        public bool  Return;
+        public int   NextState;
+        public Lexer L;
+        public int   StateStack;
+    }
+
+
+    internal class Lexer
+    {
+        #region Fields
+        private delegate bool StateHandler (FsmContext ctx);
+
+        private static readonly int[]          fsm_return_table;
+        private static readonly 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;
+        #endregion
+
+
+        #region Properties
+        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 {
+            get { return end_of_input; }
+        }
+
+        public int Token {
+            get { return token; }
+        }
+
+        public string StringValue {
+            get { return string_value; }
+        }
+        #endregion
+
+
+        #region Constructors
+        static Lexer ()
+        {
+            PopulateFsmTables (out fsm_handler_table, out fsm_return_table);
+        }
+
+        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;
+        }
+        #endregion
+
+
+        #region Static Methods
+        private static int HexValue (int digit)
+        {
+            switch (digit) {
+            case 'a':
+            case 'A':
+                return 10;
+
+            case 'b':
+            case 'B':
+                return 11;
+
+            case 'c':
+            case 'C':
+                return 12;
+
+            case 'd':
+            case 'D':
+                return 13;
+
+            case 'e':
+            case 'E':
+                return 14;
+
+            case 'f':
+            case 'F':
+                return 15;
+
+            default:
+                return digit - '0';
+            }
+        }
+
+        private static void PopulateFsmTables (out StateHandler[] fsm_handler_table, out int[] fsm_return_table)
+        {
+            // See section A.1. of the manual for details of the finite
+            // state machine.
+            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] {
+                (int) ParserToken.Char,
+                0,
+                (int) ParserToken.Number,
+                (int) ParserToken.Number,
+                0,
+                (int) ParserToken.Number,
+                0,
+                (int) ParserToken.Number,
+                0,
+                0,
+                (int) ParserToken.True,
+                0,
+                0,
+                0,
+                (int) ParserToken.False,
+                0,
+                0,
+                (int) ParserToken.Null,
+                (int) ParserToken.CharSeq,
+                (int) ParserToken.Char,
+                0,
+                0,
+                (int) ParserToken.CharSeq,
+                (int) ParserToken.Char,
+                0,
+                0,
+                0,
+                0
+            };
+        }
+
+        private static char ProcessEscChar (int esc_char)
+        {
+            switch (esc_char) {
+            case '"':
+            case '\'':
+            case '\\':
+            case '/':
+                return Convert.ToChar (esc_char);
+
+            case 'n':
+                return '\n';
+
+            case 't':
+                return '\t';
+
+            case 'r':
+                return '\r';
+
+            case 'b':
+                return '\b';
+
+            case 'f':
+                return '\f';
+
+            default:
+                // Unreachable
+                return '?';
+            }
+        }
+
+        private static bool State1 (FsmContext ctx)
+        {
+            while (ctx.L.GetChar ()) {
+                if (ctx.L.input_char == ' ' ||
+                    ctx.L.input_char >= '\t' && ctx.L.input_char <= '\r')
+                    continue;
+
+                if (ctx.L.input_char >= '1' && ctx.L.input_char <= '9') {
+                    ctx.L.string_buffer.Append ((char) ctx.L.input_char);
+                    ctx.NextState = 3;
+                    return true;
+                }
+
+                switch (ctx.L.input_char) {
+                case '"':
+                    ctx.NextState = 19;
+                    ctx.Return = true;
+                    return true;
+
+                case ',':
+                case ':':
+                case '[':
+                case ']':
+                case '{':
+                case '}':
+                    ctx.NextState = 1;
+                    ctx.Return = true;
+                    return true;
+
+                case '-':
+                    ctx.L.string_buffer.Append ((char) ctx.L.input_char);
+                    ctx.NextState = 2;
+                    return true;
+
+                case '0':
+                    ctx.L.string_buffer.Append ((char) ctx.L.input_char);
+                    ctx.NextState = 4;
+                    return true;
+
+                case 'f':
+                    ctx.NextState = 12;
+                    return true;
+
+                case 'n':
+                    ctx.NextState = 16;
+                    return true;
+
+                case 't':
+                    ctx.NextState = 9;
+                    return true;
+
+                case '\'':
+                    if (! ctx.L.allow_single_quoted_strings)
+                        return false;
+
+                    ctx.L.input_char = '"';
+                    ctx.NextState = 23;
+                    ctx.Return = true;
+                    return true;
+
+                case '/':
+                    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 >= '1' && ctx.L.input_char<= '9') {
+                ctx.L.string_buffer.Append ((char) ctx.L.input_char);
+                ctx.NextState = 3;
+                return true;
+            }
+
+            switch (ctx.L.input_char) {
+            case '0':
+                ctx.L.string_buffer.Append ((char) ctx.L.input_char);
+                ctx.NextState = 4;
+                return true;
+
+            default:
+                return false;
+            }
+        }
+
+        private static bool State3 (FsmContext ctx)
+        {
+            while (ctx.L.GetChar ()) {
+                if (ctx.L.input_char >= '0' && ctx.L.input_char <= '9') {
+                    ctx.L.string_buffer.Append ((char) ctx.L.input_char);
+                    continue;
+                }
+
+                if (ctx.L.input_char == ' ' ||
+                    ctx.L.input_char >= '\t' && ctx.L.input_char <= '\r') {
+                    ctx.Return = true;
+                    ctx.NextState = 1;
+                    return true;
+                }
+
+                switch (ctx.L.input_char) {
+                case ',':
+                case ']':
+                case '}':
+                    ctx.L.UngetChar ();
+                    ctx.Return = true;
+                    ctx.NextState = 1;
+                    return true;
+
+                case '.':
+                    ctx.L.string_buffer.Append ((char) ctx.L.input_char);
+                    ctx.NextState = 5;
+                    return true;
+
+                case 'e':
+                case 'E':
+                    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 == ' ' ||
+                ctx.L.input_char >= '\t' && ctx.L.input_char <= '\r') {
+                ctx.Return = true;
+                ctx.NextState = 1;
+                return true;
+            }
+
+            switch (ctx.L.input_char) {
+            case ',':
+            case ']':
+            case '}':
+                ctx.L.UngetChar ();
+                ctx.Return = true;
+                ctx.NextState = 1;
+                return true;
+
+            case '.':
+                ctx.L.string_buffer.Append ((char) ctx.L.input_char);
+                ctx.NextState = 5;
+                return true;
+
+            case 'e':
+            case 'E':
+                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 >= '0' && ctx.L.input_char <= '9') {
+                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 >= '0' && ctx.L.input_char <= '9') {
+                    ctx.L.string_buffer.Append ((char) ctx.L.input_char);
+                    continue;
+                }
+
+                if (ctx.L.input_char == ' ' ||
+                    ctx.L.input_char >= '\t' && ctx.L.input_char <= '\r') {
+                    ctx.Return = true;
+                    ctx.NextState = 1;
+                    return true;
+                }
+
+                switch (ctx.L.input_char) {
+                case ',':
+                case ']':
+                case '}':
+                    ctx.L.UngetChar ();
+                    ctx.Return = true;
+                    ctx.NextState = 1;
+                    return true;
+
+                case 'e':
+                case 'E':
+                    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 >= '0' && ctx.L.input_char<= '9') {
+                ctx.L.string_buffer.Append ((char) ctx.L.input_char);
+                ctx.NextState = 8;
+                return true;
+            }
+
+            switch (ctx.L.input_char) {
+            case '+':
+            case '-':
+                ctx.L.string_buffer.Append ((char) ctx.L.input_char);
+                ctx.NextState = 8;
+                return true;
+
+            default:
+                return false;
+            }
+        }
+
+        private static bool State8 (FsmContext ctx)
+        {
+            while (ctx.L.GetChar ()) {
+                if (ctx.L.input_char >= '0' && ctx.L.input_char<= '9') {
+                    ctx.L.string_buffer.Append ((char) ctx.L.input_char);
+                    continue;
+                }
+
+                if (ctx.L.input_char == ' ' ||
+                    ctx.L.input_char >= '\t' && ctx.L.input_char<= '\r') {
+                    ctx.Return = true;
+                    ctx.NextState = 1;
+                    return true;
+                }
+
+                switch (ctx.L.input_char) {
+                case ',':
+                case ']':
+                case '}':
+                    ctx.L.UngetChar ();
+                    ctx.Return = true;
+                    ctx.NextState = 1;
+                    return true;
+
+                default:
+                    return false;
+                }
+            }
+
+            return true;
+        }
+
+        private static bool State9 (FsmContext ctx)
+        {
+            ctx.L.GetChar ();
+
+            switch (ctx.L.input_char) {
+            case 'r':
+                ctx.NextState = 10;
+                return true;
+
+            default:
+                return false;
+            }
+        }
+
+        private static bool State10 (FsmContext ctx)
+        {
+            ctx.L.GetChar ();
+
+            switch (ctx.L.input_char) {
+            case 'u':
+                ctx.NextState = 11;
+                return true;
+
+            default:
+                return false;
+            }
+        }
+
+        private static bool State11 (FsmContext ctx)
+        {
+            ctx.L.GetChar ();
+
+            switch (ctx.L.input_char) {
+            case 'e':
+                ctx.Return = true;
+                ctx.NextState = 1;
+                return true;
+
+            default:
+                return false;
+            }
+        }
+
+        private static bool State12 (FsmContext ctx)
+        {
+            ctx.L.GetChar ();
+
+            switch (ctx.L.input_char) {
+            case 'a':
+                ctx.NextState = 13;
+                return true;
+
+            default:
+                return false;
+            }
+        }
+
+        private static bool State13 (FsmContext ctx)
+        {
+            ctx.L.GetChar ();
+
+            switch (ctx.L.input_char) {
+            case 'l':
+                ctx.NextState = 14;
+                return true;
+
+            default:
+                return false;
+            }
+        }
+
+        private static bool State14 (FsmContext ctx)
+        {
+            ctx.L.GetChar ();
+
+            switch (ctx.L.input_char) {
+            case 's':
+                ctx.NextState = 15;
+                return true;
+
+            default:
+                return false;
+            }
+        }
+
+        private static bool State15 (FsmContext ctx)
+        {
+            ctx.L.GetChar ();
+
+            switch (ctx.L.input_char) {
+            case 'e':
+                ctx.Return = true;
+                ctx.NextState = 1;
+                return true;
+
+            default:
+                return false;
+            }
+        }
+
+        private static bool State16 (FsmContext ctx)
+        {
+            ctx.L.GetChar ();
+
+            switch (ctx.L.input_char) {
+            case 'u':
+                ctx.NextState = 17;
+                return true;
+
+            default:
+                return false;
+            }
+        }
+
+        private static bool State17 (FsmContext ctx)
+        {
+            ctx.L.GetChar ();
+
+            switch (ctx.L.input_char) {
+            case 'l':
+                ctx.NextState = 18;
+                return true;
+
+            default:
+                return false;
+            }
+        }
+
+        private static bool State18 (FsmContext ctx)
+        {
+            ctx.L.GetChar ();
+
+            switch (ctx.L.input_char) {
+            case 'l':
+                ctx.Return = true;
+                ctx.NextState = 1;
+                return true;
+
+            default:
+                return false;
+            }
+        }
+
+        private static bool State19 (FsmContext ctx)
+        {
+            while (ctx.L.GetChar ()) {
+                switch (ctx.L.input_char) {
+                case '"':
+                    ctx.L.UngetChar ();
+                    ctx.Return = true;
+                    ctx.NextState = 20;
+                    return true;
+
+                case '\\':
+                    ctx.StateStack = 19;
+                    ctx.NextState = 21;
+                    return true;
+
+                default:
+                    ctx.L.string_buffer.Append ((char) ctx.L.input_char);
+                    continue;
+                }
+            }
+
+            return true;
+        }
+
+        private static bool State20 (FsmContext ctx)
+        {
+            ctx.L.GetChar ();
+
+            switch (ctx.L.input_char) {
+            case '"':
+                ctx.Return = true;
+                ctx.NextState = 1;
+                return true;
+
+            default:
+                return false;
+            }
+        }
+
+        private static bool State21 (FsmContext ctx)
+        {
+            ctx.L.GetChar ();
+
+            switch (ctx.L.input_char) {
+            case 'u':
+                ctx.NextState = 22;
+                return true;
+
+            case '"':
+            case '\'':
+            case '/':
+            case '\\':
+            case 'b':
+            case 'f':
+            case 'n':
+            case 'r':
+            case 't':
+                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 counter = 0;
+            int mult    = 4096;
+
+            ctx.L.unichar = 0;
+
+            while (ctx.L.GetChar ()) {
+
+                if (ctx.L.input_char >= '0' && ctx.L.input_char <= '9' ||
+                    ctx.L.input_char >= 'A' && ctx.L.input_char <= 'F' ||
+                    ctx.L.input_char >= 'a' && ctx.L.input_char <= 'f') {
+
+                    ctx.L.unichar += HexValue (ctx.L.input_char) * mult;
+
+                    counter++;
+                    mult /= 16;
+
+                    if (counter == 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 '\'':
+                    ctx.L.UngetChar ();
+                    ctx.Return = true;
+                    ctx.NextState = 24;
+                    return true;
+
+                case '\\':
+                    ctx.StateStack = 23;
+                    ctx.NextState = 21;
+                    return true;
+
+                default:
+                    ctx.L.string_buffer.Append ((char) ctx.L.input_char);
+                    continue;
+                }
+            }
+
+            return true;
+        }
+
+        private static bool State24 (FsmContext ctx)
+        {
+            ctx.L.GetChar ();
+
+            switch (ctx.L.input_char) {
+            case '\'':
+                ctx.L.input_char = '"';
+                ctx.Return = true;
+                ctx.NextState = 1;
+                return true;
+
+            default:
+                return false;
+            }
+        }
+
+        private static bool State25 (FsmContext ctx)
+        {
+            ctx.L.GetChar ();
+
+            switch (ctx.L.input_char) {
+            case '*':
+                ctx.NextState = 27;
+                return true;
+
+            case '/':
+                ctx.NextState = 26;
+                return true;
+
+            default:
+                return false;
+            }
+        }
+
+        private static bool State26 (FsmContext ctx)
+        {
+            while (ctx.L.GetChar ()) {
+                if (ctx.L.input_char == '\n') {
+                    ctx.NextState = 1;
+                    return true;
+                }
+            }
+
+            return true;
+        }
+
+        private static bool State27 (FsmContext ctx)
+        {
+            while (ctx.L.GetChar ()) {
+                if (ctx.L.input_char == '*') {
+                    ctx.NextState = 28;
+                    return true;
+                }
+            }
+
+            return true;
+        }
+
+        private static bool State28 (FsmContext ctx)
+        {
+            while (ctx.L.GetChar ()) {
+                if (ctx.L.input_char == '*')
+                    continue;
+
+                if (ctx.L.input_char == '/') {
+                    ctx.NextState = 1;
+                    return true;
+                }
+
+                ctx.NextState = 27;
+                return true;
+            }
+
+            return true;
+        }
+        #endregion
+
+
+        private bool GetChar ()
+        {
+            if ((input_char = NextChar ()) != -1)
+                return true;
+
+            end_of_input = true;
+            return false;
+        }
+
+        private int NextChar ()
+        {
+            if (input_buffer != 0) {
+                int tmp = input_buffer;
+                input_buffer = 0;
+
+                return tmp;
+            }
+
+            return reader.Read ();
+        }
+
+        public bool NextToken ()
+        {
+            StateHandler handler;
+            fsm_context.Return = false;
+
+            while (true) {
+                handler = fsm_handler_table[state - 1];
+
+                if (! handler (fsm_context))
+                    throw new JsonException (input_char);
+
+                if (end_of_input)
+                    return false;
+
+                if (fsm_context.Return) {
+                    string_value = string_buffer.ToString ();
+                    string_buffer.Remove (0, string_buffer.Length);
+                    token = fsm_return_table[state - 1];
+
+                    if (token == (int) ParserToken.Char)
+                        token = input_char;
+
+                    state = fsm_context.NextState;
+
+                    return true;
+                }
+
+                state = fsm_context.NextState;
+            }
+        }
+
+        private void UngetChar ()
+        {
+            input_buffer = input_char;
+        }
+    }
+}

Assets/Common/LitJson/Lexer.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: bca80ccad08fde346a8a3a54f8bf7207
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Common/LitJson/LitJSON.csproj.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 97df6c516e61fef4aa6b060b51dc7403
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Common/LitJson/Netstandard15Polyfill.cs

@@ -0,0 +1,24 @@
+#if NETSTANDARD1_5
+using System;
+using System.Reflection;
+namespace LitJson
+{
+    internal static class Netstandard15Polyfill
+    {
+        internal static Type GetInterface(this Type type, string name)
+        {
+            return type.GetTypeInfo().GetInterface(name); 
+        }
+
+        internal static bool IsClass(this Type type)
+        {
+            return type.GetTypeInfo().IsClass;
+        }
+
+        internal static bool IsEnum(this Type type)
+        {
+            return type.GetTypeInfo().IsEnum;
+        }
+    }
+}
+#endif

Assets/Common/LitJson/Netstandard15Polyfill.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 459a59abd2fe6e34e81a93a6e5f56047
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Common/LitJson/ParserToken.cs

@@ -0,0 +1,44 @@
+#region Header
+/**
+ * ParserToken.cs
+ *   Internal representation of the tokens used by the lexer and the parser.
+ *
+ * The authors disclaim copyright to this source code. For more details, see
+ * the COPYING file included with this distribution.
+ **/
+#endregion
+
+
+namespace LitJson
+{
+    internal enum ParserToken
+    {
+        // Lexer tokens (see section A.1.1. of the manual)
+        None = System.Char.MaxValue + 1,
+        Number,
+        True,
+        False,
+        Null,
+        CharSeq,
+        // Single char
+        Char,
+
+        // Parser Rules (see section A.2.1 of the manual)
+        Text,
+        Object,
+        ObjectPrime,
+        Pair,
+        PairRest,
+        Array,
+        ArrayPrime,
+        Value,
+        ValueRest,
+        String,
+
+        // End of input
+        End,
+
+        // The empty rule
+        Epsilon
+    }
+}

Assets/Common/LitJson/ParserToken.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: c43f4b988234ae3419e0ff589f1f26e2
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Common/LitJson/litjson.png.meta

@@ -0,0 +1,92 @@
+fileFormatVersion: 2
+guid: 48ec93ecdc9a7554f874eb3e5dee22bb
+TextureImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 11
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 1
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: -1
+    aniso: -1
+    mipBias: -100
+    wrapU: -1
+    wrapV: -1
+    wrapW: -1
+  nPOTScale: 1
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spritePixelsToUnits: 100
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spriteGenerateFallbackPhysicsShape: 1
+  alphaUsage: 1
+  alphaIsTransparency: 0
+  spriteTessellationDetail: -1
+  textureType: 0
+  textureShape: 1
+  singleChannelComponent: 0
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  applyGammaDecoding: 0
+  platformSettings:
+  - serializedVersion: 3
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+    forceMaximumCompressionQuality_BC6H_BC7: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+    bones: []
+    spriteID: 
+    internalID: 0
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+    secondaryTextures: []
+  spritePackingTag: 
+  pSDRemoveMatte: 0
+  pSDShowRemoveMatteOption: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Common/Plugin.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: d5250627ad4bc0341967c303f560a8d4
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Common/Plugin/JsonDotNet.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: a4e331a819854c54b8526eb6203c170c
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Common/Plugin/JsonDotNet/Assemblies.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 577d9725f58264943855b8ac185531fe
+folderAsset: yes
+timeCreated: 1466788344
+licenseType: Store
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Common/Plugin/JsonDotNet/Assemblies/AOT.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 14f21d7a1e53a8c4e87b25526a7eb63c
+folderAsset: yes
+timeCreated: 1466788345
+licenseType: Store
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Common/Plugin/JsonDotNet/Assemblies/AOT/Newtonsoft.Json.XML.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: aadad8ac54f29e44583510294ac5c312
+timeCreated: 1466788355
+licenseType: Store
+TextScriptImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Common/Plugin/JsonDotNet/Assemblies/AOT/Newtonsoft.Json.dll.meta

@@ -0,0 +1,76 @@
+fileFormatVersion: 2
+guid: 6a3c684705042f345975d924f6983e36
+timeCreated: 1466788352
+licenseType: Store
+PluginImporter:
+  serializedVersion: 1
+  iconMap: {}
+  executionOrder: {}
+  isPreloaded: 0
+  platformData:
+    Android:
+      enabled: 1
+      settings:
+        CPU: AnyCPU
+    Any:
+      enabled: 0
+      settings: {}
+    Editor:
+      enabled: 0
+      settings:
+        CPU: AnyCPU
+        DefaultValueInitialized: true
+        OS: AnyOS
+    Linux:
+      enabled: 0
+      settings:
+        CPU: x86
+    Linux64:
+      enabled: 0
+      settings:
+        CPU: x86_64
+    OSXIntel:
+      enabled: 0
+      settings:
+        CPU: AnyCPU
+    OSXIntel64:
+      enabled: 0
+      settings:
+        CPU: AnyCPU
+    SamsungTV:
+      enabled: 1
+      settings:
+        STV_MODEL: STANDARD_13
+    Tizen:
+      enabled: 1
+      settings: {}
+    WebGL:
+      enabled: 1
+      settings: {}
+    Win:
+      enabled: 0
+      settings:
+        CPU: AnyCPU
+    Win64:
+      enabled: 0
+      settings:
+        CPU: AnyCPU
+    WindowsStoreApps:
+      enabled: 1
+      settings:
+        CPU: AnyCPU
+        DontProcess: False
+        PlaceholderPath: Assets/JsonDotNet/Assemblies/Standalone/Newtonsoft.Json.dll
+        SDK: AnySDK
+        ScriptingBackend: Il2Cpp
+    iOS:
+      enabled: 1
+      settings:
+        CompileFlags: 
+        FrameworkDependencies: 
+    tvOS:
+      enabled: 1
+      settings: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Common/Plugin/JsonDotNet/Assemblies/Standalone.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 01ef782d02bb1994dbe418b69432552b
+folderAsset: yes
+timeCreated: 1466788344
+licenseType: Store
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Common/Plugin/JsonDotNet/Assemblies/Standalone/Newtonsoft.Json.XML.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: d6807fedb8dcaf04682d2c84f0ab753f
+timeCreated: 1466788355
+licenseType: Store
+TextScriptImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Common/Plugin/JsonDotNet/Assemblies/Standalone/Newtonsoft.Json.dll.meta

@@ -0,0 +1,75 @@
+fileFormatVersion: 2
+guid: 17aef65a15b471f468b5fbeb4ff0c6a1
+timeCreated: 1466788349
+licenseType: Store
+PluginImporter:
+  serializedVersion: 1
+  iconMap: {}
+  executionOrder: {}
+  isPreloaded: 0
+  platformData:
+    Android:
+      enabled: 0
+      settings:
+        CPU: AnyCPU
+    Any:
+      enabled: 0
+      settings: {}
+    Editor:
+      enabled: 1
+      settings:
+        CPU: AnyCPU
+        DefaultValueInitialized: true
+        OS: AnyOS
+    Linux:
+      enabled: 1
+      settings:
+        CPU: x86
+    Linux64:
+      enabled: 1
+      settings:
+        CPU: x86_64
+    LinuxUniversal:
+      enabled: 1
+      settings:
+        CPU: AnyCPU
+    OSXIntel:
+      enabled: 1
+      settings:
+        CPU: AnyCPU
+    OSXIntel64:
+      enabled: 1
+      settings:
+        CPU: AnyCPU
+    OSXUniversal:
+      enabled: 1
+      settings:
+        CPU: AnyCPU
+    SamsungTV:
+      enabled: 0
+      settings:
+        STV_MODEL: STANDARD_13
+    Win:
+      enabled: 1
+      settings:
+        CPU: AnyCPU
+    Win64:
+      enabled: 1
+      settings:
+        CPU: AnyCPU
+    WindowsStoreApps:
+      enabled: 0
+      settings:
+        CPU: AnyCPU
+        DontProcess: False
+        PlaceholderPath: 
+        SDK: AnySDK
+        ScriptingBackend: Il2Cpp
+    iOS:
+      enabled: 0
+      settings:
+        CompileFlags: 
+        FrameworkDependencies: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Common/Plugin/JsonDotNet/Assemblies/Windows.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 1418141139a6ac443b18cb05c0643a29
+folderAsset: yes
+timeCreated: 1466788345
+licenseType: Store
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Common/Plugin/JsonDotNet/Assemblies/Windows/Newtonsoft.Json.XML.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 36f7323c55864364d8bb88c736e4bca6
+timeCreated: 1466788355
+licenseType: Store
+TextScriptImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Common/Plugin/JsonDotNet/Assemblies/Windows/Newtonsoft.Json.dll.meta

@@ -0,0 +1,67 @@
+fileFormatVersion: 2
+guid: 9b6ba260dada0ea4a871a42011f8b87d
+timeCreated: 1466788355
+licenseType: Store
+PluginImporter:
+  serializedVersion: 1
+  iconMap: {}
+  executionOrder: {}
+  isPreloaded: 0
+  platformData:
+    Android:
+      enabled: 0
+      settings:
+        CPU: AnyCPU
+    Any:
+      enabled: 0
+      settings: {}
+    Editor:
+      enabled: 0
+      settings:
+        CPU: AnyCPU
+        DefaultValueInitialized: true
+        OS: AnyOS
+    Linux:
+      enabled: 0
+      settings:
+        CPU: x86
+    Linux64:
+      enabled: 0
+      settings:
+        CPU: x86_64
+    OSXIntel:
+      enabled: 0
+      settings:
+        CPU: AnyCPU
+    OSXIntel64:
+      enabled: 0
+      settings:
+        CPU: AnyCPU
+    SamsungTV:
+      enabled: 0
+      settings:
+        STV_MODEL: STANDARD_13
+    Win:
+      enabled: 0
+      settings:
+        CPU: AnyCPU
+    Win64:
+      enabled: 0
+      settings:
+        CPU: AnyCPU
+    WindowsStoreApps:
+      enabled: 1
+      settings:
+        CPU: AnyCPU
+        DontProcess: False
+        PlaceholderPath: Assets/JsonDotNet/Assemblies/Standalone/Newtonsoft.Json.dll
+        SDK: AnySDK
+        ScriptingBackend: DotNet
+    iOS:
+      enabled: 0
+      settings:
+        CompileFlags: 
+        FrameworkDependencies: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Common/Plugin/JsonDotNet/Documentation.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 76f828f47ce26cc43991113c6a39dbbf
+folderAsset: yes
+timeCreated: 1466010535
+licenseType: Store
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Common/Plugin/JsonDotNet/Documentation/Json Net for Unity 2.0.1.pdf.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 4e7d9a07cc3f02a41a575406e7230846
+timeCreated: 1466788421
+licenseType: Store
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Common/Plugin/JsonDotNet/JsonDotNet201Source.zip.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 9a6f8c7c1ea72ce46831c5e1b6150d0c
+timeCreated: 1466790933
+licenseType: Store
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Common/Plugin/JsonDotNet/link.xml

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="utf-8" ?>
+<linker>
+  <assembly fullname="System">
+    <type fullname="System.ComponentModel.TypeConverter" preserve="all" />
+    <!-- <namespace fullname="System.ComponentModel" preserve="all" /> -->
+  </assembly>
+</linker>

Assets/Common/Plugin/JsonDotNet/link.xml.meta

@@ -0,0 +1,6 @@
+fileFormatVersion: 2
+guid: 06314f49bdda26043963578d60a0a7ee
+TextScriptImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Common/Plugin/JsonNetSample.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 367b6b3470280694e8a9c02b6a1ddb5d
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Common/Plugin/JsonNetSample/JsonNetSample.cs

@@ -0,0 +1,174 @@
+using System;
+using UnityEngine;
+using UnityEngine.UI;
+using System.Collections.Generic;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+
+public class JsonNetSample : MonoBehaviour
+{
+    public Text Output;
+
+    void Start()
+    {
+        Output.text = "Start!\n\n";
+
+        TestJson();
+        SerailizeJson();
+        DeserializeJson();
+        LinqToJson();
+        JsonPath();
+
+        WriteLine("\nDone!");
+    }
+
+    void WriteLine(string msg)
+    {
+        Output.text = Output.text + msg + "\n";
+    }
+
+    public class Product
+    {
+        public string Name;
+        public DateTime ExpiryDate = new DateTime(2000, 1, 1, 0, 0, 0, DateTimeKind.Utc);
+        public decimal Price;
+        public string[] Sizes;
+
+        public override bool Equals(object obj)
+        {
+            if (obj is Product)
+            {
+                Product p = (Product)obj;
+
+                return (p.Name == Name && p.ExpiryDate == ExpiryDate && p.Price == Price);
+            }
+
+            return base.Equals(obj);
+        }
+
+        public override int GetHashCode()
+        {
+            return (Name ?? string.Empty).GetHashCode();
+        }
+    }
+
+    [System.Serializable]
+    public class CharacterListItem
+    {
+        public int Id { get; set; }
+        public string Name { get; set; }
+        public int Level { get; set; }
+        public string Class { get; set; }
+        public string Sex { get; set; }
+    }
+
+    void TestJson()
+    {
+        WriteLine("* TestJson");
+        var json = "{\"Id\":51, \"Name\":\"padre\", \"Level\":0, \"Class\":\"Vampire\", \"Sex\":\"F\"}";
+        var c = JsonConvert.DeserializeObject<CharacterListItem>(json);
+        WriteLine(c.Id + " " + c.Name);
+    }
+
+    void SerailizeJson()
+    {
+        WriteLine("* SerailizeJson");
+
+        Product product = new Product();
+        product.Name = "Apple";
+        product.ExpiryDate = new DateTime(2008, 12, 28);
+        product.Sizes = new string[] { "Small" };
+
+        string json = JsonConvert.SerializeObject(product);
+        WriteLine(json);
+    }
+
+    public class Movie
+    {
+        public string Name { get; set; }
+        public string Description { get; set; }
+        public string Classification { get; set; }
+        public string Studio { get; set; }
+        public DateTime? ReleaseDate { get; set; }
+        public List<string> ReleaseCountries { get; set; }
+    }
+
+    void DeserializeJson()
+    {
+        WriteLine("* DeserializeJson");
+
+        string json = @"{
+          'Name': 'Bad Boys',
+          'ReleaseDate': '1995-4-7T00:00:00',
+          'Genres': [
+            'Action',
+            'Comedy'
+          ]
+        }";
+
+        Movie m = JsonConvert.DeserializeObject<Movie>(json);
+
+        string name = m.Name;
+        WriteLine(name);
+    }
+
+    void LinqToJson()
+    {
+        WriteLine("* LinqToJson");
+
+        JArray array = new JArray();
+        array.Add("Manual text");
+        array.Add(new DateTime(2000, 5, 23));
+
+        JObject o = new JObject();
+        o["MyArray"] = array;
+
+        string json = o.ToString();
+        WriteLine(json);
+    }
+
+    private void JsonPath()
+    {
+        WriteLine("* JsonPath");
+
+        var o = JObject.Parse(@"{
+            'Stores': [
+            'Lambton Quay',
+            'Willis Street'
+            ],
+            'Manufacturers': [
+            {
+                'Name': 'Acme Co',
+                'Products': [
+                {
+                    'Name': 'Anvil',
+                    'Price': 50
+                }
+                ]
+            },
+            {
+                'Name': 'Contoso',
+                'Products': [
+                {
+                    'Name': 'Elbow Grease',
+                    'Price': 99.95
+                },
+                {
+                    'Name': 'Headlight Fluid',
+                    'Price': 4
+                }
+                ]
+            }
+            ]
+        }");
+
+        JToken acme = o.SelectToken("$.Manufacturers[?(@.Name == 'Acme Co')]");
+        WriteLine(acme.ToString());
+
+        IEnumerable<JToken> pricyProducts = o.SelectTokens("$..Products[?(@.Price >= 50)].Name");
+        foreach (var item in pricyProducts)
+        {
+            WriteLine(item.ToString());
+        }
+    }
+}

Assets/Common/Plugin/JsonNetSample/JsonNetSample.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: be6c91d61e2ba1e488c4a44c69ffeeb2
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Common/Plugin/JsonNetSample/JsonNetSample.unity

@@ -0,0 +1,469 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!29 &1
+SceneSettings:
+  m_ObjectHideFlags: 0
+  m_PVSData: 
+  m_PVSObjectsArray: []
+  m_PVSPortalsArray: []
+  m_OcclusionBakeSettings:
+    smallestOccluder: 5
+    smallestHole: 0.25
+    backfaceThreshold: 100
+--- !u!104 &2
+RenderSettings:
+  m_ObjectHideFlags: 0
+  serializedVersion: 6
+  m_Fog: 0
+  m_FogColor: {r: 0.5, g: 0.5, b: 0.5, a: 1}
+  m_FogMode: 3
+  m_FogDensity: 0.01
+  m_LinearFogStart: 0
+  m_LinearFogEnd: 300
+  m_AmbientSkyColor: {r: 0.212, g: 0.227, b: 0.259, a: 1}
+  m_AmbientEquatorColor: {r: 0.114, g: 0.125, b: 0.133, a: 1}
+  m_AmbientGroundColor: {r: 0.047, g: 0.043, b: 0.035, a: 1}
+  m_AmbientIntensity: 1
+  m_AmbientMode: 3
+  m_SkyboxMaterial: {fileID: 0}
+  m_HaloStrength: 0.5
+  m_FlareStrength: 1
+  m_FlareFadeSpeed: 3
+  m_HaloTexture: {fileID: 0}
+  m_SpotCookie: {fileID: 10001, guid: 0000000000000000e000000000000000, type: 0}
+  m_DefaultReflectionMode: 0
+  m_DefaultReflectionResolution: 128
+  m_ReflectionBounces: 1
+  m_ReflectionIntensity: 1
+  m_CustomReflection: {fileID: 0}
+  m_Sun: {fileID: 0}
+--- !u!157 &3
+LightmapSettings:
+  m_ObjectHideFlags: 0
+  serializedVersion: 6
+  m_GIWorkflowMode: 1
+  m_LightmapsMode: 1
+  m_GISettings:
+    serializedVersion: 2
+    m_BounceScale: 1
+    m_IndirectOutputScale: 1
+    m_AlbedoBoost: 1
+    m_TemporalCoherenceThreshold: 1
+    m_EnvironmentLightingMode: 0
+    m_EnableBakedLightmaps: 0
+    m_EnableRealtimeLightmaps: 0
+  m_LightmapEditorSettings:
+    serializedVersion: 3
+    m_Resolution: 2
+    m_BakeResolution: 40
+    m_TextureWidth: 1024
+    m_TextureHeight: 1024
+    m_AOMaxDistance: 1
+    m_Padding: 2
+    m_CompAOExponent: 0
+    m_LightmapParameters: {fileID: 0}
+    m_TextureCompression: 1
+    m_FinalGather: 0
+    m_FinalGatherRayCount: 1024
+    m_ReflectionCompression: 2
+  m_LightingDataAsset: {fileID: 0}
+  m_RuntimeCPUUsage: 25
+--- !u!196 &4
+NavMeshSettings:
+  serializedVersion: 2
+  m_ObjectHideFlags: 0
+  m_BuildSettings:
+    serializedVersion: 2
+    agentRadius: 0.5
+    agentHeight: 2
+    agentSlope: 45
+    agentClimb: 0.4
+    ledgeDropHeight: 0
+    maxJumpAcrossDistance: 0
+    accuratePlacement: 0
+    minRegionArea: 2
+    cellSize: 0.16666667
+    manualCellSize: 0
+  m_NavMeshData: {fileID: 0}
+--- !u!1 &17972762
+GameObject:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  serializedVersion: 4
+  m_Component:
+  - 4: {fileID: 17972763}
+  - 114: {fileID: 17972764}
+  m_Layer: 0
+  m_Name: _SceneObject
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!4 &17972763
+Transform:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 17972762}
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+  m_Children: []
+  m_Father: {fileID: 0}
+  m_RootOrder: 0
+--- !u!114 &17972764
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 17972762}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 5f30dac2bcee81e4c8d946311b78cad6, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  Output: {fileID: 383421098}
+--- !u!1 &383421096
+GameObject:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  serializedVersion: 4
+  m_Component:
+  - 224: {fileID: 383421097}
+  - 222: {fileID: 383421099}
+  - 114: {fileID: 383421098}
+  - 114: {fileID: 383421100}
+  m_Layer: 5
+  m_Name: Output
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!224 &383421097
+RectTransform:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 383421096}
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+  m_Children: []
+  m_Father: {fileID: 2126236432}
+  m_RootOrder: 0
+  m_AnchorMin: {x: 0, y: 0}
+  m_AnchorMax: {x: 1, y: 1}
+  m_AnchoredPosition: {x: 0, y: 0}
+  m_SizeDelta: {x: 0, y: 0}
+  m_Pivot: {x: 0.5, y: 0.5}
+--- !u!114 &383421098
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 383421096}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 708705254, guid: f5f67c52d1564df4a8936ccd202a3bd8, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_Material: {fileID: 0}
+  m_Color: {r: 1, g: 1, b: 1, a: 1}
+  m_RaycastTarget: 1
+  m_OnCullStateChanged:
+    m_PersistentCalls:
+      m_Calls: []
+    m_TypeName: UnityEngine.UI.MaskableGraphic+CullStateChangedEvent, UnityEngine.UI,
+      Version=1.0.0.0, Culture=neutral, PublicKeyToken=null
+  m_FontData:
+    m_Font: {fileID: 10102, guid: 0000000000000000e000000000000000, type: 0}
+    m_FontSize: 12
+    m_FontStyle: 0
+    m_BestFit: 0
+    m_MinSize: 10
+    m_MaxSize: 40
+    m_Alignment: 0
+    m_AlignByGeometry: 0
+    m_RichText: 1
+    m_HorizontalOverflow: 0
+    m_VerticalOverflow: 0
+    m_LineSpacing: 1
+  m_Text: Output
+--- !u!222 &383421099
+CanvasRenderer:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 383421096}
+--- !u!114 &383421100
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 383421096}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: dcb53c957d1aa0e4e90719924cc27bdc, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+--- !u!1 &613318430
+GameObject:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  serializedVersion: 4
+  m_Component:
+  - 4: {fileID: 613318435}
+  - 20: {fileID: 613318434}
+  - 92: {fileID: 613318433}
+  - 124: {fileID: 613318432}
+  - 81: {fileID: 613318431}
+  m_Layer: 0
+  m_Name: Main Camera
+  m_TagString: MainCamera
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!81 &613318431
+AudioListener:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 613318430}
+  m_Enabled: 1
+--- !u!124 &613318432
+Behaviour:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 613318430}
+  m_Enabled: 1
+--- !u!92 &613318433
+Behaviour:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 613318430}
+  m_Enabled: 1
+--- !u!20 &613318434
+Camera:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 613318430}
+  m_Enabled: 1
+  serializedVersion: 2
+  m_ClearFlags: 1
+  m_BackGroundColor: {r: 0.19215687, g: 0.3019608, b: 0.4745098, a: 0.019607844}
+  m_NormalizedViewPortRect:
+    serializedVersion: 2
+    x: 0
+    y: 0
+    width: 1
+    height: 1
+  near clip plane: 0.3
+  far clip plane: 1000
+  field of view: 60
+  orthographic: 1
+  orthographic size: 5
+  m_Depth: -1
+  m_CullingMask:
+    serializedVersion: 2
+    m_Bits: 4294967295
+  m_RenderingPath: -1
+  m_TargetTexture: {fileID: 0}
+  m_TargetDisplay: 0
+  m_TargetEye: 3
+  m_HDR: 0
+  m_OcclusionCulling: 1
+  m_StereoConvergence: 10
+  m_StereoSeparation: 0.022
+  m_StereoMirrorMode: 0
+--- !u!4 &613318435
+Transform:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 613318430}
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: -10}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+  m_Children: []
+  m_Father: {fileID: 0}
+  m_RootOrder: 1
+--- !u!1 &1098611478
+GameObject:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  serializedVersion: 4
+  m_Component:
+  - 4: {fileID: 1098611482}
+  - 114: {fileID: 1098611481}
+  - 114: {fileID: 1098611480}
+  - 114: {fileID: 1098611479}
+  m_Layer: 0
+  m_Name: EventSystem
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!114 &1098611479
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 1098611478}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 1997211142, guid: f5f67c52d1564df4a8936ccd202a3bd8, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_ForceModuleActive: 0
+--- !u!114 &1098611480
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 1098611478}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 1077351063, guid: f5f67c52d1564df4a8936ccd202a3bd8, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_HorizontalAxis: Horizontal
+  m_VerticalAxis: Vertical
+  m_SubmitButton: Submit
+  m_CancelButton: Cancel
+  m_InputActionsPerSecond: 10
+  m_RepeatDelay: 0.5
+  m_ForceModuleActive: 0
+--- !u!114 &1098611481
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 1098611478}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: -619905303, guid: f5f67c52d1564df4a8936ccd202a3bd8, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_FirstSelected: {fileID: 0}
+  m_sendNavigationEvents: 1
+  m_DragThreshold: 5
+--- !u!4 &1098611482
+Transform:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 1098611478}
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+  m_Children: []
+  m_Father: {fileID: 0}
+  m_RootOrder: 2
+--- !u!1 &2126236428
+GameObject:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  serializedVersion: 4
+  m_Component:
+  - 224: {fileID: 2126236432}
+  - 223: {fileID: 2126236431}
+  - 114: {fileID: 2126236430}
+  - 114: {fileID: 2126236429}
+  m_Layer: 5
+  m_Name: Canvas
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!114 &2126236429
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 2126236428}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 1301386320, guid: f5f67c52d1564df4a8936ccd202a3bd8, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_IgnoreReversedGraphics: 1
+  m_BlockingObjects: 0
+  m_BlockingMask:
+    serializedVersion: 2
+    m_Bits: 4294967295
+--- !u!114 &2126236430
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 2126236428}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 1980459831, guid: f5f67c52d1564df4a8936ccd202a3bd8, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_UiScaleMode: 0
+  m_ReferencePixelsPerUnit: 100
+  m_ScaleFactor: 1
+  m_ReferenceResolution: {x: 800, y: 600}
+  m_ScreenMatchMode: 0
+  m_MatchWidthOrHeight: 0
+  m_PhysicalUnit: 3
+  m_FallbackScreenDPI: 96
+  m_DefaultSpriteDPI: 96
+  m_DynamicPixelsPerUnit: 1
+--- !u!223 &2126236431
+Canvas:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 2126236428}
+  m_Enabled: 1
+  serializedVersion: 2
+  m_RenderMode: 0
+  m_Camera: {fileID: 0}
+  m_PlaneDistance: 100
+  m_PixelPerfect: 0
+  m_ReceivesEvents: 1
+  m_OverrideSorting: 0
+  m_OverridePixelPerfect: 0
+  m_SortingBucketNormalizedSize: 0
+  m_SortingLayerID: 0
+  m_SortingOrder: 0
+  m_TargetDisplay: 0
+--- !u!224 &2126236432
+RectTransform:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 2126236428}
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 0, y: 0, z: 0}
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+  m_Children:
+  - {fileID: 383421097}
+  m_Father: {fileID: 0}
+  m_RootOrder: 3
+  m_AnchorMin: {x: 0, y: 0}
+  m_AnchorMax: {x: 0, y: 0}
+  m_AnchoredPosition: {x: 0, y: 0}
+  m_SizeDelta: {x: 0, y: 0}
+  m_Pivot: {x: 0, y: 0}

Assets/Common/Plugin/JsonNetSample/JsonNetSample.unity.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 39f1fdde21c84984b9e5f7e004a9b2ef
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Font.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 879f15c3e633d2842ab33f18b6117599
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Font/DroidSansFallback.ttf.meta

@@ -0,0 +1,22 @@
+fileFormatVersion: 2
+guid: c72f41c163e2c914db2b89ee387cda74
+TrueTypeFontImporter:
+  externalObjects: {}
+  serializedVersion: 4
+  fontSize: 16
+  forceTextureCase: -2
+  characterSpacing: 0
+  characterPadding: 1
+  includeFontData: 1
+  fontName: Droid Sans Fallback
+  fontNames:
+  - Droid Sans Fallback
+  fallbackFontReferences: []
+  customCharacters: 
+  fontRenderingMode: 0
+  ascentCalculationMode: 1
+  useLegacyBoundsCalculation: 0
+  shouldRoundAdvanceValue: 1
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Image.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: fd71041aaf4122746966b914e7e6b459
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Mesh.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 83527bdc0d652214eac69df768035b80
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Mesh/12.FBX.meta

@@ -0,0 +1,164 @@
+fileFormatVersion: 2
+guid: 1dbd3f2c7c2d52d4c9ef3f4649fccf2d
+ModelImporter:
+  serializedVersion: 23
+  fileIDToRecycleName:
+    100000: //RootNode
+    100002: Floor
+    100004: Floor001
+    100006: Glass_01
+    100008: Glass_02
+    100010: Glass_03
+    100012: Light
+    100014: Roof_01
+    100016: Roof_02
+    100018: tianhuaban
+    100020: wall_01
+    100022: wall_02
+    100024: windows_01
+    100026: windows_02
+    100028: windows_03
+    400000: //RootNode
+    400002: Floor
+    400004: Floor001
+    400006: Glass_01
+    400008: Glass_02
+    400010: Glass_03
+    400012: Light
+    400014: Roof_01
+    400016: Roof_02
+    400018: tianhuaban
+    400020: wall_01
+    400022: wall_02
+    400024: windows_01
+    400026: windows_02
+    400028: windows_03
+    2100000: No Name
+    2300000: Floor
+    2300002: Floor001
+    2300004: Glass_01
+    2300006: Glass_02
+    2300008: Glass_03
+    2300010: Light
+    2300012: Roof_01
+    2300014: Roof_02
+    2300016: tianhuaban
+    2300018: wall_01
+    2300020: wall_02
+    2300022: windows_01
+    2300024: windows_02
+    2300026: windows_03
+    3300000: Floor
+    3300002: Floor001
+    3300004: Glass_01
+    3300006: Glass_02
+    3300008: Glass_03
+    3300010: Light
+    3300012: Roof_01
+    3300014: Roof_02
+    3300016: tianhuaban
+    3300018: wall_01
+    3300020: wall_02
+    3300022: windows_01
+    3300024: windows_02
+    3300026: windows_03
+    4300000: Floor
+    4300002: wall_01
+    4300004: windows_01
+    4300006: Glass_01
+    4300008: windows_02
+    4300010: Glass_02
+    4300012: windows_03
+    4300014: Glass_03
+    4300016: Roof_01
+    4300018: Roof_02
+    4300020: tianhuaban
+    4300022: Light
+    4300024: Floor001
+    4300026: wall_02
+  externalObjects: {}
+  materials:
+    importMaterials: 1
+    materialName: 0
+    materialSearch: 1
+    materialLocation: 1
+  animations:
+    legacyGenerateAnimations: 4
+    bakeSimulation: 0
+    resampleCurves: 1
+    optimizeGameObjects: 0
+    motionNodeName: 
+    rigImportErrors: 
+    rigImportWarnings: 
+    animationImportErrors: 
+    animationImportWarnings: 
+    animationRetargetingWarnings: 
+    animationDoRetargetingWarnings: 0
+    importAnimatedCustomProperties: 0
+    importConstraints: 0
+    animationCompression: 1
+    animationRotationError: 0.5
+    animationPositionError: 0.5
+    animationScaleError: 0.5
+    animationWrapMode: 0
+    extraExposedTransformPaths: []
+    extraUserProperties: []
+    clipAnimations: []
+    isReadable: 1
+  meshes:
+    lODScreenPercentages: []
+    globalScale: 1
+    meshCompression: 0
+    addColliders: 0
+    useSRGBMaterialColor: 1
+    importVisibility: 1
+    importBlendShapes: 1
+    importCameras: 1
+    importLights: 1
+    swapUVChannels: 0
+    generateSecondaryUV: 1
+    useFileUnits: 1
+    optimizeMeshForGPU: 1
+    keepQuads: 0
+    weldVertices: 1
+    preserveHierarchy: 0
+    indexFormat: 0
+    secondaryUVAngleDistortion: 8
+    secondaryUVAreaDistortion: 15.000001
+    secondaryUVHardAngle: 88
+    secondaryUVPackMargin: 4
+    useFileScale: 1
+    previousCalculatedGlobalScale: 1
+    hasPreviousCalculatedGlobalScale: 0
+  tangentSpace:
+    normalSmoothAngle: 60
+    normalImportMode: 0
+    tangentImportMode: 3
+    normalCalculationMode: 4
+    legacyComputeAllNormalsFromSmoothingGroupsWhenMeshHasBlendShapes: 0
+    blendShapeNormalImportMode: 1
+    normalSmoothingSource: 0
+  importAnimation: 1
+  copyAvatar: 0
+  humanDescription:
+    serializedVersion: 2
+    human: []
+    skeleton: []
+    armTwist: 0.5
+    foreArmTwist: 0.5
+    upperLegTwist: 0.5
+    legTwist: 0.5
+    armStretch: 0.05
+    legStretch: 0.05
+    feetSpacing: 0
+    rootMotionBoneName: 
+    hasTranslationDoF: 0
+    hasExtraRoot: 0
+    skeletonHasParents: 1
+  lastHumanDescriptionAvatarSource: {instanceID: 0}
+  animationType: 0
+  humanoidOversampling: 1
+  additionalBone: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Mesh/123.FBX.meta

@@ -0,0 +1,152 @@
+fileFormatVersion: 2
+guid: c69d083cf35149e43b93ec1b30d9de03
+ModelImporter:
+  serializedVersion: 23
+  fileIDToRecycleName:
+    100000: //RootNode
+    100002: Group-1561353-6-154
+    100004: Group-1561353-7-317
+    100006: Obj3d66-1561353-12-732
+    100008: Obj3d66-1561353-13-315
+    100010: Obj3d66-1561353-14-941
+    100012: Obj3d66-1561353-15-432
+    100014: Obj3d66-1561353-16-743
+    100016: Obj3d66-1561353-17-178
+    100018: Obj3d66-1561353-18-454
+    100020: Obj3d66-1561353-19-950
+    100022: Obj3d66-1561353-20-226
+    100024: Obj3d66-1561353-21-446
+    400000: //RootNode
+    400002: Group-1561353-6-154
+    400004: Group-1561353-7-317
+    400006: Obj3d66-1561353-12-732
+    400008: Obj3d66-1561353-13-315
+    400010: Obj3d66-1561353-14-941
+    400012: Obj3d66-1561353-15-432
+    400014: Obj3d66-1561353-16-743
+    400016: Obj3d66-1561353-17-178
+    400018: Obj3d66-1561353-18-454
+    400020: Obj3d66-1561353-19-950
+    400022: Obj3d66-1561353-20-226
+    400024: Obj3d66-1561353-21-446
+    2100000: 13 - Brushed Metal
+    2100002: 'Material #84'
+    2100004: 'Material #83'
+    2100006: 'Material #81'
+    2100008: 'Material #82'
+    2300000: Obj3d66-1561353-12-732
+    2300002: Obj3d66-1561353-13-315
+    2300004: Obj3d66-1561353-14-941
+    2300006: Obj3d66-1561353-15-432
+    2300008: Obj3d66-1561353-16-743
+    2300010: Obj3d66-1561353-17-178
+    2300012: Obj3d66-1561353-18-454
+    2300014: Obj3d66-1561353-19-950
+    2300016: Obj3d66-1561353-20-226
+    2300018: Obj3d66-1561353-21-446
+    3300000: Obj3d66-1561353-12-732
+    3300002: Obj3d66-1561353-13-315
+    3300004: Obj3d66-1561353-14-941
+    3300006: Obj3d66-1561353-15-432
+    3300008: Obj3d66-1561353-16-743
+    3300010: Obj3d66-1561353-17-178
+    3300012: Obj3d66-1561353-18-454
+    3300014: Obj3d66-1561353-19-950
+    3300016: Obj3d66-1561353-20-226
+    3300018: Obj3d66-1561353-21-446
+    4300000: Obj3d66-1561353-12-732
+    4300002: Obj3d66-1561353-13-315
+    4300004: Obj3d66-1561353-14-941
+    4300006: Obj3d66-1561353-15-432
+    4300008: Obj3d66-1561353-16-743
+    4300010: Obj3d66-1561353-17-178
+    4300012: Obj3d66-1561353-18-454
+    4300014: Obj3d66-1561353-19-950
+    4300016: Obj3d66-1561353-20-226
+    4300018: Obj3d66-1561353-21-446
+  externalObjects: {}
+  materials:
+    importMaterials: 1
+    materialName: 0
+    materialSearch: 1
+    materialLocation: 1
+  animations:
+    legacyGenerateAnimations: 4
+    bakeSimulation: 0
+    resampleCurves: 1
+    optimizeGameObjects: 0
+    motionNodeName: 
+    rigImportErrors: 
+    rigImportWarnings: 
+    animationImportErrors: 
+    animationImportWarnings: 
+    animationRetargetingWarnings: 
+    animationDoRetargetingWarnings: 0
+    importAnimatedCustomProperties: 0
+    importConstraints: 0
+    animationCompression: 1
+    animationRotationError: 0.5
+    animationPositionError: 0.5
+    animationScaleError: 0.5
+    animationWrapMode: 0
+    extraExposedTransformPaths: []
+    extraUserProperties: []
+    clipAnimations: []
+    isReadable: 1
+  meshes:
+    lODScreenPercentages: []
+    globalScale: 1
+    meshCompression: 0
+    addColliders: 0
+    useSRGBMaterialColor: 1
+    importVisibility: 1
+    importBlendShapes: 1
+    importCameras: 1
+    importLights: 1
+    swapUVChannels: 0
+    generateSecondaryUV: 1
+    useFileUnits: 1
+    optimizeMeshForGPU: 1
+    keepQuads: 0
+    weldVertices: 1
+    preserveHierarchy: 0
+    indexFormat: 0
+    secondaryUVAngleDistortion: 8
+    secondaryUVAreaDistortion: 15.000001
+    secondaryUVHardAngle: 88
+    secondaryUVPackMargin: 4
+    useFileScale: 1
+    previousCalculatedGlobalScale: 1
+    hasPreviousCalculatedGlobalScale: 0
+  tangentSpace:
+    normalSmoothAngle: 60
+    normalImportMode: 0
+    tangentImportMode: 3
+    normalCalculationMode: 4
+    legacyComputeAllNormalsFromSmoothingGroupsWhenMeshHasBlendShapes: 0
+    blendShapeNormalImportMode: 1
+    normalSmoothingSource: 0
+  importAnimation: 1
+  copyAvatar: 0
+  humanDescription:
+    serializedVersion: 2
+    human: []
+    skeleton: []
+    armTwist: 0.5
+    foreArmTwist: 0.5
+    upperLegTwist: 0.5
+    legTwist: 0.5
+    armStretch: 0.05
+    legStretch: 0.05
+    feetSpacing: 0
+    rootMotionBoneName: 
+    hasTranslationDoF: 0
+    hasExtraRoot: 0
+    skeletonHasParents: 1
+  lastHumanDescriptionAvatarSource: {instanceID: 0}
+  animationType: 0
+  humanoidOversampling: 1
+  additionalBone: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Mesh/BJ.FBX.meta

@@ -0,0 +1,97 @@
+fileFormatVersion: 2
+guid: 80c4ca3095779ac43ae76ddb18a7cb07
+ModelImporter:
+  serializedVersion: 23
+  fileIDToRecycleName:
+    100000: //RootNode
+    400000: //RootNode
+    2100000: No Name
+    2300000: //RootNode
+    3300000: //RootNode
+    4300000: BJ
+  externalObjects: {}
+  materials:
+    importMaterials: 1
+    materialName: 0
+    materialSearch: 1
+    materialLocation: 1
+  animations:
+    legacyGenerateAnimations: 4
+    bakeSimulation: 0
+    resampleCurves: 1
+    optimizeGameObjects: 0
+    motionNodeName: 
+    rigImportErrors: 
+    rigImportWarnings: 
+    animationImportErrors: 
+    animationImportWarnings: 
+    animationRetargetingWarnings: 
+    animationDoRetargetingWarnings: 0
+    importAnimatedCustomProperties: 0
+    importConstraints: 0
+    animationCompression: 1
+    animationRotationError: 0.5
+    animationPositionError: 0.5
+    animationScaleError: 0.5
+    animationWrapMode: 0
+    extraExposedTransformPaths: []
+    extraUserProperties: []
+    clipAnimations: []
+    isReadable: 1
+  meshes:
+    lODScreenPercentages: []
+    globalScale: 1
+    meshCompression: 0
+    addColliders: 0
+    useSRGBMaterialColor: 1
+    importVisibility: 1
+    importBlendShapes: 1
+    importCameras: 1
+    importLights: 1
+    swapUVChannels: 0
+    generateSecondaryUV: 0
+    useFileUnits: 1
+    optimizeMeshForGPU: 1
+    keepQuads: 0
+    weldVertices: 1
+    preserveHierarchy: 0
+    indexFormat: 0
+    secondaryUVAngleDistortion: 8
+    secondaryUVAreaDistortion: 15.000001
+    secondaryUVHardAngle: 88
+    secondaryUVPackMargin: 4
+    useFileScale: 1
+    previousCalculatedGlobalScale: 1
+    hasPreviousCalculatedGlobalScale: 0
+  tangentSpace:
+    normalSmoothAngle: 60
+    normalImportMode: 0
+    tangentImportMode: 3
+    normalCalculationMode: 4
+    legacyComputeAllNormalsFromSmoothingGroupsWhenMeshHasBlendShapes: 0
+    blendShapeNormalImportMode: 1
+    normalSmoothingSource: 0
+  importAnimation: 1
+  copyAvatar: 0
+  humanDescription:
+    serializedVersion: 2
+    human: []
+    skeleton: []
+    armTwist: 0.5
+    foreArmTwist: 0.5
+    upperLegTwist: 0.5
+    legTwist: 0.5
+    armStretch: 0.05
+    legStretch: 0.05
+    feetSpacing: 0
+    rootMotionBoneName: 
+    hasTranslationDoF: 0
+    hasExtraRoot: 0
+    skeletonHasParents: 1
+  lastHumanDescriptionAvatarSource: {instanceID: 0}
+  animationType: 0
+  humanoidOversampling: 1
+  additionalBone: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Mesh/BJ_02.FBX.meta

@@ -0,0 +1,97 @@
+fileFormatVersion: 2
+guid: 2143a131424aba04b96a6d41cc9bad62
+ModelImporter:
+  serializedVersion: 23
+  fileIDToRecycleName:
+    100000: //RootNode
+    400000: //RootNode
+    2100000: No Name
+    2300000: //RootNode
+    3300000: //RootNode
+    4300000: BJ_02
+  externalObjects: {}
+  materials:
+    importMaterials: 1
+    materialName: 0
+    materialSearch: 1
+    materialLocation: 1
+  animations:
+    legacyGenerateAnimations: 4
+    bakeSimulation: 0
+    resampleCurves: 1
+    optimizeGameObjects: 0
+    motionNodeName: 
+    rigImportErrors: 
+    rigImportWarnings: 
+    animationImportErrors: 
+    animationImportWarnings: 
+    animationRetargetingWarnings: 
+    animationDoRetargetingWarnings: 0
+    importAnimatedCustomProperties: 0
+    importConstraints: 0
+    animationCompression: 1
+    animationRotationError: 0.5
+    animationPositionError: 0.5
+    animationScaleError: 0.5
+    animationWrapMode: 0
+    extraExposedTransformPaths: []
+    extraUserProperties: []
+    clipAnimations: []
+    isReadable: 1
+  meshes:
+    lODScreenPercentages: []
+    globalScale: 1
+    meshCompression: 0
+    addColliders: 0
+    useSRGBMaterialColor: 1
+    importVisibility: 1
+    importBlendShapes: 1
+    importCameras: 1
+    importLights: 1
+    swapUVChannels: 0
+    generateSecondaryUV: 0
+    useFileUnits: 1
+    optimizeMeshForGPU: 1
+    keepQuads: 0
+    weldVertices: 1
+    preserveHierarchy: 0
+    indexFormat: 0
+    secondaryUVAngleDistortion: 8
+    secondaryUVAreaDistortion: 15.000001
+    secondaryUVHardAngle: 88
+    secondaryUVPackMargin: 4
+    useFileScale: 1
+    previousCalculatedGlobalScale: 1
+    hasPreviousCalculatedGlobalScale: 0
+  tangentSpace:
+    normalSmoothAngle: 60
+    normalImportMode: 0
+    tangentImportMode: 3
+    normalCalculationMode: 4
+    legacyComputeAllNormalsFromSmoothingGroupsWhenMeshHasBlendShapes: 0
+    blendShapeNormalImportMode: 1
+    normalSmoothingSource: 0
+  importAnimation: 1
+  copyAvatar: 0
+  humanDescription:
+    serializedVersion: 2
+    human: []
+    skeleton: []
+    armTwist: 0.5
+    foreArmTwist: 0.5
+    upperLegTwist: 0.5
+    legTwist: 0.5
+    armStretch: 0.05
+    legStretch: 0.05
+    feetSpacing: 0
+    rootMotionBoneName: 
+    hasTranslationDoF: 0
+    hasExtraRoot: 0
+    skeletonHasParents: 1
+  lastHumanDescriptionAvatarSource: {instanceID: 0}
+  animationType: 0
+  humanoidOversampling: 1
+  additionalBone: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Mesh/Chuanglian_01.FBX.meta

@@ -0,0 +1,97 @@
+fileFormatVersion: 2
+guid: 299e3a5cd7653c24bb24117abd0aef50
+ModelImporter:
+  serializedVersion: 23
+  fileIDToRecycleName:
+    100000: //RootNode
+    400000: //RootNode
+    2100000: No Name
+    2300000: //RootNode
+    3300000: //RootNode
+    4300000: Chuanglian_01
+  externalObjects: {}
+  materials:
+    importMaterials: 1
+    materialName: 0
+    materialSearch: 1
+    materialLocation: 1
+  animations:
+    legacyGenerateAnimations: 4
+    bakeSimulation: 0
+    resampleCurves: 1
+    optimizeGameObjects: 0
+    motionNodeName: 
+    rigImportErrors: 
+    rigImportWarnings: 
+    animationImportErrors: 
+    animationImportWarnings: 
+    animationRetargetingWarnings: 
+    animationDoRetargetingWarnings: 0
+    importAnimatedCustomProperties: 0
+    importConstraints: 0
+    animationCompression: 1
+    animationRotationError: 0.5
+    animationPositionError: 0.5
+    animationScaleError: 0.5
+    animationWrapMode: 0
+    extraExposedTransformPaths: []
+    extraUserProperties: []
+    clipAnimations: []
+    isReadable: 1
+  meshes:
+    lODScreenPercentages: []
+    globalScale: 1
+    meshCompression: 0
+    addColliders: 0
+    useSRGBMaterialColor: 1
+    importVisibility: 1
+    importBlendShapes: 1
+    importCameras: 1
+    importLights: 1
+    swapUVChannels: 0
+    generateSecondaryUV: 1
+    useFileUnits: 1
+    optimizeMeshForGPU: 1
+    keepQuads: 0
+    weldVertices: 1
+    preserveHierarchy: 0
+    indexFormat: 0
+    secondaryUVAngleDistortion: 8
+    secondaryUVAreaDistortion: 15.000001
+    secondaryUVHardAngle: 88
+    secondaryUVPackMargin: 4
+    useFileScale: 1
+    previousCalculatedGlobalScale: 1
+    hasPreviousCalculatedGlobalScale: 0
+  tangentSpace:
+    normalSmoothAngle: 60
+    normalImportMode: 0
+    tangentImportMode: 3
+    normalCalculationMode: 4
+    legacyComputeAllNormalsFromSmoothingGroupsWhenMeshHasBlendShapes: 0
+    blendShapeNormalImportMode: 1
+    normalSmoothingSource: 0
+  importAnimation: 1
+  copyAvatar: 0
+  humanDescription:
+    serializedVersion: 2
+    human: []
+    skeleton: []
+    armTwist: 0.5
+    foreArmTwist: 0.5
+    upperLegTwist: 0.5
+    legTwist: 0.5
+    armStretch: 0.05
+    legStretch: 0.05
+    feetSpacing: 0
+    rootMotionBoneName: 
+    hasTranslationDoF: 0
+    hasExtraRoot: 0
+    skeletonHasParents: 1
+  lastHumanDescriptionAvatarSource: {instanceID: 0}
+  animationType: 0
+  humanoidOversampling: 1
+  additionalBone: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Mesh/Light_01.FBX.meta

@@ -0,0 +1,104 @@
+fileFormatVersion: 2
+guid: e5ef6ef1ebe9e94488582ad52024b79c
+ModelImporter:
+  serializedVersion: 23
+  fileIDToRecycleName:
+    100000: //RootNode
+    100002: Light_01a
+    100004: Light_01b
+    400000: //RootNode
+    400002: Light_01a
+    400004: Light_01b
+    2100000: No Name
+    2300000: Light_01a
+    2300002: Light_01b
+    3300000: Light_01a
+    3300002: Light_01b
+    4300000: Light_01a
+    4300002: Light_01b
+  externalObjects: {}
+  materials:
+    importMaterials: 1
+    materialName: 0
+    materialSearch: 1
+    materialLocation: 1
+  animations:
+    legacyGenerateAnimations: 4
+    bakeSimulation: 0
+    resampleCurves: 1
+    optimizeGameObjects: 0
+    motionNodeName: 
+    rigImportErrors: 
+    rigImportWarnings: 
+    animationImportErrors: 
+    animationImportWarnings: 
+    animationRetargetingWarnings: 
+    animationDoRetargetingWarnings: 0
+    importAnimatedCustomProperties: 0
+    importConstraints: 0
+    animationCompression: 1
+    animationRotationError: 0.5
+    animationPositionError: 0.5
+    animationScaleError: 0.5
+    animationWrapMode: 0
+    extraExposedTransformPaths: []
+    extraUserProperties: []
+    clipAnimations: []
+    isReadable: 1
+  meshes:
+    lODScreenPercentages: []
+    globalScale: 1
+    meshCompression: 0
+    addColliders: 0
+    useSRGBMaterialColor: 1
+    importVisibility: 1
+    importBlendShapes: 1
+    importCameras: 1
+    importLights: 1
+    swapUVChannels: 0
+    generateSecondaryUV: 0
+    useFileUnits: 1
+    optimizeMeshForGPU: 1
+    keepQuads: 0
+    weldVertices: 1
+    preserveHierarchy: 0
+    indexFormat: 0
+    secondaryUVAngleDistortion: 8
+    secondaryUVAreaDistortion: 15.000001
+    secondaryUVHardAngle: 88
+    secondaryUVPackMargin: 4
+    useFileScale: 1
+    previousCalculatedGlobalScale: 1
+    hasPreviousCalculatedGlobalScale: 0
+  tangentSpace:
+    normalSmoothAngle: 60
+    normalImportMode: 0
+    tangentImportMode: 3
+    normalCalculationMode: 4
+    legacyComputeAllNormalsFromSmoothingGroupsWhenMeshHasBlendShapes: 0
+    blendShapeNormalImportMode: 1
+    normalSmoothingSource: 0
+  importAnimation: 1
+  copyAvatar: 0
+  humanDescription:
+    serializedVersion: 2
+    human: []
+    skeleton: []
+    armTwist: 0.5
+    foreArmTwist: 0.5
+    upperLegTwist: 0.5
+    legTwist: 0.5
+    armStretch: 0.05
+    legStretch: 0.05
+    feetSpacing: 0
+    rootMotionBoneName: 
+    hasTranslationDoF: 0
+    hasExtraRoot: 0
+    skeletonHasParents: 1
+  lastHumanDescriptionAvatarSource: {instanceID: 0}
+  animationType: 0
+  humanoidOversampling: 1
+  additionalBone: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Mesh/Material.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 62bb81c274915ea438399823af038f6a
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Mesh/Material/BJ.jpg.meta

@@ -0,0 +1,88 @@
+fileFormatVersion: 2
+guid: 9fe8c9b0b46e7bf45b39fab40910316b
+TextureImporter:
+  fileIDToRecycleName: {}
+  externalObjects: {}
+  serializedVersion: 9
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 1
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: -1
+    aniso: -1
+    mipBias: -100
+    wrapU: -1
+    wrapV: -1
+    wrapW: -1
+  nPOTScale: 1
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spritePixelsToUnits: 100
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spriteGenerateFallbackPhysicsShape: 1
+  alphaUsage: 1
+  alphaIsTransparency: 0
+  spriteTessellationDetail: -1
+  textureType: 0
+  textureShape: 1
+  singleChannelComponent: 0
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  platformSettings:
+  - serializedVersion: 2
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+    bones: []
+    spriteID: 
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+  spritePackingTag: 
+  pSDRemoveMatte: 0
+  pSDShowRemoveMatteOption: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Mesh/Material/BJ.mat

@@ -0,0 +1,77 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 6
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: BJ
+  m_Shader: {fileID: 46, guid: 0000000000000000f000000000000000, type: 0}
+  m_ShaderKeywords: _EMISSION
+  m_LightmapFlags: 1
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  disabledShaderPasses: []
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BumpMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailNormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissionMap:
+        m_Texture: {fileID: 2800000, guid: 9fe8c9b0b46e7bf45b39fab40910316b, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 2800000, guid: 9fe8c9b0b46e7bf45b39fab40910316b, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MetallicGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ParallaxMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Floats:
+    - _BumpScale: 1
+    - _Cutoff: 0.5
+    - _DetailNormalMapScale: 1
+    - _DstBlend: 0
+    - _GlossMapScale: 1
+    - _Glossiness: 0.5
+    - _GlossyReflections: 1
+    - _Metallic: 0
+    - _Mode: 0
+    - _OcclusionStrength: 1
+    - _Parallax: 0.02
+    - _SmoothnessTextureChannel: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _UVSec: 0
+    - _ZWrite: 1
+    m_Colors:
+    - _Color: {r: 1, g: 1, b: 1, a: 1}
+    - _EmissionColor: {r: 1, g: 1, b: 1, a: 1}

Assets/Mesh/Material/BJ.mat.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 2ffdab8d61a96264689bbacbd2049ef6
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 2100000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Mesh/Material/BJ_02.jpg.meta

@@ -0,0 +1,88 @@
+fileFormatVersion: 2
+guid: a02b72cfd796f294ba423a1223424d92
+TextureImporter:
+  fileIDToRecycleName: {}
+  externalObjects: {}
+  serializedVersion: 9
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 1
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: -1
+    aniso: -1
+    mipBias: -100
+    wrapU: -1
+    wrapV: -1
+    wrapW: -1
+  nPOTScale: 1
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spritePixelsToUnits: 100
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spriteGenerateFallbackPhysicsShape: 1
+  alphaUsage: 1
+  alphaIsTransparency: 0
+  spriteTessellationDetail: -1
+  textureType: 0
+  textureShape: 1
+  singleChannelComponent: 0
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  platformSettings:
+  - serializedVersion: 2
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+    bones: []
+    spriteID: 
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+  spritePackingTag: 
+  pSDRemoveMatte: 0
+  pSDShowRemoveMatteOption: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Mesh/Material/BJ_02.mat

@@ -0,0 +1,77 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 6
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: BJ_02
+  m_Shader: {fileID: 46, guid: 0000000000000000f000000000000000, type: 0}
+  m_ShaderKeywords: 
+  m_LightmapFlags: 4
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  disabledShaderPasses: []
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BumpMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailNormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1.37, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 2800000, guid: a02b72cfd796f294ba423a1223424d92, type: 3}
+        m_Scale: {x: 1.37, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MetallicGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ParallaxMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Floats:
+    - _BumpScale: 1
+    - _Cutoff: 0.5
+    - _DetailNormalMapScale: 1
+    - _DstBlend: 0
+    - _GlossMapScale: 1
+    - _Glossiness: 0
+    - _GlossyReflections: 1
+    - _Metallic: 0
+    - _Mode: 0
+    - _OcclusionStrength: 1
+    - _Parallax: 0.02
+    - _SmoothnessTextureChannel: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _UVSec: 0
+    - _ZWrite: 1
+    m_Colors:
+    - _Color: {r: 0.5566038, g: 0.5566038, b: 0.5566038, a: 1}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}

Assets/Mesh/Material/BJ_02.mat.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: d799488996034af41920e9a4057de72d
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 2100000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Mesh/Material/Chuanglian_01.jpg.meta

@@ -0,0 +1,88 @@
+fileFormatVersion: 2
+guid: d870aea29b74a3d4fac37ac2cd096c7e
+TextureImporter:
+  fileIDToRecycleName: {}
+  externalObjects: {}
+  serializedVersion: 9
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 1
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: -1
+    aniso: -1
+    mipBias: -100
+    wrapU: -1
+    wrapV: -1
+    wrapW: -1
+  nPOTScale: 1
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spritePixelsToUnits: 100
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spriteGenerateFallbackPhysicsShape: 1
+  alphaUsage: 1
+  alphaIsTransparency: 0
+  spriteTessellationDetail: -1
+  textureType: 0
+  textureShape: 1
+  singleChannelComponent: 0
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  platformSettings:
+  - serializedVersion: 2
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+    bones: []
+    spriteID: 
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+  spritePackingTag: 
+  pSDRemoveMatte: 0
+  pSDShowRemoveMatteOption: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Mesh/Material/Chuanglian_01.mat

@@ -0,0 +1,77 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 6
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: Chuanglian_01
+  m_Shader: {fileID: 46, guid: 0000000000000000f000000000000000, type: 0}
+  m_ShaderKeywords: _EMISSION
+  m_LightmapFlags: 1
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  disabledShaderPasses: []
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BumpMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailNormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissionMap:
+        m_Texture: {fileID: 2800000, guid: d870aea29b74a3d4fac37ac2cd096c7e, type: 3}
+        m_Scale: {x: -0.03, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 2800000, guid: d870aea29b74a3d4fac37ac2cd096c7e, type: 3}
+        m_Scale: {x: -0.03, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MetallicGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ParallaxMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Floats:
+    - _BumpScale: 1
+    - _Cutoff: 0.5
+    - _DetailNormalMapScale: 1
+    - _DstBlend: 0
+    - _GlossMapScale: 1
+    - _Glossiness: 0
+    - _GlossyReflections: 1
+    - _Metallic: 0
+    - _Mode: 0
+    - _OcclusionStrength: 1
+    - _Parallax: 0.02
+    - _SmoothnessTextureChannel: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _UVSec: 0
+    - _ZWrite: 1
+    m_Colors:
+    - _Color: {r: 1, g: 1, b: 1, a: 1}
+    - _EmissionColor: {r: 0.57434916, g: 0.57434916, b: 0.57434916, a: 1}

Assets/Mesh/Material/Chuanglian_01.mat.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 9c61aa1aedfe78f48936fe259ece03ce
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 2100000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Mesh/Material/Chuanglian_02.mat

@@ -0,0 +1,77 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 6
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: Chuanglian_02
+  m_Shader: {fileID: 46, guid: 0000000000000000f000000000000000, type: 0}
+  m_ShaderKeywords: _EMISSION
+  m_LightmapFlags: 1
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  disabledShaderPasses: []
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BumpMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailNormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissionMap:
+        m_Texture: {fileID: 2800000, guid: d870aea29b74a3d4fac37ac2cd096c7e, type: 3}
+        m_Scale: {x: -0.03, y: 1}
+        m_Offset: {x: -0.871, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 2800000, guid: d870aea29b74a3d4fac37ac2cd096c7e, type: 3}
+        m_Scale: {x: -0.03, y: 1}
+        m_Offset: {x: -0.871, y: 0}
+    - _MetallicGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ParallaxMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Floats:
+    - _BumpScale: 1
+    - _Cutoff: 0.5
+    - _DetailNormalMapScale: 1
+    - _DstBlend: 0
+    - _GlossMapScale: 1
+    - _Glossiness: 0
+    - _GlossyReflections: 1
+    - _Metallic: 0
+    - _Mode: 0
+    - _OcclusionStrength: 1
+    - _Parallax: 0.02
+    - _SmoothnessTextureChannel: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _UVSec: 0
+    - _ZWrite: 1
+    m_Colors:
+    - _Color: {r: 1, g: 1, b: 1, a: 1}
+    - _EmissionColor: {r: 0.57434916, g: 0.57434916, b: 0.57434916, a: 1}

Assets/Mesh/Material/Chuanglian_02.mat.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: f2813b274fe0ed441821ae13979e6375
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 2100000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Mesh/Material/CityRoad_01.mat

@@ -0,0 +1,77 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 6
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: CityRoad_01
+  m_Shader: {fileID: 46, guid: 0000000000000000f000000000000000, type: 0}
+  m_ShaderKeywords: 
+  m_LightmapFlags: 4
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  disabledShaderPasses: []
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BumpMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailNormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 2800000, guid: 6ab7ed0a146d147499c69ae97aa13064, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MetallicGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ParallaxMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Floats:
+    - _BumpScale: 1
+    - _Cutoff: 0.5
+    - _DetailNormalMapScale: 1
+    - _DstBlend: 0
+    - _GlossMapScale: 1
+    - _Glossiness: 0.3
+    - _GlossyReflections: 1
+    - _Metallic: 0.5
+    - _Mode: 0
+    - _OcclusionStrength: 1
+    - _Parallax: 0.02
+    - _SmoothnessTextureChannel: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _UVSec: 0
+    - _ZWrite: 1
+    m_Colors:
+    - _Color: {r: 1, g: 1, b: 1, a: 1}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}

Assets/Mesh/Material/CityRoad_01.mat.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 8be5d446b80e14a44a1fb5bc09fc53bf
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 2100000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Mesh/Material/CityRoad_01.tga.meta

@@ -0,0 +1,88 @@
+fileFormatVersion: 2
+guid: 6ab7ed0a146d147499c69ae97aa13064
+TextureImporter:
+  fileIDToRecycleName: {}
+  externalObjects: {}
+  serializedVersion: 9
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 1
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: -1
+    aniso: -1
+    mipBias: -100
+    wrapU: -1
+    wrapV: -1
+    wrapW: -1
+  nPOTScale: 1
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spritePixelsToUnits: 100
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spriteGenerateFallbackPhysicsShape: 1
+  alphaUsage: 1
+  alphaIsTransparency: 0
+  spriteTessellationDetail: -1
+  textureType: 0
+  textureShape: 1
+  singleChannelComponent: 0
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  platformSettings:
+  - serializedVersion: 2
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+    bones: []
+    spriteID: 
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+  spritePackingTag: 
+  pSDRemoveMatte: 0
+  pSDShowRemoveMatteOption: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: