Esta página foi traduzida pela API Cloud Translation.

Como adicionar jogos salvos ao jogo

Este guia mostra como salvar e carregar os dados de progresso de um jogador usando o serviço de Jogos salvos em um app C++. Você pode usar isso serviço para carregar e salvar automaticamente o progresso do jogador a qualquer momento durante o jogo. Esse serviço também pode permitir que os jogadores acionem um usuário para atualizar ou restaurar um jogo salvo existente ou criar um novo.

Antes de começar

Caso ainda não tenha feito isso, talvez seja útil revisar o Conceitos de Jogos salvos.

Antes de começar a programar usando a API Saved Games:

Formatos de dados e compatibilidade multiplataforma

Os dados dos Jogos salvos salvos nos servidores do Google precisam estar em std::vector<uint8_t>. O serviço de Jogos salvos cuida da codificação seus dados para compatibilidade multiplataforma. Os apps Android podem ler esses mesmos dados como uma matriz de bytes, sem problemas de compatibilidade entre plataformas.

Evite usar formatos específicos da plataforma ao escolher um formato de dados para seu Dados de Jogos salvos. Recomendamos que você use um formato de dados, como XML ou JSON, que tem um forte suporte a bibliotecas em várias plataformas.

Como ativar o serviço Jogos salvos

Antes de usar o serviço de Jogos salvos, é necessário ativar o acesso a reimplantá-lo. Para fazer isso, chame EnableSnapshots() ao criar o serviço com gpg::GameServices::Builder. Isso vai ativar os escopos de autenticação adicionais exigida pela Saved Games no próximo evento de autenticação.

Mostrando jogos salvos

No jogo, é possível oferecer uma opção que os jogadores podem acionar para salvar ou restaurar jogos salvos. Quando os jogadores selecionam essa opção, seu jogo deve apresentar uma tela que exibe os espaços salvos e permite que os jogadores salvar ou carregar a partir de um desses slots, ou criar um novo jogo salvo. Use o método a seguir para fazer isso:

  SnapshotManager::ShowSelectUIOperation(...)

A interface de seleção de Jogos salvos permite os jogadores para criar um novo jogo salvo, visualizar detalhes sobre jogos salvos já existentes, e carregar os jogos salvos anteriores.

  SnapshotManager::SnapshotSelectUIResponse response;
  if (IsSuccess(response.status)) {
  if (response.data.Valid()) {
    LogI("Description: %s", response.data.Description().c_str());
    LogI("FileName %s", response.data.FileName().c_str());
    //Opening the snapshot data
    …
  } else {
    LogI("Creating new snapshot");
    …
  }
} else {
  LogI("ShowSelectUIOperation returns an error %d", response.status);
}

