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