Object-Oriented 'Save Game' Techniques?

GreyArtist asks: "I took a course in C++ a year ago in which the instructor claimed that global (file-scope or inter-file-scope) variables were antiquated and not to be used under any circumstances. I immediately thought of a counter argument that involved the method I use for saving game data. The games (and many of the other programs) I write use not only global variables, but consecutive global variables declared in their own separate module. To save the game (or user settings) to file, I simply save a single large segment of data that contains all the necessary information. How do other coders do it? Would they create a 'MyObject.savemyself()' method for every object in their game? Do they save all the game code along with the data? Either way, it seems like a horrid case of code (or data) bloat. What do you die-hard object-oriented fanatics have to say about this, and what method they would you use for saving games?"

Comments

eh? mygame.savemethod()??

[torpor]

Would they create a 'MyObject.savemyself()' method for every object in their game?

isn't the purpose of 'object oriented programming' that you don't have to think like this? you just call the one big 'Game Object' save method, and .. all other derived/related objects, do their big save?

seems a bit wonky to me.

"game saves" is not just a game problem, of course. there are many, many parallels in other types of application .. embedded data loggers, for example, getting a warning that the shack is about to flood for winter, need to save their state too ..

for me, the 'global context save and restore' is a 'built-in' to the design. i'm rather fond of libs and services which provide persistence natively .. though i think that some would argue that mmap's to flash RAM are cheating ... ;)

Re:how about..

[vinsci]

You mean object prevalence like in Prevayler? See also here for a general presentation (intro here: Object Prevalence in C++).

Beware of Memory Dumps.

[Jason Pollock]

If you use a memory dump save (as it sounds to me) you will eventually notice several things:

1) The files aren't easily loaded between versions of the software.
2) The files aren't platform independent.
3) The files are very fragile, and very dependent on compiler options.

This is one of the complaints about Word document files - they can contain memory dumps. :)

However, for simple ease of implementation, nothing beats getting a pointer and writing a block of memory to disk.

Jason

Serialization

[SteveX]

It's called serialization, and most OO frameworks support it in some way or another.

Usually it's a way for an object to render itself to a stream, and reconstitute itself from a stream.

That way you can save the objects to disk, or send them over the network, or whatever else you need to do with them.

Every object serializes itself, and all of it's immediate children. Once every object does this, you can save the whole tree of objects with one call.