How to script a Save/Load game option

Question

I would like to be able to save and load a players progress to a players hard disk.

as an example if i have a player that collects 3 gems then a door will open automatically when the 3rd gem is collected. so id like to be able to save the location of the player (in the world or at a save location spot) as well as save the information that the crystals have been collected (i assume each crystal would have a unique name such as crystal_A crystal_B etc...so that when the player loads the game all the crystals won't be loaded again just the ones that have not been collected. )

I would like this system to work as a stand alone game (not a web browser run game) is it possible? does anyone know how?

OH and the reason for the hard disk save is so that if the player has to wipe the pc clean the player should be able to fine the directory where the file is saved and back up his save game. (this has saved me from loosing all my hard work on games i've played in the past when antivirus failed to protect my pc)

Answer 1

There are loads of solutions to that. The most used one is called PlayerPrefs and some documentation about that can be found in the docs. That approach does not save the data to a file which you can place anywhere you want though so that solution might be out of the question.

The second solution is called XML serialization and can automatically generate an XML file from a class, it can also put together the class from an XML class so you won't need to worry about writing your own parser. On the wiki there is a full example script using XML serialization.

The third option is using mono's serialization class, it works much like the XML serializer but requires a bit more work but is a lot more stable in return. I don't have any code here so I don't remember where the documentation is, a search on the forums always yields good results though.

The fourth option is to write a parser of your own, I have tried this and it is quite hard, especially when dealing with floats (vectors too). Documentation about this can be found when searching for XML text writer or StringWriter.

Hope this gives you some ideas! If you decide to use one option I can explain more about that then.

[Edit] Well I though a bit about the XML serialization, and actually I don't think it will be very good for your game to store it that way. The XML will look something like this

<Player>
  <Score score=245>
  <Life life=85>
</Player>

Which means the player will be able to open the XML file in a text editor and change whatever he/she wants, and that isn't so good, is it?

Stable wasn't the right word I think, limited would suite better, for example the XML serializer can't save Hashtables or any special stuff, neither can it save classes other than primitive types (I can't anyway, I have heard that it should work).

So I think the "ordinary" serializer would work better for you.

If you still want to use the XML serializer you can take a look here

The Serializer works like this:

You create a holder class for everything you want to save and then you mark it with the Serializable attribute:

[Serializable ()] public class SaveData : ISerializable { public bool foundGem1 = false; public float score = 42; public int levelReached = 3;

 public SaveData () {
 }

Then you have to define functions for how the class should be loaded and how it should be saved, these should be put inside the class.

public SaveData (SerializationInfo info, StreamingContext ctxt) { //Get the values from info and assign them to the appropriate properties foundGem1 = (bool)info.GetValue("foundGem1", typeof(bool)); score = (float)info.GetValue("score", typeof(float));

     levelReached = (int)info.GetValue("levelReached", typeof(int));
 }

 //Serialization function.

 public void GetObjectData (SerializationInfo info, StreamingContext ctxt)
 {

     info.AddValue("foundGem1", (foundGem1));
     info.AddValue("score", score);
     info.AddValue("levelReached", levelReached);
 }

The only thing left now is the save and load functions in your script.

public void Save () {

 SaveData data = new SaveData ();

 Stream stream = File.Open("MySavedGame.game", FileMode.Create);
 BinaryFormatter bformatter = new BinaryFormatter();
     bformatter.Binder = new VersionDeserializationBinder(); 
 Debug.Log ("Writing Information");
 bformatter.Serialize(stream, data);
 stream.Close();

public void Load () {

 SaveData data = new SaveData ();
 Stream stream = File.Open("MySavedGame.gamed", FileMode.Open);
 BinaryFormatter bformatter = new BinaryFormatter();
 bformatter.Binder = new VersionDeserializationBinder(); 
 Debug.Log ("Reading Data");
 data = (SaveData)bformatter.Deserialize(stream);
 stream.Close();

Oh, just one thing more, you need to define a VersionDeserializationBinder class, otherwise you can't load the game when you open it later, something about Unity generates a new key of some sort for the binary formatter, search for "Serialization" on the forum and you can find a post about that.

public sealed class VersionDeserializationBinder : SerializationBinder { public override Type BindToType( string assemblyName, string typeName ) { if ( !string.IsNullOrEmpty( assemblyName ) && !string.IsNullOrEmpty( typeName ) ) { Type typeToDeserialize = null;

         assemblyName = Assembly.GetExecutingAssembly().FullName; 

         // The following line of code returns the type. 
         typeToDeserialize = Type.GetType( String.Format( "{0}, {1}", typeName, assemblyName ) ); 

         return typeToDeserialize; 
     } 

     return null; 
 }

You will need to use these namespaces to get it working:

using System.Text; using System.IO; using System.Runtime.Serialization.Formatters.Binary;

using System;
using System.Runtime.Serialization;
using System.Reflection;

Done, at last :D

Answer 2

I took TowerOfBricks's code for data serialization and put it together into a single script, complete with thorough commenting. Might be good for people looking to understand the save/load process a little better.

 using UnityEngine;    // For Debug.Log, etc.
 
 using System.Text;
 using System.IO;
 using System.Runtime.Serialization.Formatters.Binary;
 
 using System;
 using System.Runtime.Serialization;
 using System.Reflection;
 
 // === This is the info container class ===
 [Serializable ()]
 public class SaveData : ISerializable {
 
   // === Values ===
   // Edit these during gameplay
   public bool foundGem1 = false;
   public float score = 42;
   public int levelReached = 3;
   // === /Values ===
 
   // The default constructor. Included for when we call it during Save() and Load()
   public SaveData () {}
 
   // This constructor is called automatically by the parent class, ISerializable
   // We get to custom-implement the serialization process here
   public SaveData (SerializationInfo info, StreamingContext ctxt)
   {
     // Get the values from info and assign them to the appropriate properties. Make sure to cast each variable.
     // Do this for each var defined in the Values section above
     foundGem1 = (bool)info.GetValue("foundGem1", typeof(bool));
     score = (float)info.GetValue("score", typeof(float));
 
     levelReached = (int)info.GetValue("levelReached", typeof(int));
   }
 
   // Required by the ISerializable class to be properly serialized. This is called automatically
   public void GetObjectData (SerializationInfo info, StreamingContext ctxt)
   {
     // Repeat this for each var defined in the Values section
     info.AddValue("foundGem1", (foundGem1));
     info.AddValue("score", score);
     info.AddValue("levelReached", levelReached);
   }
 }
 
 // === This is the class that will be accessed from scripts ===
 public class SaveLoad {
 
   public static string currentFilePath = "SaveData.cjc";    // Edit this for different save files
 
   // Call this to write data
   public static void Save ()  // Overloaded
   {
     Save (currentFilePath);
   }
   public static void Save (string filePath)
   {
     SaveData data = new SaveData ();
 
     Stream stream = File.Open(filePath, FileMode.Create);
     BinaryFormatter bformatter = new BinaryFormatter();
     bformatter.Binder = new VersionDeserializationBinder(); 
     bformatter.Serialize(stream, data);
     stream.Close();
   }
 
   // Call this to load from a file into "data"
   public static void Load ()  { Load(currentFilePath);  }   // Overloaded
   public static void Load (string filePath) 
   {
     SaveData data = new SaveData ();
     Stream stream = File.Open(filePath, FileMode.Open);
     BinaryFormatter bformatter = new BinaryFormatter();
     bformatter.Binder = new VersionDeserializationBinder(); 
     data = (SaveData)bformatter.Deserialize(stream);
     stream.Close();
 
     // Now use "data" to access your Values
   }
 
 }
 
 // === This is required to guarantee a fixed serialization assembly name, which Unity likes to randomize on each compile
 // Do not change this
 public sealed class VersionDeserializationBinder : SerializationBinder 
 { 
     public override Type BindToType( string assemblyName, string typeName )
     { 
         if ( !string.IsNullOrEmpty( assemblyName ) && !string.IsNullOrEmpty( typeName ) ) 
         { 
             Type typeToDeserialize = null; 
 
             assemblyName = Assembly.GetExecutingAssembly().FullName; 
 
             // The following line of code returns the type. 
             typeToDeserialize = Type.GetType( String.Format( "{0}, {1}", typeName, assemblyName ) ); 
 
             return typeToDeserialize; 
         } 
 
         return null; 
     } 
 }

Answer 3

Answer by Ehren · Dec 01, 2009 at 05:03 PM

Another option is to purchase a third-party save/restore tool, such as EZ Game Saver from Above & Beyond Software.

Add comment · Show 2 · Share

reboot2009 · Dec 01, 2009 at 06:05 PM 0

Share

that is an excellent suggestion! unfortunately it is currently out of my price range.

Statement · Feb 19, 2010 at 09:46 AM 5

Share

Remember that it is always good to evaluate existing solutions as coding your own may cost you more in time and maintainance than to pay the price up front (given it works as expected and fulfill your needs).

Answer 4

Answer by Thoben · Oct 13, 2010 at 04:02 PM

@The Stone: Big THX for sharing, this serialization works perfectly.

I've tested it on the iPad with Unity 3. You can use it the exact way, except you have to choose carefully where to save and load the file, because you only have restricted access to the device's folders.

For me the Application's "Documents" folder worked very well:

Stream stream = File.Create(Application.dataPath + "/../../Documents/" + "MySavedGame.game");

Use the same path for loading.

Add comment · Share

Answer 5

Answer by Kevin Tweedy · Jul 26, 2010 at 06:39 AM

Maybe another option would be to serialize to XML then zip up or encrypt the XML in some way and save it out to disk.

Add comment · Show 1 · Share

shadowpuppet · Dec 11, 2017 at 05:58 AM 0

Share

I'm fine with using player prefs. Personally if someone wants to hack into it to cheat let them - at least for my games because there is no global leaderboard or cash awards and what ids the point of playing if take away the challenge by giving yourself God$$anonymous$$ode or unlimited ammo or extra cash points. I think people that into game do so for the challenge and if you take away the challenge by storing game info in a file a 5 year old could alter it kind of di$$anonymous$$ishes the feat of having hacked as well as wrecking gameplay

How to script a Save/Load game option

17 Replies

Your answer

Follow this Question

Related Questions