Como crio um arquivo salvo para um jogo em C ++?

Estou codificando minha final para um curso de Programação de videogame e quero saber como criar um arquivo salvo para o meu jogo, para que um usuário possa jogar e depois voltar mais tarde. Qualquer idéia de como isso é feito, tudo que eu fiz antes foi em programas de execução única.

Você precisa usar a serialização para salvar suas variáveis ​​na memória no disco rígido. Existem muitos tipos de serialização. O .NET XML é um formato comum, embora haja serializadores binários e JSON disponíveis. Não sou muito programador em C ++, mas uma pesquisa rápida mostrou um exemplo de serialização em C ++:

• http://www.functionx.com/cpp/articles/serialization.htm

Existem bibliotecas que oferecem funcionalidades de serialização. Alguns são mencionados em outras respostas.

As variáveis ​​nas quais você estará interessado provavelmente estarão relacionadas ao estado do jogo. Por exemplo, você provavelmente desejará conhecer esse tipo de informação

1. O jogador estava jogando nível 3
2. O jogador estava em X, Y coordenadas mundiais
3. O jogador tem três itens na mochila
   1. Arma
   2. armaduras
   3. Comida

Você realmente não se importa com as texturas que estão sendo usadas (a menos que seu jogador possa mudar sua aparência, esse é um caso especial), porque elas geralmente são as mesmas. Você precisa se concentrar em salvar dados importantes do estado do jogo.

Ao iniciar o jogo, você inicia normalmente um jogo "novo" (isso carrega suas texturas, modelos etc.), mas no momento apropriado você carrega os valores do seu arquivo salvo no objeto de estado do jogo, substituindo o novo "padrão" estado do jogo. Em seguida, você permite que o player continue a jogar.

Simplifiquei bastante aqui, mas você deve ter uma ideia geral. Se você tiver uma pergunta mais específica, faça uma nova pergunta aqui e podemos tentar ajudá-lo.

Normalmente, isso é específico para o seu jogo. Tenho certeza que você aprendeu a escrever e ler arquivos de suas aulas até agora. A ideia básica é:

1. Ao sair do jogo, escreva os valores que deseja salvar em um arquivo.
2. Ao carregar o jogo, verifique se existe um arquivo salvo, caso exista, carregue os valores lidos no seu programa. Se o arquivo não existir, continue como agora e defina os valores para os valores iniciais / padrão.

O que você escreve depende de você, depende do seu jogo. Uma maneira de escrever é escrever as variáveis ​​que você deseja em uma ordem específica como um fluxo de bytes. Em seguida, ao carregar, leia-os no seu programa na mesma ordem.

Por exemplo (no pseudo-código rápido):

SaveGame(FileInput file) {
    file.writeInt(playerLevel);
    file.writeInt(playerHealth);
    file.writeInt(gameProgress);
}

LoadGame(FileInput file) {
    if(file.exists()) {
        playerLevel= file.readInt();
        playerHealth = file.readInt();
        gameProgress = file.readInt();
    } else {
        playerLevel = 1;
        playerHealth = 100;
        gameProgress = 0;
    }
}

Provavelmente, existe um grande número de maneiras de fazer isso, mas a mais simples que sempre achei e usei tanto pessoal quanto profissionalmente é criar uma estrutura que contenha todos os valores que desejo salvar.

struct SaveGameData
{
    int              characterLevel; // Any straight up values from the player
    int              inventoryCount; // Number of items the player has on them or stored or what not
    int[STAT_COUNT]  statistics;     // This is usually a constant size (I am tracking X number of stats)
    // etc
}

struct Item
{
    int itemTypeId;
    int Durability; // also used as a 'uses' count for potions and the like
    int strength;   // damage of a weapon, protection of armor, effectiveness of a potion
    // etc
}

