/// <summary>
        /// Save data of the gameObjects which implemented and registed IDataSaveable interface
        /// </summary>
        public void SaveSceneData()
        {
            string sceneName = SceneManager.GetActiveScene().name;

            BinaryFormatter bf   = new BinaryFormatter();
            string          path = Path.Combine(Application.persistentDataPath, sceneName + "TinyExplorer.dat");
            FileStream      file = File.Create(path);

            foreach (IDataSaveable iDataSaveable in m_DataSaveables)
            {
                iDataSaveable.SaveData();
            }

            //Since Unity doesn't support serializing Dictionary, we have to convert it to List
            SerializableSavedData savedData = new SerializableSavedData();

            savedData.stringKeys = new List <string>(m_StringSavedData.Keys);
            savedData.stringData = new List <string>(m_StringSavedData.Values);

            savedData.intKeys = new List <string>(m_IntSavedData.Keys);
            savedData.intData = new List <int>(m_IntSavedData.Values);

            savedData.floatKeys = new List <string>(m_FloatSavedData.Keys);
            savedData.floatData = new List <float>(m_FloatSavedData.Values);

            savedData.boolKeys = new List <string>(m_BoolSavedData.Keys);
            savedData.boolData = new List <bool>(m_BoolSavedData.Values);

            savedData.vectorKeys = new List <string>(m_Vector3SavedData.Keys);
            savedData.vectorData = new List <SerializableVector3>(m_Vector3SavedData.Values);

            bf.Serialize(file, savedData);

            file.Close();
        }
Esempio n. 2
0
    public SerializableSavedData GetSeralizableData()
    {
        SerializableSavedData serializableData = new SerializableSavedData();

        serializableData.count         = count;
        serializableData.levelComplete = levelComplete;

        return(serializableData);
    }
Esempio n. 3
0
    public SerializableSavedData GetSeralizableData()
    {
        //Since Unity doesn't support serializing Dictionary, we have to convert it to List
        SerializableSavedData serializableData = new SerializableSavedData();

        serializableData.count = count;


        return(serializableData);
    }
Esempio n. 4
0
    public void Save(string additionalPath)
    {
        BinaryFormatter bf   = new BinaryFormatter();
        string          path = Path.Combine(Application.persistentDataPath, additionalPath + "MyOrdinaryLife.dat");
        FileStream      file = File.Create(path);

        //Since Unity doesn't support serializing Dictionary, we have to convert it to List
        SerializableSavedData serializableData = this.GetSeralizableData();

        bf.Serialize(file, serializableData);

        file.Close();
    }
Esempio n. 5
0
    /// <summary>
    /// Load custom data and return true
    /// </summary>
    /// <returns></returns>
    public bool Load(string addtionalPath)
    {
        string path = Path.Combine(Application.persistentDataPath, addtionalPath + "MyOrdinaryLife.dat");

        if (File.Exists(path))
        {
            BinaryFormatter bf   = new BinaryFormatter();
            FileStream      file = File.Open(path, FileMode.Open);

            SerializableSavedData serializableData = (SerializableSavedData)bf.Deserialize(file);

            this.FromSerializableData(serializableData);

            file.Close();

            return(true);
        }

        return(false);
    }
        /// <summary>
        /// Load custom data and return true
        /// </summary>
        /// <returns></returns>
        public SavedData LoadCustomData(string addtionalPath)
        {
            string path = Path.Combine(Application.persistentDataPath, addtionalPath + "TinyExplorer.dat");

            if (File.Exists(path))
            {
                BinaryFormatter bf   = new BinaryFormatter();
                FileStream      file = File.Open(path, FileMode.Open);

                SerializableSavedData serializableData = (SerializableSavedData)bf.Deserialize(file);

                SavedData savedData = new SavedData();
                savedData.FromSerializableData(serializableData);

                file.Close();

                return(savedData);
            }

            return(null);
        }
Esempio n. 7
0
    public SerializableSavedData GetSeralizableData()
    {
        //Since Unity doesn't support serializing Dictionary, we have to convert it to List
        SerializableSavedData serializableData = new SerializableSavedData();

        serializableData.stringKeys = new List <string>(m_StringSavedData.Keys);
        serializableData.stringData = new List <string>(m_StringSavedData.Values);

        serializableData.intKeys = new List <string>(m_IntSavedData.Keys);
        serializableData.intData = new List <int>(m_IntSavedData.Values);

        serializableData.floatKeys = new List <string>(m_FloatSavedData.Keys);
        serializableData.floatData = new List <float>(m_FloatSavedData.Values);

        serializableData.boolKeys = new List <string>(m_BoolSavedData.Keys);
        serializableData.boolData = new List <bool>(m_BoolSavedData.Values);

        serializableData.vectorKeys = new List <string>(m_Vector3SavedData.Keys);
        serializableData.vectorData = new List <SerializableVector3>(m_Vector3SavedData.Values);


        return(serializableData);
    }
