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