Exemple #1
0
        /// <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));
            }
        }
Exemple #2
0
        /// <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);
            }
        }
Exemple #3
0
        /// <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));
            }
        }
Exemple #4
0
        /// <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);
        }
Exemple #5
0
        /// <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);
            }
        }