Esempio n. 8
0
    public void FromSerializableData(SerializableSavedData serializableData)
    {
        //String data
        m_StringSavedData = new Dictionary <string, string>();
        for (int i = 0; i < serializableData.stringKeys.Count; i++)
        {
            m_StringSavedData.Add(serializableData.stringKeys[i], serializableData.stringData[i]);
        }

        //Int data
        m_IntSavedData = new Dictionary <string, int>();
        for (int i = 0; i < serializableData.intKeys.Count; i++)
        {
            m_IntSavedData.Add(serializableData.intKeys[i], serializableData.intData[i]);
        }

        //Float data
        m_FloatSavedData = new Dictionary <string, float>();
        for (int i = 0; i < serializableData.floatKeys.Count; i++)
        {
            m_FloatSavedData.Add(serializableData.floatKeys[i], serializableData.floatData[i]);
        }

        //Bool data
        m_BoolSavedData = new Dictionary <string, bool>();
        for (int i = 0; i < serializableData.boolKeys.Count; i++)
        {
            m_BoolSavedData.Add(serializableData.boolKeys[i], serializableData.boolData[i]);
        }

        //Vector data
        m_Vector3SavedData = new Dictionary <string, SerializableVector3>();
        for (int i = 0; i < serializableData.vectorKeys.Count; i++)
        {
            m_Vector3SavedData.Add(serializableData.vectorKeys[i], serializableData.vectorData[i]);
        }
    }
Esempio n. 9
0
 public void FromSerializableData(SerializableSavedData serializableData)
 {
     count = serializableData.count;
 }
        /// <summary>
        /// Load data of current scene and return true if data is successfully loaded or has already been loaded
        /// </summary>
        /// <returns></returns>
        public bool LoadSceneData()
        {
            if (m_DataLoaded)
            {
                return(true);
            }

            string sceneName = SceneManager.GetActiveScene().name;

            string path = Path.Combine(Application.persistentDataPath, sceneName + "TinyExplorer.dat");

            if (File.Exists(path))
            {
                BinaryFormatter bf   = new BinaryFormatter();
                FileStream      file = File.Open(path, FileMode.Open);

                SerializableSavedData savedData = (SerializableSavedData)bf.Deserialize(file);

                //String data
                m_StringSavedData = new Dictionary <string, string>();
                for (int i = 0; i < savedData.stringKeys.Count; i++)
                {
                    m_StringSavedData.Add(savedData.stringKeys[i], savedData.stringData[i]);
                }

                //Int data
                m_IntSavedData = new Dictionary <string, int>();
                for (int i = 0; i < savedData.intKeys.Count; i++)
                {
                    m_IntSavedData.Add(savedData.intKeys[i], savedData.intData[i]);
                }

                //Float data
                m_FloatSavedData = new Dictionary <string, float>();
                for (int i = 0; i < savedData.floatKeys.Count; i++)
                {
                    m_FloatSavedData.Add(savedData.floatKeys[i], savedData.floatData[i]);
                }

                //Bool data
                m_BoolSavedData = new Dictionary <string, bool>();
                for (int i = 0; i < savedData.boolKeys.Count; i++)
                {
                    m_BoolSavedData.Add(savedData.boolKeys[i], savedData.boolData[i]);
                }

                //Vector data
                m_Vector3SavedData = new Dictionary <string, SerializableVector3>();
                for (int i = 0; i < savedData.vectorKeys.Count; i++)
                {
                    m_Vector3SavedData.Add(savedData.vectorKeys[i], savedData.vectorData[i]);
                }

                foreach (IDataSaveable iDataSaveable in m_DataSaveables)
                {
                    iDataSaveable.LoadData();
                }

                m_DataLoaded = true;

                file.Close();

                return(true);
            }


            return(false);
        }
Esempio n. 11
0
 public void FromSerializableData(SerializableSavedData serializableData)
 {
     count         = serializableData.count;
     levelComplete = serializableData.levelComplete;
 }