O exemplo a seguir ilustra como exibir a interface padrão de Jogos salvos e processar a seleção da interface do jogador:

  service_->Snapshots().ShowSelectUIOperation(
  ALLOW_CREATE_SNAPSHOT,
  ALLOW_DELETE_SNAPSHOT,
  MAX_SNAPSHOTS,
  SNAPSHOT_UI_TITLE,
  [this](gpg::SnapshotManager::SnapshotSelectUIResponse const & response) {
  …
      }

Se, no exemplo acima, ALLOW_CREATE_SNAPSHOT for true e MAX_SNAPSHOTS é maior do que o número real de snapshots que o usuário tem atualmente criada, a interface de snapshot padrão oferece aos jogadores um botão para criar um novo salvar o jogo, em vez de selecionar um já existente. (Quando exibido, o botão está na parte inferior da interface. Quando um jogador clica nesse botão, A resposta SnapshotSelectUIResponse é válida, mas não tem dados.

Como abrir e ler jogos salvos

Para acessar um jogo salvo e ler ou modificar o conteúdo dele, primeiro abra o objeto SnapshotMetadata que representa esse jogo salvo. Em seguida, chame o método SnapshotManager::Read*().

O exemplo abaixo mostra como abrir um jogo salvo:

  LogI("Opening file");
  service_->Snapshots()
  .Open(current_snapshot_.FileName(),
               gpg::SnapshotConflictPolicy::BASE_WINS,
        [this](gpg::SnapshotManager::OpenResponse const & response) {
           LogI("Reading file");
           gpg::SnapshotManager::ReadResponse responseRead =
           service_->Snapshots().ReadBlocking(response.data);
          …
        }

Detecção e resolução de conflitos de dados

Quando você abre um objeto SnapshotMetadata, o serviço Jogos salvos detecta se existe um jogo salvo conflitante. Conflitos de dados podem ocorrer quando o conteúdo Jogo armazenado no dispositivo local de um jogador não sincronizado com a versão remota armazenadas nos servidores do Google.

A política de conflitos especificada ao abrir um jogo salvo informa ao Como resolver automaticamente um conflito de dados com o serviço de jogos. A política pode ser uma das seguintes:

Política de conflito	Descrição
`SnapshotConflictPolicy::MANUAL`	Indica que o serviço Jogos salvos não deve realizar de resolução de problemas. Em vez disso, o jogo terá uma mesclagem personalizada.
`SnapshotConflictPolicy::LONGEST_PLAYTIME`	Indica que o serviço de Jogos salvos deve escolher a jogo salvo com o maior valor de tempo de jogo.
`SnapshotConflictPolicy::BASE_WINS`	Indica que o serviço de Jogos salvos precisa escolher a base jogo salvo.
`SnapshotConflictPolicy::REMOTE_WINS`	Indica que o serviço de Jogos salvos precisa escolher o controle remoto jogo salvo. A versão remota é uma versão da interface que é detectado em um dos dispositivos do jogador e tem uma versão do que a versão base.

Se você especificou uma política de conflito diferente de GPGSnapshotConflictPolicyManual: o serviço de Jogos salvos mesclará o jogo salvo e retornará a versão atualizada usando o valor SnapshotManager::OpenResponse resultante. O jogo pode abrir o jogo salvo, gravar nele e chamar a função SnapshotManager::Commit(...) para fazer commit do jogo salvo nos servidores do Google.

Como fazer uma mesclagem personalizada

Se você especificou SnapshotConflictPolicy::MANUAL como política de conflitos, o jogo precisa resolver qualquer conflito de dados detectado antes de continuar operações de leitura ou gravação no jogo salvo.

Nesse caso, quando um conflito de dados é detectado, o serviço retorna o parâmetros a seguir pelo SnapshotManager::OpenResponse:

Um conflict_id para identificar exclusivamente esse conflito. Você vai usar esse valor. ao confirmar a versão final do jogo salvo);
A versão base conflitante do jogo salvo. e
A versão remota conflitante do jogo salvo.

Seu jogo deve decidir quais dados salvar e, em seguida, chamar o método Método SnapshotManager::ResolveConflictBlocking() para confirmar/resolver o problema final para os servidores do Google.

    //Resolve conflict
    gpg::SnapshotManager::OpenResponse resolveResponse =
        manager.ResolveConflictBlocking(openResponse.conflict_base, metadata_change,
                                  openResponse.conflict_id);

Escrevendo jogos salvos

Para gravar um jogo salvo, primeiro abra o objeto SnapshotMetadata que representa que salvou o jogo, resolva quaisquer conflitos de dados detectados e, em seguida, chame o método Método SnapshotManager::Commit() para confirmar as alterações mudanças no jogo.

O exemplo a seguir mostra como você pode criar uma alteração e confirmar uma jogo salvo.

Primeiro, abra o resumo que queremos editar e verifique se todos os conflitos estão e resolvidos escolhendo a base.

service_->Snapshots().Open(
      file_name,
      gpg::SnapshotConflictPolicy::BASE_WINS,
      [this](gpg::SnapshotManager::OpenResponse const &response) {
        if (IsSuccess(response.status)) {
          // metadata : gpg::SnapshotMetadata
          metadata = response.data;
        } else {
          // Handle snapshot open error here
        }
      });

Em seguida, crie uma mudança de jogo salva que inclua os dados de imagem usados para o imagem da capa:

gpg::SnapshotMetadataChange::Builder builder;
gpg::SnapshotMetadataChange metadata_change =
    builder.SetDescription("CollectAllTheStar savedata")
             .SetCoverImageFromPngData(pngData).Create();

Por fim, confirme as mudanças do jogo salvo.
```
gpg::SnapshotManager::CommitResponse commitResponse =
    service_->Snapshots().CommitBlocking(metadata, metadata_change, SetupSnapshotData());
```
O parâmetro data contém todos os dados do jogo salvo que você está armazenando. A mudança também contém outros metadados de jogos salvos, como tempo jogado e uma descrição dele.

Se a operação de confirmação for concluída, os jogadores poderão ver o jogo salvo na interface de seleção de Jogos salvos.