示例#1
0
        UnityEngine.Object DeserializeUnityObjectInner()
        {
            // Ignore InstanceID field (compatibility only)
            var fieldName = EatField();

            if (fieldName == "InstanceID")
            {
                EatField();
                fieldName = EatField();
            }

            if (fieldName != "Name")
            {
                throw new Exception("Expected 'Name' field");
            }
            string name = EatField();

            if (name == null)
            {
                return(null);
            }

            if (EatField() != "Type")
            {
                throw new Exception("Expected 'Type' field");
            }
            string typename = EatField();

            // Remove assembly information
            if (typename.IndexOf(',') != -1)
            {
                typename = typename.Substring(0, typename.IndexOf(','));
            }

            // Note calling through assembly is more stable on e.g WebGL
            var type = WindowsStoreCompatibility.GetTypeInfo(typeof(AstarPath)).Assembly.GetType(typename);

            type = type ?? WindowsStoreCompatibility.GetTypeInfo(typeof(Transform)).Assembly.GetType(typename);

            if (Type.Equals(type, null))
            {
                Debug.LogError("Could not find type '" + typename + "'. Cannot deserialize Unity reference");
                return(null);
            }

            // Check if there is another field there
            EatWhitespace();
            if ((char)reader.Peek() == '"')
            {
                if (EatField() != "GUID")
                {
                    throw new Exception("Expected 'GUID' field");
                }
                string guid = EatField();

                foreach (var helper in UnityEngine.Object.FindObjectsOfType <UnityReferenceHelper>())
                {
                    if (helper.GetGUID() == guid)
                    {
                        if (Type.Equals(type, typeof(GameObject)))
                        {
                            return(helper.gameObject);
                        }
                        else
                        {
                            return(helper.GetComponent(type));
                        }
                    }
                }
            }

            // Try to load from resources
            UnityEngine.Object[] objs = Resources.LoadAll(name, type);

            for (int i = 0; i < objs.Length; i++)
            {
                if (objs[i].name == name || objs.Length == 1)
                {
                    return(objs[i]);
                }
            }

            return(null);
        }
        private object Deserialize(Type tp, object populate = null)
        {
            Type typeInfo = WindowsStoreCompatibility.GetTypeInfo(tp);

            if (typeInfo.IsEnum)
            {
                return(Enum.Parse(tp, this.EatField()));
            }
            if (this.TryEat('n'))
            {
                this.Eat("ull");
                this.TryEat(',');
                return(null);
            }
            if (object.Equals(tp, typeof(float)))
            {
                return(float.Parse(this.EatField(), TinyJsonDeserializer.numberFormat));
            }
            if (object.Equals(tp, typeof(int)))
            {
                return(int.Parse(this.EatField(), TinyJsonDeserializer.numberFormat));
            }
            if (object.Equals(tp, typeof(uint)))
            {
                return(uint.Parse(this.EatField(), TinyJsonDeserializer.numberFormat));
            }
            if (object.Equals(tp, typeof(bool)))
            {
                return(bool.Parse(this.EatField()));
            }
            if (object.Equals(tp, typeof(string)))
            {
                return(this.EatField());
            }
            if (object.Equals(tp, typeof(Version)))
            {
                return(new Version(this.EatField()));
            }
            if (object.Equals(tp, typeof(Vector2)))
            {
                this.Eat("{");
                Vector2 vector = default(Vector2);
                this.EatField();
                vector.x = float.Parse(this.EatField(), TinyJsonDeserializer.numberFormat);
                this.EatField();
                vector.y = float.Parse(this.EatField(), TinyJsonDeserializer.numberFormat);
                this.Eat("}");
                return(vector);
            }
            if (object.Equals(tp, typeof(Vector3)))
            {
                this.Eat("{");
                Vector3 vector2 = default(Vector3);
                this.EatField();
                vector2.x = float.Parse(this.EatField(), TinyJsonDeserializer.numberFormat);
                this.EatField();
                vector2.y = float.Parse(this.EatField(), TinyJsonDeserializer.numberFormat);
                this.EatField();
                vector2.z = float.Parse(this.EatField(), TinyJsonDeserializer.numberFormat);
                this.Eat("}");
                return(vector2);
            }
            if (object.Equals(tp, typeof(Pathfinding.Util.Guid)))
            {
                this.Eat("{");
                this.EatField();
                Pathfinding.Util.Guid guid = Pathfinding.Util.Guid.Parse(this.EatField());
                this.Eat("}");
                return(guid);
            }
            if (object.Equals(tp, typeof(LayerMask)))
            {
                this.Eat("{");
                this.EatField();
                LayerMask layerMask = int.Parse(this.EatField());
                this.Eat("}");
                return(layerMask);
            }
            if (object.Equals(tp, typeof(List <string>)))
            {
                IList list = new List <string>();
                this.Eat("[");
                while (!this.TryEat(']'))
                {
                    list.Add(this.Deserialize(typeof(string), null));
                    this.TryEat(',');
                }
                return(list);
            }
            if (typeInfo.IsArray)
            {
                List <object> list2 = new List <object>();
                this.Eat("[");
                while (!this.TryEat(']'))
                {
                    list2.Add(this.Deserialize(tp.GetElementType(), null));
                    this.TryEat(',');
                }
                Array array = Array.CreateInstance(tp.GetElementType(), list2.Count);
                list2.ToArray().CopyTo(array, 0);
                return(array);
            }
            if (object.Equals(tp, typeof(Mesh)) || object.Equals(tp, typeof(Texture2D)) || object.Equals(tp, typeof(Transform)) || object.Equals(tp, typeof(GameObject)))
            {
                return(this.DeserializeUnityObject());
            }
            object obj = populate ?? Activator.CreateInstance(tp);

            this.Eat("{");
            while (!this.TryEat('}'))
            {
                string    name  = this.EatField();
                FieldInfo field = tp.GetField(name, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
                if (field == null)
                {
                    this.SkipFieldData();
                }
                else
                {
                    field.SetValue(obj, this.Deserialize(field.FieldType, null));
                }
                this.TryEat(',');
            }
            return(obj);
        }
示例#3
0
        /** Deserializes an object of type tp.
         * Will load all fields into the \a populate object if it is set (only works for classes).
         */
        System.Object Deserialize(Type tp, System.Object populate = null)
        {
            var tpInfo = WindowsStoreCompatibility.GetTypeInfo(tp);

            if (tpInfo.IsEnum)
            {
                return(Enum.Parse(tp, EatField()));
            }
            else if (TryEat('n'))
            {
                Eat("ull");
                TryEat(',');
                return(null);
            }
            else if (Type.Equals(tp, typeof(float)))
            {
                return(float.Parse(EatField(), numberFormat));
            }
            else if (Type.Equals(tp, typeof(int)))
            {
                return(int.Parse(EatField(), numberFormat));
            }
            else if (Type.Equals(tp, typeof(uint)))
            {
                return(uint.Parse(EatField(), numberFormat));
            }
            else if (Type.Equals(tp, typeof(bool)))
            {
                return(bool.Parse(EatField()));
            }
            else if (Type.Equals(tp, typeof(string)))
            {
                return(EatField());
            }
            else if (Type.Equals(tp, typeof(Version)))
            {
                return(new Version(EatField()));
            }
            else if (Type.Equals(tp, typeof(Vector2)))
            {
                Eat("{");
                var result = new Vector2();
                EatField();
                result.x = float.Parse(EatField(), numberFormat);
                EatField();
                result.y = float.Parse(EatField(), numberFormat);
                Eat("}");
                return(result);
            }
            else if (Type.Equals(tp, typeof(Vector3)))
            {
                Eat("{");
                var result = new Vector3();
                EatField();
                result.x = float.Parse(EatField(), numberFormat);
                EatField();
                result.y = float.Parse(EatField(), numberFormat);
                EatField();
                result.z = float.Parse(EatField(), numberFormat);
                Eat("}");
                return(result);
            }
            else if (Type.Equals(tp, typeof(Pathfinding.Util.Guid)))
            {
                Eat("{");
                EatField();
                var result = Pathfinding.Util.Guid.Parse(EatField());
                Eat("}");
                return(result);
            }
            else if (Type.Equals(tp, typeof(LayerMask)))
            {
                Eat("{");
                EatField();
                var result = (LayerMask)int.Parse(EatField());
                Eat("}");
                return(result);
            }
            else if (Type.Equals(tp, typeof(List <string>)))
            {
                System.Collections.IList result = new List <string>();

                Eat("[");
                while (!TryEat(']'))
                {
                    result.Add(Deserialize(typeof(string)));
                    TryEat(',');
                }
                return(result);
            }
            else if (tpInfo.IsArray)
            {
                List <System.Object> ls = new List <System.Object>();
                Eat("[");
                while (!TryEat(']'))
                {
                    ls.Add(Deserialize(tp.GetElementType()));
                    TryEat(',');
                }
                var arr = Array.CreateInstance(tp.GetElementType(), ls.Count);
                ls.ToArray().CopyTo(arr, 0);
                return(arr);
            }
            else if (Type.Equals(tp, typeof(Mesh)) || Type.Equals(tp, typeof(Texture2D)) || Type.Equals(tp, typeof(Transform)) || Type.Equals(tp, typeof(GameObject)))
            {
                return(DeserializeUnityObject());
            }
            else
            {
                var obj = populate ?? Activator.CreateInstance(tp);
                Eat("{");
                while (!TryEat('}'))
                {
                    var name    = EatField();
                    var tmpType = tp;
                    System.Reflection.FieldInfo field = null;
                    while (field == null && tmpType != null)
                    {
                        field   = tmpType.GetField(name, System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.NonPublic);
                        tmpType = tmpType.BaseType;
                    }

                    if (field == null)
                    {
                        SkipFieldData();
                    }
                    else
                    {
                        field.SetValue(obj, Deserialize(field.FieldType));
                    }
                    TryEat(',');
                }
                return(obj);
            }
        }
        private UnityEngine.Object DeserializeUnityObjectInner()
        {
            string a = this.EatField();

            if (a == "InstanceID")
            {
                this.EatField();
                a = this.EatField();
            }
            if (a != "Name")
            {
                throw new Exception("Expected 'Name' field");
            }
            string text = this.EatField();

            if (text == null)
            {
                return(null);
            }
            if (this.EatField() != "Type")
            {
                throw new Exception("Expected 'Type' field");
            }
            string text2 = this.EatField();

            if (text2.IndexOf(',') != -1)
            {
                text2 = text2.Substring(0, text2.IndexOf(','));
            }
            Type type = WindowsStoreCompatibility.GetTypeInfo(typeof(AstarPath)).Assembly.GetType(text2);

            type = (type ?? WindowsStoreCompatibility.GetTypeInfo(typeof(Transform)).Assembly.GetType(text2));
            if (object.Equals(type, null))
            {
                Debug.LogError("Could not find type '" + text2 + "'. Cannot deserialize Unity reference");
                return(null);
            }
            this.EatWhitespace();
            if ((ushort)this.reader.Peek() == 34)
            {
                if (this.EatField() != "GUID")
                {
                    throw new Exception("Expected 'GUID' field");
                }
                string b = this.EatField();
                UnityReferenceHelper[] array = UnityEngine.Object.FindObjectsOfType <UnityReferenceHelper>();
                int i = 0;
                while (i < array.Length)
                {
                    UnityReferenceHelper unityReferenceHelper = array[i];
                    if (unityReferenceHelper.GetGUID() == b)
                    {
                        if (object.Equals(type, typeof(GameObject)))
                        {
                            return(unityReferenceHelper.gameObject);
                        }
                        return(unityReferenceHelper.GetComponent(type));
                    }
                    else
                    {
                        i++;
                    }
                }
            }
            UnityEngine.Object[] array2 = Resources.LoadAll(text, type);
            for (int j = 0; j < array2.Length; j++)
            {
                if (array2[j].name == text || array2.Length == 1)
                {
                    return(array2[j]);
                }
            }
            return(null);
        }
示例#5
0
        void Serialize(System.Object obj)
        {
            if (obj == null)
            {
                output.Append("null");
                return;
            }

            var type     = obj.GetType();
            var typeInfo = WindowsStoreCompatibility.GetTypeInfo(type);

            if (serializers.ContainsKey(type))
            {
                serializers[type] (obj);
            }
            else if (typeInfo.IsEnum)
            {
                output.Append('"' + obj.ToString() + '"');
            }
            else if (obj is System.Collections.IList)
            {
                output.Append("[");
                var arr = obj as System.Collections.IList;
                for (int i = 0; i < arr.Count; i++)
                {
                    if (i != 0)
                    {
                        output.Append(", ");
                    }
                    Serialize(arr[i]);
                }
                output.Append("]");
            }
            else if (obj is UnityEngine.Object)
            {
                SerializeUnityObject(obj as UnityEngine.Object);
            }
            else
            {
#if NETFX_CORE
                var optIn = typeInfo.CustomAttributes.Any(attr => attr.GetType() == typeof(JsonOptInAttribute));
#else
                var optIn = typeInfo.GetCustomAttributes(typeof(JsonOptInAttribute), true).Length > 0;
#endif
                output.Append("{");
                bool earlier = false;

                while (true)
                {
#if NETFX_CORE
                    var fields = typeInfo.DeclaredFields.Where(f => !f.IsStatic).ToArray();
#else
                    var fields = type.GetFields(System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.NonPublic);
#endif
                    foreach (var field in fields)
                    {
                        if (field.DeclaringType != type)
                        {
                            continue;
                        }
                        if ((!optIn && field.IsPublic) ||
#if NETFX_CORE
                            field.CustomAttributes.Any(attr => attr.GetType() == typeof(JsonMemberAttribute))
#else
                            field.GetCustomAttributes(typeof(JsonMemberAttribute), true).Length > 0
#endif
                            )
                        {
                            if (earlier)
                            {
                                output.Append(", ");
                            }

                            earlier = true;
                            output.AppendFormat("\"{0}\": ", field.Name);
                            Serialize(field.GetValue(obj));
                        }
                    }

#if NETFX_CORE
                    typeInfo = typeInfo.BaseType;
                    if (typeInfo == null)
                    {
                        break;
                    }
#else
                    type = type.BaseType;
                    if (type == null)
                    {
                        break;
                    }
#endif
                }
                output.Append("}");
            }
        }
示例#6
0
 /** Returns the first graph which inherits from the type \a type. Returns null if no graph was found. */
 public NavGraph FindGraphWhichInheritsFrom(System.Type type)
 {
     return(FindGraph(graph => WindowsStoreCompatibility.GetTypeInfo(type).IsAssignableFrom(WindowsStoreCompatibility.GetTypeInfo(graph.GetType()))));
 }
        // Token: 0x06002815 RID: 10261 RVA: 0x001B6830 File Offset: 0x001B4A30
        private void Serialize(object obj)
        {
            if (obj == null)
            {
                this.output.Append("null");
                return;
            }
            Type type     = obj.GetType();
            Type typeInfo = WindowsStoreCompatibility.GetTypeInfo(type);

            if (this.serializers.ContainsKey(type))
            {
                this.serializers[type](obj);
                return;
            }
            if (typeInfo.IsEnum)
            {
                this.output.Append("\"" + obj.ToString() + "\"");
                return;
            }
            if (obj is IList)
            {
                this.output.Append("[");
                IList list = obj as IList;
                for (int i = 0; i < list.Count; i++)
                {
                    if (i != 0)
                    {
                        this.output.Append(", ");
                    }
                    this.Serialize(list[i]);
                }
                this.output.Append("]");
                return;
            }
            if (obj is UnityEngine.Object)
            {
                this.SerializeUnityObject(obj as UnityEngine.Object);
                return;
            }
            bool flag = typeInfo.GetCustomAttributes(typeof(JsonOptInAttribute), true).Length != 0;

            this.output.Append("{");
            bool flag2 = false;

            do
            {
                foreach (FieldInfo fieldInfo in type.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic))
                {
                    if (!(fieldInfo.DeclaringType != type) && ((!flag && fieldInfo.IsPublic) || fieldInfo.GetCustomAttributes(typeof(JsonMemberAttribute), true).Length != 0))
                    {
                        if (flag2)
                        {
                            this.output.Append(", ");
                        }
                        flag2 = true;
                        this.output.AppendFormat("\"{0}\": ", fieldInfo.Name);
                        this.Serialize(fieldInfo.GetValue(obj));
                    }
                }
                type = type.BaseType;
            }while (!(type == null));
            this.output.Append("}");
        }
示例#8
0
 // Token: 0x060021F7 RID: 8695 RVA: 0x00191008 File Offset: 0x0018F208
 public NavGraph FindGraphWhichInheritsFrom(Type type)
 {
     return(this.FindGraph((NavGraph graph) => WindowsStoreCompatibility.GetTypeInfo(type).IsAssignableFrom(WindowsStoreCompatibility.GetTypeInfo(graph.GetType()))));
 }