Come posso scrivere un sistema di salvataggio / caricamento per il mio gioco?

Sto cercando di trovare un modo per scrivere un sistema di salvataggio / caricamento per il mio gioco in C ++. A partire da ora, sto facendo tutto usando flag binari. Qualcuno ha idea di come farlo in un altro modo? Non mi dispiace usare il binario, ma voglio conoscere le mie opzioni. Voglio anche qualcosa in cui sarebbe facile controllare lo stato di un solo evento come completo o incompleto al fine di decidere determinate cose (molti sistemi di oggetti in questo gioco dipendono da ciò che il giocatore ha o non ha fatto nel corso del gioco).

La serializzazione sarebbe la strada da percorrere, e per quanto riguarda il controllo dello stato, potresti avere una logica nel metodo di deserializzazione per farlo.

Ho studiato un po 'il codice sorgente DOOM. Ti dirò come è fatto lì.

D_DoomMain contiene tutte le funzioni open / save / load, oltre a una serie di altre cose. Come dice all'inizio del file,

// DESCRIPTION:
//      DOOM main program (D_DoomMain) and game loop (D_DoomLoop),
//      plus functions to determine game mode (shareware, registered),
//      parse command line parameters, configure game parameters (turbo),
//      and call the startup functions.

Fondamentalmente, l'intero file è pieno di messaggi M_CheckParmdall'inizio alla fine. Ecco in cosa consiste D_DoomLoop. È un loop enorme (qualcosa come 1000-2000 linee di lunghezza).

Poiché la tua domanda è "Come posso scrivere?" Ho appena intenzione di incollare alcuni bit di codice che si riferiscono a gamesaves, da D_DoomMain:

ecco le dichiarazioni in cui quella roba viene utilizzata, alla fine del ciclo.

   p = M_CheckParm ("-loadgame");
   if (p && p < myargc-1)
   {
       if (M_CheckParm("-cdrom"))
           sprintf(file, "c:\\doomdata\\"SAVEGAMENAME"%c.dsg",myargv[p+1][0]);
       else
           sprintf(file, SAVEGAMENAME"%c.dsg",myargv[p+1][0]);
       G_LoadGame (file);
   }


   if ( gameaction != ga_loadgame )
   {
       if (autostart || netgame)
           G_InitNew (startskill, startepisode, startmap);
       else
           D_StartTitle ();                // start up intro loop

   }

   D_DoomLoop ();  // never returns

Ecco la funzione che accede alle stringhe, che trovi sparse in tutto il codice:

void M_ReadSaveStrings(void)
{
   int             handle;
   int             count;
   int             i;
   char    name[256];

   for (i = 0;i < load_end;i++)
   {
       if (M_CheckParm("-cdrom"))
           sprintf(name,"c:\\doomdata\\"SAVEGAMENAME"%d.dsg",i);
       else
           sprintf(name,SAVEGAMENAME"%d.dsg",i);

       handle = open (name, O_RDONLY | 0, 0666);
       if (handle == -1)
       {
           strcpy(&savegamestrings[i][0],EMPTYSTRING);
           LoadMenu[i].status = 0;
           continue;
       }
       count = read (handle, &savegamestrings[i], SAVESTRINGSIZE);
       close (handle);
       LoadMenu[i].status = 1;
   }
}

Hai anche un file chiamato p_savegame.c con cose che salveranno tutti i dati associati all'utente (quali armi hai, dove sei in quale livello, ecc.).

E finalmente hai il file che carica i dati di savegame in uno scenario di gioco, probabilmente il più complesso di tutti, perché carica anche tutto il resto. Quello si chiama p_setup.c e si trova nella stessa directory.

Ha funzionato bene per me cattutto ciò in un buffer di testo e pipequel testo sendmailnel mio indirizzo e-mail. In questo modo posso leggerlo nei momenti strani della giornata e usare "trova" quando voglio cercare cose come "come fa DOOM a caricare un gioco". Il codice è ben commentato.

È possibile serializzare la classe o i dati in un file flat e rileggerlo al momento del caricamento.

Ho fatto +1: ho suggerito di usare XML / JSON per strutturare i salvataggi. In questo modo sei molto preparato a rendere il cloud "cloud" basato. O almeno, avrai una struttura che potresti usare per progetti futuri che potrebbero coinvolgere il web. Finché i file non sono archiviati in un modo troppo facile da leggere, dovrebbero offrirti molti vantaggi. Come le metriche! urrà