making a "Save" feature in a console applcation

Hello,

The save and load feature are highly dependent on how your internal data are kept. Does your character has an inventory? Health? Does he walks on a map?

There's no real rule to savegames. If your game is simple, and you want to keep things simple, try using .INI files, like this:

[Player Character]
Health=100
Map=Venise
Location_X=10
Location_Y=32

... etc ...

If you didn't plan for a savegame from the start, you may need to rewrite quite a bit in order to implement it correctly.

If it's too hard and would cause too much of a rewrite, you could have the player save the game at key locations on the map.

Feel free to provide more information, and I'll do my best to help.

--Eric Fortier

thanks, Eric for the info

my game characters  will have health and an inventory and he explores Rooms

i just need to know how to make an .INI File and how does it work

--DRAGONOFSTORMS--

 

The implementation of the file format is all up to yourself. There is no rule on what these files look like, or what the include...

As suggested above, look up the documentation (a textbook if you have one, else http://www.cplusplus.com is a good reference) for the functions associated with file handling, and then design a file format which will work for your game system.

It all goes very easily once you've gotten the hang of the basic file read/write operations/procedures.

Good luck.

My IniFile reader/writer:

[source]
#include <windows.h>
#include <string>
#include <algorithm>
struct IniFile
     {
     std::string file;
     std::string section;
     
     IniFile()
          {}
     IniFile(const std::string& szFile, const std::string& szSection)
          : file(szFile), section(szSection)
          {}
     
     bool read(const std::string& key, std::string* property, std::string default_value = "")
          {
          char szBuf[256];
          BOOL b= GetPrivateProfileString(this->section.c_str(),
                                                key.c_str(),
                                                default_value.c_str(),
                                                szBuf, sizeof(szBuf),
                                                this->file.c_str());
          *property = szBuf;
          std::string::iterator it, it2, it3, end;
          end = property->end();
          it = property->begin();
          while(it!=end)
               {
               it = std::find(it, end, '[');
               if(it!=end)
                    {
                    it2 = std::find(it, end, '|');
                    if(it2!=end)
                         {
                         it3 = std::find(it2, end, ']');
                         if(it3!=end)
                              {    
                              std::string key;
                             
                              it++;
                              this->section = "";
                              this->section.reserve(it2-it);
                              std::copy(it, it2, std::inserter(this->section, this->section.begin()));
                              it2++;
                              key.reserve(it3-it2);
                              std::copy(it2, it3, std::inserter(key, key.begin()));
                              std::string subprop;
                              std::string temp;
                              temp.reserve(256);
                              if(!this->read(key, &subprop))
                                   return false;
                              it--;
                              std::insert_iterator<std::string> cp(temp, temp.begin());
                              cp = std::copy(property->begin(), it, cp);
                              cp = std::copy(subprop.begin(), subprop.end(), cp);
                              it3++;
                              cp = std::copy(it3, end, cp);
                             
                              *property = temp;
                              }
                         }
                    }
               }
          return (0!=b);
          }
     
     bool write(const std::string& key, const std::string& property)
          {
          return 0!=WritePrivateProfileString(this->section.c_str(),
                                                key.c_str(),
                                                property.c_str(),
                                                this->file.c_str());
          }
     bool write(const char*const key, const char*const property)
          {
          return 0!=WritePrivateProfileString(this->section.c_str(),
                                                key,
                                                property,
                                                this->file.c_str());
          }
     };
[/source]

This lets you use ini data in other ini keys, e.g.

[Paths]
Drive=C:
Home=[Paths|Drive]\HomeDir

And when you read in Paths|Home, you'll get C:\HomeDir

another (imho better variant) : use serializable objects.
Just implement interface and use it anywhere...
Any of your object will serialize itself and get/put all data it needed from/to stream.

you really don't need an ini file.  You could use a normal text file to save the data.  If you don't want someone editing the file (so they can get more stuff) then convert it to binary or encrypt it afterwards.  

an example layout of the file might be:

Health:
character attributes: str, wis, int, con, dex,
inventory: # of items
etc

the actual file would be

100
18 10 13 15 17
0 0 3 3 4 5 2 10 . . .
etc

use the file writing as shown


fstream fs("c:\\myfile.txt");
fs << health << endl;
fs << str << setw(1);  // creates a space between numbers, needed for when you input it back in.
fs << wis << setw(1);
.
.
.
fs << dex << endl;

when pulling in the stream:

istream sin("c:\\myfile.txt");
sin >> health;
sin >> str;
sin >> wis;
sin >> con;
etc.

Hi,

Not using an INI file or a formatted file is a huge mistake. Been there, done that.

One of the big reason why to use an INI file is that if you need to remove one of the entry in your savefile, you don't have to reformat the whole file.

For example, if you just write the strength, dexterity, wisdom and charisma to a file like this:

30
20
10
15

And if you decide that you don't want the dexterity anymore, you need to remove "20" and move every entry up one notch.

This doesn't happen with an INI or other formatted file. Save with adding data. Besides, it's easier to edit with a text editor.

Save yourself some trouble. Reading an ini file, especially if you load it to memory first is quick and painless.

--Eric Fortier