Cette page a été traduite par l'API Cloud Translation.

Ajouter des jeux enregistrés à votre jeu

Ce guide vous explique comment enregistrer et charger les données de progression d'un joueur dans le jeu à l'aide de le service Jeux enregistrés dans une application C++. Vous pouvez utiliser cette service permettant de charger et d'enregistrer automatiquement la progression du joueur dans le jeu à tout moment pendant le jeu. Ce service peut aussi permettre aux joueurs de déclencher pour mettre à jour ou restaurer une partie enregistrée ou en créer une nouvelle.

Avant de commencer

Si vous ne l'avez pas encore fait, il peut être utile de consulter les Concepts des jeux enregistrés

Avant de commencer à coder à l'aide de l'API Saved Games:

Formats de données et compatibilité multiplate-forme

Les données des jeux enregistrés que vous enregistrez sur les serveurs de Google doivent se trouver dans Format std::vector<uint8_t>. Le service Jeux enregistrés se charge de l'encodage. pour assurer la compatibilité multiplate-forme ; Les applications Android peuvent lire dans ces mêmes données dans un tableau d'octets sans aucun problème de compatibilité multiplate-forme.

Évitez d'utiliser des formats propres à la plate-forme lorsque vous choisissez un format de données pour vos Données des jeux enregistrés. Nous vous encourageons vivement à utiliser un format de données, tel que XML ou JSON, qui offre une compatibilité étendue avec les bibliothèques sur plusieurs plates-formes.

Activer le service Jeux enregistrés

Avant de pouvoir utiliser le service Jeux enregistrés, vous devez activer l'accès Pour ce faire, appelez EnableSnapshots() lorsque vous créez le service avec gpg::GameServices::Builder Cela activera les niveaux d'accès d'authentification supplémentaires requis par le service Jeux enregistrés lors du prochain événement d'authentification.

Afficher les jeux enregistrés

Dans votre jeu, vous pouvez proposer une option que les joueurs peuvent déclencher pour enregistrer ou restaurer les jeux enregistrés. Lorsque les joueurs sélectionnent cette option, votre jeu doit vers le haut un écran qui affiche les emplacements de sauvegarde existants, et permet aux joueurs de enregistrer ou charger depuis l'un de ces emplacements, ou créer un nouveau jeu enregistré. Utilisez le Pour ce faire, procédez comme suit:

  SnapshotManager::ShowSelectUIOperation(...)

L'UI de sélection des jeux enregistrés permet les joueurs pour créer un jeu enregistré, afficher des informations sur des jeux enregistrés existants, et charger les jeux enregistrés précédents.

  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);
}

L'exemple suivant montre comment afficher l'interface utilisateur de Jeux enregistrés par défaut et gérez la sélection de l'interface utilisateur du joueur:

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

Si, dans l'exemple ci-dessus, ALLOW_CREATE_SNAPSHOT est true et MAX_SNAPSHOTS est supérieure au nombre réel d'instantanés dont dispose actuellement l'utilisateur Instantané de l'UI par défaut fournit aux joueurs un bouton permettant de créer enregistrer la partie, plutôt que d'en sélectionner une existante. (Lorsqu'il s'affiche, le bouton se trouve en bas de l'interface utilisateur.) Lorsqu'un joueur clique sur ce bouton, la La réponse SnapshotSelectUIResponse est valide, mais ne contient aucune donnée.

Ouvrir et lire les jeux enregistrés

Pour accéder à un jeu enregistré, et lire ou modifier son contenu, ouvrez-le L'objet SnapshotMetadata représentant ce jeu enregistré. Appelez ensuite la fonction SnapshotManager::Read*().

L'exemple suivant montre comment ouvrir un jeu enregistré:

  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);
          …
        }

Détecter et résoudre les conflits de données

Lorsque vous ouvrez un objet SnapshotMetadata, le service Jeux enregistrés détecte si un jeu enregistré en conflit existe. Des conflits de données peuvent survenir un jeu stocké sur l'appareil local d'un joueur n'est pas synchronisé avec la version distante stockées sur les serveurs de Google.

La règle de conflit que vous spécifiez à l'ouverture d'un jeu enregistré indique comment résoudre automatiquement un conflit de données avec le service de jeux. La règle peut être l'une des suivantes:

Règle concernant les conflits	Description
`SnapshotConflictPolicy::MANUAL`	Indique que le service Jeux enregistrés ne doit effectuer aucune opération l'action de résolution. À la place, votre jeu effectue fusion personnalisée.
`SnapshotConflictPolicy::LONGEST_PLAYTIME`	Indique que le service Jeux enregistrés doit sélectionner la jeu enregistré avec la valeur de temps de jeu la plus élevée.
`SnapshotConflictPolicy::BASE_WINS`	Indique que le service Jeux enregistrés doit choisir la base jeu enregistré.
`SnapshotConflictPolicy::REMOTE_WINS`	Indique que le service Jeux enregistrés doit sélectionner la télécommande jeu enregistré. La version distante est une version de l'instance jeu détecté sur l'un des appareils du joueur et doté d'une version que la version de base.

Si vous avez spécifié une règle de conflit autre que GPGSnapshotConflictPolicyManual, le service Jeux enregistrés fusionnera le jeu enregistré et renverra la version mise à jour via la valeur SnapshotManager::OpenResponse obtenue. Votre jeu peut s'ouvrir le jeu enregistré, y écrire, puis appeler la classe SnapshotManager::Commit(...) pour valider le jeu enregistré sur les serveurs de Google.

Effectuer une fusion personnalisée

Si vous avez spécifié SnapshotConflictPolicy::MANUAL comme règle de conflit, votre jeu doit résoudre tout conflit de données détecté pour pouvoir continuer des opérations de lecture ou d'écriture sur le jeu enregistré.

Dans ce cas, lorsqu'un conflit de données est détecté, le service renvoie le les paramètres suivants via SnapshotManager::OpenResponse:

Un conflict_id pour identifier ce conflit de manière unique (vous utiliserez cette valeur lors du commit de la version finale du jeu enregistré) ;
Version de base en conflit du jeu enregistré. et
Version à distance en conflit du jeu enregistré.

Votre jeu doit décider quelles données enregistrer, puis appeler le La méthode SnapshotManager::ResolveConflictBlocking() pour valider/résoudre le vers les serveurs de Google.

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

Écrire des jeux enregistrés

Pour écrire un jeu enregistré, ouvrez d'abord l'objet SnapshotMetadata représentant ce jeu enregistré, résolvez les conflits de données détectés, puis appelez la méthode Méthode SnapshotManager::Commit() pour valider votre sauvegarde les changements de jeu.

L'exemple suivant montre comment créer une modification et valider un jeu enregistré.

Tout d'abord, ouvrez l'instantané à modifier et assurez-vous que tous les conflits en choisissant la 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
        }
      });

Ensuite, créez une modification de jeu enregistrée incluant les données d'image utilisées pour image de couverture:

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

Enfin, validez les modifications du jeu enregistrées.
```
gpg::SnapshotManager::CommitResponse commitResponse =
    service_->Snapshots().CommitBlocking(metadata, metadata_change, SetupSnapshotData());
```
Le paramètre "data" contient toutes les données de sauvegarde que vous stockez. La modification contient également d'autres métadonnées de jeu enregistrées, telles que l'heure joué et une description du jeu enregistré.

Si l'opération de commit aboutit, les joueurs peuvent voir le jeu enregistré dans l'UI de sélection des jeux enregistrés.