Depois, escrevo / lemos os dados de e para um arquivo usando os valores básicos de IO do arquivo. O inventárioCont é o número de estruturas de itens que são salvas após a estrutura principal SaveGameData no arquivo, para que eu saiba quantas delas serão lidas após a busca desses dados. A chave aqui é que, quando eu quero salvar algo novo, a menos que seja uma lista de itens ou algo parecido, tudo o que tenho que fazer é adicionar um valor à estrutura em algum lugar. Se for uma lista de itens, terei que adicionar um passe de leitura, como já impliquei para os objetos Item, um contador no cabeçalho principal e depois as entradas.

Isso tem a desvantagem de tornar incompatíveis versões diferentes de um arquivo salvo sem tratamento especial (mesmo que sejam apenas valores padrão para cada entrada na estrutura principal). Mas, no geral, isso facilita a extensão do sistema, apenas adicionando um novo valor de dados e colocando um valor quando necessário.

Novamente, algumas maneiras de fazer isso e isso podem levar mais ao C do que ao C ++, mas ele já fez o trabalho!

Primeiro, você precisa decidir quais dados precisam ser salvos. Por exemplo, pode ser a localização do personagem, sua pontuação e o número de moedas. Obviamente, seu jogo provavelmente será muito mais complexo e, portanto, você precisará salvar dados adicionais, como o número do nível e a lista de inimigos.

Em seguida, escreva o código para salvá-lo em um arquivo (use ofstream). Um formato relativamente simples que você pode usar é o seguinte:

x y score coins

E assim o arquivo ficaria assim:

14 96 4200 100

O que significa que ele estava na posição (14, 96) com uma pontuação de 4200 e 100 moedas.

Você também precisa escrever um código para carregar este arquivo (use ifstream).

É possível salvar os inimigos incluindo sua posição no arquivo. Podemos usar este formato:

number_of_enemies x1 y1 x2 y2 ...

Primeiro, number_of_enemiesé lido e, em seguida, cada posição é lida com um loop simples.

Uma adição / sugestão seria adicionar um nível de criptografia à sua serialização para que os usuários não possam editar seus valores em texto para "9999999999999999999". Uma boa razão para fazer isso seria evitar estouros de número inteiro (por exemplo).

Eu acho que sua melhor aposta é boost :: serialization porque é fácil de propagar na sua hierarquia. Você só precisa chamar a função de salvar / carregar do objeto superior e todas as suas classes são criadas facilmente.

Consulte: http://www.boost.org/doc/libs/1_49_0/libs/serialization/doc/index.html

Por uma questão de completude, quero mencionar uma biblioteca de serialização c ++, que eu pessoalmente uso e ainda não foi mencionada: cereal .
É fácil de usar e possui uma sintaxe agradável e limpa para serialização. Ele também oferece vários tipos de formatos nos quais você pode salvar (XML, Json, Binário (incluindo uma versão portátil com os respectivos aspectos endianess)). Ele suporta herança e é somente cabeçalho,

Seu jogo comprometerá as estruturas de dados (espero?) Que você precisa transformar em bytes (serializar) para poder armazená-las. Em um futuro, você poderá carregar esses bytes de volta e transformá-los novamente em sua estrutura original (desserialização). Em C ++, não é tão complicado, pois a reflexão é muito limitada. Mas ainda assim, algumas bibliotecas podem ajudá-lo aqui. Eu escrevi um artigo sobre isso: https://rubentorresbonet.wordpress.com/2014/08/25/an-overview-of-data-serialization-techniques-in-c/ Basicamente, eu sugiro que você dê uma olhada biblioteca de cereais se você tiver como alvo os compiladores C ++ 11. Não é necessário criar arquivos intermediários, como o protobuf, para que você economize algum tempo se desejar resultados rápidos. Você também pode escolher entre binário e JSON, para ajudar bastante na depuração aqui.

Além disso, se a segurança for uma preocupação, convém criptografar / descriptografar os dados que você está armazenando, especialmente se você estiver usando formatos legíveis por humanos, como JSON. Algoritmos como o AES são úteis aqui.

Você precisa usar fstreampara arquivos de entrada / saída. A sintaxe é simples EX:

#include <fstream>
// ...
std::ofstream flux ; // to open a file in ouput mode
flux.open("myfile.whatever") ; 

Ou

#include <fstream>
// ...
std::ifstream flux ; // open a file in input mode
flux.open("myfile.whatever") ;

Outras ações são possíveis no seu arquivo: append , binário , trunc etc. Você usaria a mesma sintaxe acima, em vez de colocarmos std :: ios: :( flags), por exemplo:

• ios::out para operação de saída
• ios::in para operação de entrada
• ios::binary para operação IO binária (byte bruto), em vez de baseada em caracteres
• ios::app para começar a escrever no final do arquivo
• ios::trunc pois se o arquivo já existir, substitua, exclua o conteúdo antigo e substitua por novo
• ios::ate - posicione o ponteiro do arquivo "no final" para entrada / saída

Ex:

#include <fstream>
// ...
std::ifstream flux ;
flux.open("myfile.whatever" , ios::binary) ;

Aqui está um exemplo mais completo, mas simples.

#include <iostream>
#include <fstream>

using namespace std ;

int input ;
int New_Apple ;
int Apple_Instock ;
int Eat_Apple ;
int Apple ;

int  main()
{
  bool shouldQuit = false;
  New_Apple = 0 ;
  Apple_Instock = 0 ;
  Eat_Apple = 0 ;

  while( !shouldQuit )
  {
    cout << "------------------------------------- /n";
    cout << "1) add some apple " << endl ;
    cout << "2) check apple in stock " << endl ;
    cout << "3) eat some apple " << endl ;
    cout << "4) quit " << endl ;
    cout << "------------------------------------- /n";
    cin >> input ;

    switch (input)
    {
      case 1 :
      {
        system("cls") ;

        cout << "------------------------------------ /n";
        cout << " how much apple do you want to add /n";
        cout << "------------------------------------ /n";      
        cin >> New_Apple ;

        ifstream apple_checker ;
        apple_checker.open("apple.apl") ;
        apple_checker >> Apple_Instock ;
        apple_checker.close() ; 

        Apple = New_Apple + Apple_Instock ;

        ofstream apple_adder ;
        apple_adder.open("apple.apl") ;
        apple_adder << Apple ;
        apple_adder.close() ;

        cout << "------------------------------------ /n";
        cout << New_Apple << " Apple has been added ! /n";
        cout << "------------------------------------ /n";
        break;
      }

      case 2 :  
      {
        system("cls") ;

        ifstream apple_checker ;
        apple_checker.open("apple.apl") ;
        apple_checker >> Apple_Instock ;
        apple_checker.close() ;

        cout << "------------------------------------ /n";
        cout << " there is " << Apple_Instock ;
        cout << "apple in stock /n" ;
        cout << "------------------------------------ /n";
        break;
      }

      case 3 :
      {
        system("cls") ;

        cout << "------------------------------------ /n";
        cout << "How many apple do you want to eat /n" ;
        cout << "------------------------------------ /n";
        cin >> Eat_Apple ;

        ifstream apple_checker ;
        apple_checker.open("apple.apl") ;
        apple_checker >> Apple_Instock ;
        apple_checker.close() ;

        Apple = Apple_Instock - Eat_Apple ; 

        ofstream apple_eater ;
        apple_eater.open("apple.apl") ;
        apple_eater << Apple ;
        apple_eater.close() ;

        cout << "----------------------------------- /n";
        cout << Eat_Apple ;
        cout << " Apple has been eated! /n";
        cout << "----------------------------------- /n";
        cout << Apple << " Apple left in stock /n";
        cout << "----------------------------------- /n";
        break;
      }

      case 4 :
      {
        shouldQuit = true;
        break;
      }

      default :
      {
        system("cls") ;

        cout << "------------------------------------ /n";
        cout << " invalide choice ! /n";
        cout << "------------------------------------ /n"; 
        break;
      }
    }
  }
  return 0;
}