/// <summary>
/// Deserializes a file from the Unity Resources folder and returns it as the provided object type.
/// </summary>
/// <typeparam name="T">Object type to deserialize file into</typeparam>
/// <param name="fileName">Name of the file to deserialize</param>
/// <returns>Deserialized file in the provided type</returns>
private static T loadFromPersistentFolder <T> (string fileName)
{
string filePath = UnityTools.getPersistentFilePath() + "/" + fileName;
//make sure file exists
if (SystemTools.fileExists(filePath) == false)
{
DS_MessageLogger.logMessageToUnityConsole("Failed to find file '" + fileName + "' when loading the" +
"file for deserialization on the loadSave() call.", SerializerLogType.Warning);
return(default(T));
}
//Try to load the file
try
{
BinaryFormatter binaryFormatter = new BinaryFormatter();
FileStream fileStream = new FileStream(filePath, FileMode.Open);
T returnObject = (T)binaryFormatter.Deserialize(fileStream);
fileStream.Close();
return(returnObject);
}
catch (IOException)
{
DS_MessageLogger.logMessageToUnityConsole("An IO exception occurred while trying to load '" +
fileName + "' in the Persistent build folder.", SerializerLogType.Error);
return(default(T));
}
catch (Exception)
{
DS_MessageLogger.logMessageToUnityConsole("An unknown exception occurred while trying to load '" +
fileName + "' in the Persistent build folder.", SerializerLogType.Error);
return(default(T));
}
}
/// <summary>
/// Takes the name of the Unity stored TextAsset and reserializes it to a persistent location for access and modification
/// </summary>
/// <param name="fileName">Name of the file in the Resources Folder</param>
private static void unpackFile(string fileName)
{
try
{
TextAsset textAsset = Resources.Load(fileName) as TextAsset;
MemoryStream memoryStream = new MemoryStream(textAsset.bytes);
string filePath = UnityTools.getPersistentFilePath() + "/" + filenamePrefix + fileName + fileNameExtension;
FileStream fileStream = new FileStream(filePath, FileMode.Create, FileAccess.Write);
memoryStream.WriteTo(fileStream);
fileStream.Close();
memoryStream.Close();
}
catch (IOException)
{
string message = "When trying to unpack file '" + fileName + "', an IO exception occured and the file was not unpacked.";
DS_MessageLogger.logMessageToBuildFile(message, SerializerLogType.Error);
return;
}
catch (Exception)
{
string message = "When trying to unpack file '" + fileName + "', an unknown exception occured and the file was not unpacked.";
DS_MessageLogger.logMessageToBuildFile(message, SerializerLogType.Error);
}
}
/// <summary>
/// Loads a saved file by name in engine and build. isPersistent Only used when in engine.
/// </summary>
/// <typeparam name="T">Object type to deserialize file into</typeparam>
/// <param name="fileName">Name of file</param>
/// <param name="isPersistent">Is the file marked as persistent? Not checked in build.</param>
/// <returns>Type T if file exists, default value of T otherwise.</returns>
public static T loadObject <T> (string fileName, bool isPersistent)
{
//Convert name to valid file path format
if (fileName.StartsWith(filenamePrefix))
{
fileName = fileName + fileNameExtension;
}
else
{
fileName = filenamePrefix + fileName + fileNameExtension;
}
//Check for where the file is saved in engine
if (UnityTools.isRunningInEngine())
{
//If it's persistent we're looking in the Resources Folder
if (isPersistent)
{
return(loadFromResourcesFolder <T>(fileName));
}
//Otherwise its in the dev binaries
else
{
return(loadFromDeveloperBinariesFolder <T>(fileName));
}
}
//otherwise its in the persistent folder
else
{
return(loadFromPersistentFolder <T>(fileName));
}
}
/// <summary>
/// Saves the object to a binary file in the PersistentPath for post deployment saves
/// </summary>
/// <typeparam name="T">Object type to be serialized</typeparam>
/// <param name="objectToSave">Object to be serialized</param>
/// <param name="fileName">Name to save the file under</param>
private static void serializeObject_Build(object objectToSave, string fileName)
{
//Initialize objects for use
BinaryFormatter binaryFormatter;
FileStream fileStream;
//Build file name and save reference
fileName = filenamePrefix + fileName;
string filePath = UnityTools.getPersistentFilePath() + "/" + filenamePrefix + fileName + fileNameExtension;
//Serialize the new Object provided by the Dev
try
{
//Create stream and formatter
binaryFormatter = new BinaryFormatter();
fileStream = new FileStream(filePath, FileMode.Create);
//Serialize file and close stream
binaryFormatter.Serialize(fileStream, objectToSave);
fileStream.Close();
}
catch (IOException)
{
DS_MessageLogger.logMessageToUnityConsole("An unexpected IO failure occured when trying to serialize the provided object to the" +
" Persistent File Path in build. " +
"Process is being aborted! \n" +
"Class Name: " + SystemTools.getObjectName(objectToSave), SerializerLogType.Error);
return;
}
catch (Exception)
{
DS_MessageLogger.logMessageToUnityConsole("An unknown failure occured when trying to serialize the provided object to the " +
" Persistent File Path in build." +
"Process is being aborted! \n" +
"Class Name: " + SystemTools.getObjectName(objectToSave), SerializerLogType.Error);
return;
}
//Log the save if messages are enabled
DS_MessageLogger.logMessageToUnityConsole(SystemTools.getObjectName(objectToSave) + " was saved successfully", SerializerLogType.Standard);
}
/// <summary>
/// Saves the provided Object to a binary file. If marked as persistent the file is saved to the Resources folder to be rebuilt for
/// builds of the game. If called in game build the isPersistentInBuild parameter is ignored.
/// </summary>
/// <typeparam name="T">Type of Object to save</typeparam>
/// <param name="objectToSave">Object to be saved</param>
/// <param name="isPersistentInBuild">Determines if the file is saved to the resources folder to keep persistent in game build</param>
public static void saveObject(object objectToSave, string fileName, bool isPersistentInBuild)
{
//Preliminary check to make sure the provided Object is serializable
if (SystemTools.isSerializable(objectToSave) == false)
{
DS_MessageLogger.logNonSerializableObjectCall(objectToSave);
return;
}
//Check if we're running in build or engine - Save to correct location
if (UnityTools.isRunningInEngine())
{
//Guarentee file paths exists
makeSureResourcesExists();
makeSureNonPersistentPathExists();
//Saves the object to the persistent location using a thread.
//Threading is used to make sure that OS read/write cycles do not prevent multiple saves from stopping each other from updating
//or saving to the FNTP file
if (isPersistentInBuild)
{
Thread saveThread = new Thread(() => serializeObject_Persistent(objectToSave, fileName));
saveThread.Start();
}
//Save to DevelopmentBinaries for dev only
else
{
serializeObject_Developer(objectToSave, fileName);
}
}
//Otherwise we're in a build of the game and can save normally
else
{
serializeObject_Build(objectToSave, fileName);
}
}