public override void ReadInto <T>(ES3Reader reader, object obj) { var instance = (UnityEngine.Flare)obj; string propertyName; while ((propertyName = reader.ReadPropertyName()) != null) { switch (propertyName) { case "hideFlags": instance.hideFlags = reader.Read <UnityEngine.HideFlags>(); break; default: reader.Skip(); break; } } }
/// <summary>Merges the data specified by the bytes parameter into this ES3File.</summary> /// <param name="bytes">The bytes we want to merge with this ES3File.</param> /// <param name="settings">The settings we want to use to override the default settings.</param> public void SaveRaw(byte[] bytes, ES3Settings settings) { // Type checking must be enabled when syncing. var settingsWithTypeChecking = (ES3Settings)settings.Clone(); settingsWithTypeChecking.typeChecking = true; using (var reader = ES3Reader.Create(bytes, settingsWithTypeChecking)) { if (reader == null) { return; } foreach (KeyValuePair <string, ES3Data> kvp in reader.RawEnumerator) { cache [kvp.Key] = kvp.Value; } } }
protected override void ReadUnityObject <T>(ES3Reader reader, object obj) { var instance = (UnityEngine.Font)obj; string propertyName; while ((propertyName = reader.ReadPropertyName()) != null) { switch (propertyName) { case "material": instance.material = reader.Read <UnityEngine.Material>(ES3Type_Material.Instance); break; default: reader.Skip(); break; } } }
protected override object ReadObject <T>(ES3Reader reader) { var refMgr = ES3ReferenceMgrBase.Current; if (refMgr == null) { return(ReadUnityObject <T>(reader)); } long id = -1; UnityEngine.Object instance = null; foreach (string propertyName in reader.Properties) { if (propertyName == ES3ReferenceMgrBase.referencePropertyName) { if (refMgr == null) { throw new InvalidOperationException("An Easy Save 3 Manager is required to load references. To add one to your scene, exit playmode and go to Assets > Easy Save 3 > Add Manager to Scene"); } id = reader.Read_ref(); instance = refMgr.Get(id, type); if (instance != null) { break; } } else { reader.overridePropertiesName = propertyName; if (instance == null) { return(ReadUnityObject <T>(reader)); } break; } } ReadUnityObject <T>(reader, instance); return(instance); }
public override void ReadInto <T>(ES3Reader reader, object obj) { if (reader.StartReadCollection()) { throw new NullReferenceException("The Collection we are trying to load is stored as null, which is not allowed when using ReadInto methods."); } int itemsLoaded = 0; var queue = (Queue <T>)obj; // Iterate through each item in the collection and try to load it. foreach (var item in queue) { itemsLoaded++; if (!reader.StartReadCollectionItem()) { break; } reader.ReadInto <T>(item, elementType); // If we find a ']', we reached the end of the array. if (reader.EndReadCollectionItem()) { break; } // If there's still items to load, but we've reached the end of the collection we're loading into, throw an error. if (itemsLoaded == queue.Count) { throw new IndexOutOfRangeException("The collection we are loading is longer than the collection provided as a parameter."); } } // If we loaded fewer items than the parameter collection, throw index out of range exception. if (itemsLoaded != queue.Count) { throw new IndexOutOfRangeException("The collection we are loading is shorter than the collection provided as a parameter."); } reader.EndReadCollection(); }
/// <summary>Creates a new ES3File and loads the specified file into the ES3File if there is data to load.</summary> /// <param name="settings">The settings we want to use to override the default settings.</param> /// <param name="syncWithFile">Whether we should sync this ES3File with the one in storage immediately after creating it.</param> public ES3File(ES3Settings settings, bool syncWithFile) { this.settings = settings; this.syncWithFile = syncWithFile; if (syncWithFile) { using (var reader = ES3Reader.Create(settings)) { if (reader == null) { return; } foreach (KeyValuePair <string, ES3Data> kvp in reader.RawEnumerator) { cache[kvp.Key] = kvp.Value; } } } }
protected override void ReadObject <T>(ES3Reader reader, object obj) { var instance = (Assets.Scripts.Entities.Skills)obj; foreach (string propertyName in reader.Properties) { switch (propertyName) { case "<Melee>k__BackingField": reader.SetPrivateField("<Melee>k__BackingField", reader.Read <System.Int32>(), instance); break; case "<Ranged>k__BackingField": reader.SetPrivateField("<Ranged>k__BackingField", reader.Read <System.Int32>(), instance); break; case "<Sneak>k__BackingField": reader.SetPrivateField("<Sneak>k__BackingField", reader.Read <System.Int32>(), instance); break; case "<Endurance>k__BackingField": reader.SetPrivateField("<Endurance>k__BackingField", reader.Read <System.Int32>(), instance); break; case "<Healing>k__BackingField": reader.SetPrivateField("<Healing>k__BackingField", reader.Read <System.Int32>(), instance); break; case "<Survival>k__BackingField": reader.SetPrivateField("<Survival>k__BackingField", reader.Read <System.Int32>(), instance); break; case "_persuasion": reader.SetPrivateField("_persuasion", reader.Read <System.Int32>(), instance); break; default: reader.Skip(); break; } } }
protected override void ReadComponent <T>(ES3Reader reader, object obj) { var instance = (UnityEngine.BoxCollider2D)obj; foreach (string propertyName in reader.Properties) { switch (propertyName) { case "size": instance.size = reader.Read <UnityEngine.Vector2>(); break; case "density": instance.density = reader.Read <System.Single>(); break; case "isTrigger": instance.isTrigger = reader.Read <System.Boolean>(); break; case "usedByEffector": instance.usedByEffector = reader.Read <System.Boolean>(); break; case "offset": instance.offset = reader.Read <UnityEngine.Vector2>(); break; case "sharedMaterial": instance.sharedMaterial = reader.Read <UnityEngine.PhysicsMaterial2D>(); break; case "enabled": instance.enabled = reader.Read <System.Boolean>(); break; default: reader.Skip(); break; } } }
protected object ReadProperties(ES3Reader reader, object obj) { // Iterate through each property in the file and try to load it using the appropriate // ES3Member in the members array. foreach (string propertyName in reader.Properties) { // Find the property. ES3Member property = null; for (int i = 0; i < members.Length; i++) { if (members[i].name == propertyName) { property = members[i]; break; } } if (property == null) { reader.Skip(); } else { var type = ES3TypeMgr.GetOrCreateES3Type(property.type); if (ES3Reflection.IsAssignableFrom(typeof(IDictionary), property.type)) { property.reflectedMember.SetValue(obj, ((ES3DictionaryType)type).Read(reader)); } else if (ES3Reflection.IsAssignableFrom(typeof(ICollection), property.type)) { property.reflectedMember.SetValue(obj, ((ES3CollectionType)type).Read(reader)); } else { object readObj = reader.Read <object>(type); property.reflectedMember.SetValue(obj, readObj); } } } return(obj); }
protected override void ReadObject <T>(ES3Reader reader, object obj) { var instance = (Assets.Scripts.Effects.Blinded)obj; foreach (string propertyName in reader.Properties) { switch (propertyName) { case "LocationDependent": reader.SetPrivateField("LocationDependent", reader.Read <System.Boolean>(), instance); break; case "Stacks": reader.SetPrivateField("Stacks", reader.Read <System.Boolean>(), instance); break; case "Description": reader.SetPrivateField("Description", reader.Read <System.String>(), instance); break; case "TargetType": reader.SetPrivateField("TargetType", reader.Read <Assets.Scripts.TargetType>(), instance); break; case "<Icon>k__BackingField": reader.SetPrivateField("<Icon>k__BackingField", reader.Read <UnityEngine.Sprite>(), instance); break; case "<Name>k__BackingField": reader.SetPrivateField("<Name>k__BackingField", reader.Read <System.String>(), instance); break; case "_duration": reader.SetPrivateField("_duration", reader.Read <System.Int32>(), instance); break; default: reader.Skip(); break; } } }
public override object Read <T>(ES3Reader reader) { var prefabId = reader.ReadRefProperty(); // Load as ES3Refs and convert to longs. var localToGlobal_refs = reader.ReadProperty <Dictionary <ES3Ref, ES3Ref> >(); var localToGlobal = new Dictionary <long, long>(); foreach (var kvp in localToGlobal_refs) { localToGlobal.Add(kvp.Key.id, kvp.Value.id); } if (ES3ReferenceMgrBase.Current == null) { return(null); } var es3Prefab = ES3ReferenceMgrBase.Current.GetPrefab(prefabId); if (es3Prefab == null) { throw new MissingReferenceException("Prefab with ID " + prefabId + " could not be found.\nPress the 'Refresh References' button on the ES3ReferenceMgr Component of the Easy Save 3 Manager in the scene to refresh prefabs."); } #if UNITY_EDITOR // Use PrefabUtility.InstantiatePrefab if we're saving in the Editor and the application isn't playing. // This keeps the connection to the prefab, which is useful for Editor scripts saving data outside of runtime. var instance = Application.isPlaying ? GameObject.Instantiate(es3Prefab.gameObject) : PrefabUtility.InstantiatePrefab(es3Prefab.gameObject); #else var instance = GameObject.Instantiate(es3Prefab.gameObject); #endif var instanceES3Prefab = ((GameObject)instance).GetComponent <ES3Prefab>(); if (instanceES3Prefab == null) { throw new MissingReferenceException("Prefab with ID " + prefabId + " was found, but it does not have an ES3Prefab component attached."); } instanceES3Prefab.ApplyReferences(localToGlobal); return(instanceES3Prefab.gameObject); }
public override object Read(ES3Reader reader) { if (reader.StartReadCollection()) { return(null); } // Create a List to store the items as a 1D array, which we can work out the positions of by calculating the lengths of the two dimensions. var items = new List <object>(); int length1 = 0; // Iterate through each character until we reach the end of the array. while (true) { if (!reader.StartReadCollectionItem()) { break; } ReadICollection <object>(reader, items, elementType); length1++; if (reader.EndReadCollectionItem()) { break; } } int length2 = items.Count / length1; var array = ES3Reflection.ArrayCreateInstance(elementType.type, new int[] { length1, length2 }); for (int i = 0; i < length1; i++) { for (int j = 0; j < length2; j++) { array.SetValue(items[(i * length2) + j], i, j); } } return(array); }
protected override void ReadComponent <T>(ES3Reader reader, object obj) { var instance = (UIItem)obj; foreach (string propertyName in reader.Properties) { switch (propertyName) { case "item": instance.item = reader.Read <Item>(ES3Type_Item.Instance); break; case "isCraftingSlot": instance.isCraftingSlot = reader.Read <System.Boolean>(ES3Type_bool.Instance); break; case "isCraftingResultSlot": instance.isCraftingResultSlot = reader.Read <System.Boolean>(ES3Type_bool.Instance); break; case "isPlayerEquipmentSlot": instance.isPlayerEquipmentSlot = reader.Read <System.Boolean>(ES3Type_bool.Instance); break; case "isConsumableInventorySlot": instance.isConsumableInventorySlot = reader.Read <System.Boolean>(ES3Type_bool.Instance); break; case "isCraftingInventorySlot": instance.isCraftingInventorySlot = reader.Read <System.Boolean>(ES3Type_bool.Instance); break; case "isConsumableItemSlot": instance.isConsumableItemSlot = reader.Read <System.Boolean>(ES3Type_bool.Instance); break; default: reader.Skip(); break; } } }
protected override void ReadComponent <T>(ES3Reader reader, object obj) { var instance = (HexCell)obj; foreach (string propertyName in reader.Properties) { switch (propertyName) { case "coordinates": instance.coordinates = reader.Read <HexCoordinates>(); break; case "isOccupied": instance.isOccupied = reader.Read <System.Boolean>(ES3Type_bool.Instance); break; case "position": instance.position = reader.Read <UnityEngine.Transform>(ES3Type_Transform.Instance); break; case "tileType": instance.tileType = reader.Read <TileType>(); break; case "isVisible": instance.isVisible = reader.Read <System.Boolean>(ES3Type_bool.Instance); break; case "visionField": instance.visionField = reader.Read <System.Int32>(ES3Type_int.Instance); break; case "currentInfo": instance.currentInfo = reader.Read <TileInfo>(ES3Type_TileInfo.Instance); break; default: reader.Skip(); break; } } }
public override object Read <T>(ES3Reader reader) { LayerMask instance = new LayerMask(); string propertyName; while ((propertyName = reader.ReadPropertyName()) != null) { switch (propertyName) { case "value": instance = reader.Read <int>(ES3Type_int.Instance); break; default: reader.Skip(); break; } } return(instance); }
protected override object ReadUnityObject <T>(ES3Reader reader) { string name = ""; int samples = 0; int channels = 0; int frequency = 0; AudioClip clip = null; foreach (string propertyName in reader.Properties) { switch (propertyName) { case "name": name = reader.Read <string>(ES3Type_string.Instance); break; case "samples": samples = reader.Read <int>(ES3Type_int.Instance); break; case "channels": channels = reader.Read <int>(ES3Type_int.Instance); break; case "frequency": frequency = reader.Read <int>(ES3Type_int.Instance); break; case "sampleData": clip = AudioClip.Create(name, samples, channels, frequency, false); clip.SetData(reader.Read <float[]>(ES3Type_floatArray.Instance), 0); break; default: reader.Skip(); break; } } return(clip); }
protected override void ReadObject <T>(ES3Reader reader, object obj) { var instance = (UnityEngine.GameObject)obj; foreach (string propertyName in reader.Properties) { switch (propertyName) { case "prefab": break; case "layer": instance.layer = reader.Read <System.Int32>(ES3Type_int.Instance); break; case "tag": instance.tag = reader.Read <System.String>(ES3Type_string.Instance); break; case "name": instance.name = reader.Read <System.String>(ES3Type_string.Instance); break; case "hideFlags": instance.hideFlags = reader.Read <UnityEngine.HideFlags>(); break; case "children": reader.Read <GameObject[]>(); break; case "components": reader.Read <Component[]>(); break; default: reader.Skip(); break; } } }
protected override object ReadUnityObject <T>(ES3Reader reader) { Texture2D texture = null; Rect rect = Rect.zero; Vector2 pivot = Vector2.zero; float pixelsPerUnit = 0; Vector4 border = Vector4.zero; foreach (string propertyName in reader.Properties) { switch (propertyName) { case "texture": texture = reader.Read <UnityEngine.Texture2D>(ES3Type_Texture2D.Instance); break; case "textureRect": case "rect": rect = reader.Read <Rect>(ES3Type_Rect.Instance); break; case "pivot": pivot = reader.Read <UnityEngine.Vector2>(ES3Type_Vector2.Instance); break; case "pixelsPerUnit": pixelsPerUnit = reader.Read <System.Single>(ES3Type_float.Instance); break; case "border": border = reader.Read <Vector4>(ES3Type_Vector4.Instance); break; default: reader.Skip(); break; } } return(Sprite.Create(texture, rect, pivot, pixelsPerUnit, 0, SpriteMeshType.Tight, border)); }
public override object Read <T>(ES3Reader reader) { if (members == null) { GetMembers(reader.settings.safeReflection); } object obj; string propertyName = reader.ReadPropertyName(); // If we're loading a derived type, use it's specific ES3Type. if (propertyName == ES3Type.typeFieldName) { return(ES3TypeMgr.GetOrCreateES3Type(reader.ReadType()).Read <T>(reader)); } // If we're loading a reference, load it. Else, create an instance. if (propertyName == ES3ReferenceMgrBase.referencePropertyName) { long id = reader.Read <long>(ES3Type_long.Instance); obj = ES3ReferenceMgrBase.Current.Get(id); if (obj == null) { // If an instance isn't already registered for this object, create an instance and register the reference. obj = ES3Reflection.CreateInstance(this.type); ES3ReferenceMgrBase.Current.Add((UnityEngine.Object)obj, id); } } else { reader.overridePropertiesName = propertyName; obj = ES3Reflection.CreateInstance(this.type); } // Iterate through each property in the file and try to load it using the appropriate // ES3Property in the members array. ReadProperties(reader, obj); return(obj); }
public override void ReadInto <T>(ES3Reader reader, object obj) { var instance = (UnityEngine.ParticleSystem.TriggerModule)obj; string propertyName; while ((propertyName = reader.ReadPropertyName()) != null) { switch (propertyName) { case "enabled": instance.enabled = reader.Read <System.Boolean>(ES3Type_bool.Instance); break; case "inside": instance.inside = reader.Read <UnityEngine.ParticleSystemOverlapAction>(); break; case "outside": instance.outside = reader.Read <UnityEngine.ParticleSystemOverlapAction>(); break; case "enter": instance.enter = reader.Read <UnityEngine.ParticleSystemOverlapAction>(); break; case "exit": instance.exit = reader.Read <UnityEngine.ParticleSystemOverlapAction>(); break; case "radiusScale": instance.radiusScale = reader.Read <System.Single>(ES3Type_float.Instance); break; default: reader.Skip(); break; } } }
protected override void ReadObject <T>(ES3Reader reader, object obj) { var instance = (HK.AutoAnt.UserControllers.History)obj; foreach (string propertyName in reader.Properties) { switch (propertyName) { case "game": reader.SetPrivateField("game", reader.Read <HK.AutoAnt.UserControllers.GameHistory>(), instance); break; case "generateCellEvent": reader.SetPrivateField("generateCellEvent", reader.Read <HK.AutoAnt.UserControllers.GenerateCellEventHistory>(), instance); break; default: reader.Skip(); break; } } }
public override void ReadInto <T>(ES3Reader reader, object obj) { var instance = (UnityEngine.Shader)obj; foreach (string propertyName in reader.Properties) { switch (propertyName) { case "name": instance.name = reader.Read <string>(ES3Type_string.Instance); break; case "maximumLOD": instance.maximumLOD = reader.Read <System.Int32>(ES3Type_int.Instance); break; default: reader.Skip(); break; } } }
protected override void ReadObject <T>(ES3Reader reader, object obj) { var refMgr = ES3ReferenceMgrBase.Current; if (refMgr != null) { foreach (string propertyName in reader.Properties) { if (propertyName == ES3ReferenceMgrBase.referencePropertyName) { // If the object we're loading into isn't registered with the reference manager, register it. refMgr.Add((UnityEngine.Object)obj, reader.Read_ref()); } else { reader.overridePropertiesName = propertyName; break; } } } ReadUnityObject <T>(reader, obj); }
public override object Read <T>(ES3Reader reader) { return(Read(reader)); /*if(reader.StartReadCollection()) * return null; * * var stack = new Stack<T>(); * * // Iterate through each character until we reach the end of the array. * while(true) * { * if(!reader.StartReadCollectionItem()) * break; * stack.Push(reader.Read<T>(elementType)); * if(reader.EndReadCollectionItem()) * break; * } * * reader.EndReadCollection(); * return stack;*/ }
protected override void ReadObject <T>(ES3Reader reader, object obj) { var instance = (HK.AutoAnt.UserControllers.UnlockCellBundle)obj; foreach (string propertyName in reader.Properties) { switch (propertyName) { case "nextPopulation": reader.SetPrivateField("nextPopulation", reader.Read <System.Double>(), instance); break; case "targetRecordIds": reader.SetPrivateField("targetRecordIds", reader.Read <System.Collections.Generic.List <System.Int32> >(), instance); break; default: reader.Skip(); break; } } }
protected override object ReadObject <T>(ES3Reader reader) { var refMgr = ES3ReferenceMgrBase.Current; if (refMgr == null) { return(ReadUnityObject <T>(reader)); } long id = -1; UnityEngine.Object instance = null; foreach (string propertyName in reader.Properties) { if (propertyName == ES3ReferenceMgrBase.referencePropertyName && refMgr != null) { id = reader.Read <long>(ES3Type_long.Instance); instance = refMgr.Get(id); if (instance != null) { break; } } else { reader.overridePropertiesName = propertyName; if (instance == null) { return(ReadUnityObject <T>(reader)); } break; } } ReadUnityObject <T>(reader, instance); return(instance); }
protected override void ReadObject <T>(ES3Reader reader, object obj) { var instance = (UnityEngine.PhysicsMaterial2D)obj; foreach (string propertyName in reader.Properties) { switch (propertyName) { case "bounciness": instance.bounciness = reader.Read <System.Single>(ES3Type_float.Instance); break; case "friction": instance.friction = reader.Read <System.Single>(ES3Type_float.Instance); break; default: reader.Skip(); break; } } }
protected override void ReadObject <T>(ES3Reader reader, object obj) { var instance = (HK.AutoAnt.SaveData.Serializables.SerializableCellMapper)obj; foreach (string propertyName in reader.Properties) { switch (propertyName) { case "Cells": instance.Cells = reader.Read <System.Collections.Generic.List <HK.AutoAnt.SaveData.Serializables.SerializableCell> >(); break; case "CellEvents": instance.CellEvents = reader.Read <System.Collections.Generic.List <HK.AutoAnt.CellControllers.Events.ICellEvent> >(); break; default: reader.Skip(); break; } } }
protected override void ReadObject <T>(ES3Reader reader, object obj) { var instance = (Item)obj; foreach (string propertyName in reader.Properties) { switch (propertyName) { case "itemType": instance.itemType = reader.Read <Item.ItemType>(); break; case "amount": instance.amount = reader.Read <System.Int32>(ES3Type_int.Instance); break; default: reader.Skip(); break; } } }
protected override void ReadComponent <T>(ES3Reader reader, object obj) { var instance = (ShowTooltip)obj; foreach (string propertyName in reader.Properties) { switch (propertyName) { case "tooltip": reader.SetPrivateField("tooltip", reader.Read <Tooltip>(), instance); break; case "thisTooltipString": reader.SetPrivateField("thisTooltipString", reader.Read <System.String>(), instance); break; default: reader.Skip(); break; } } }