Se usó la API de Cloud Translation para traducir esta página.

Cómo agregar juegos guardados a tu juego

En esta guía, se muestra cómo guardar y cargar los datos de progreso del juego de un jugador usando el servicio de Juegos guardados en una aplicación de C++. Puedes usar esta para cargar y guardar automáticamente el progreso del juego en cualquier momento durante el juego. Este servicio también puede permitir que los jugadores activen la activación para actualizar o restablecer un juego guardado existente, o bien crear uno nuevo.

Antes de comenzar

Si aún no lo has hecho, puede resultarte útil consultar el Conceptos de Juegos guardados

Antes de comenzar a programar con la API de Saved Games, haz lo siguiente:

Formatos de datos y compatibilidad multiplataforma

Los datos de Juegos guardados que guardes en los servidores de Google deben estar en std::vector<uint8_t>. El servicio de Juegos guardados se encarga de la codificación sus datos para la compatibilidad multiplataforma; Las aplicaciones para Android pueden leer estos mismos datos que un array de bytes sin problemas de compatibilidad entre plataformas.

Evita usar formatos específicos de la plataforma cuando elijas un formato de datos para tu Datos de Juegos guardados. Te recomendamos que uses un formato de datos, como XML o JSON, que tienen una gran compatibilidad con bibliotecas en varias plataformas.

Cómo habilitar el servicio de Juegos guardados

Antes de poder utilizar el servicio de Juegos guardados, primero debes habilitar el acceso a que la modifica. Para ello, llama a EnableSnapshots() cuando crees el servicio con gpg::GameServices::Builder Esto habilitará los permisos de autenticación adicionales requeridos por Saved Games en el próximo evento auth.

Cómo mostrar los juegos guardados

En tu juego, puedes brindar una opción que los jugadores puedan activar para guardar restablecer los juegos guardados. Cuando los jugadores seleccionan esta opción, el juego debe una pantalla que muestre los espacios existentes para guardar guardar o cargar desde una de estas ranuras, o crear un nuevo juego guardado. Usa el siguiente método para hacerlo:

  SnapshotManager::ShowSelectUIOperation(...)

La IU de selección de Juegos guardados permite jugadores para crear un nuevo juego guardado, ver detalles de los juegos guardados existentes, y cargar los juegos guardados 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);
}

En el siguiente ejemplo, se muestra cómo activar la IU de Juegos guardados predeterminada y controlar la selección de la IU del reproductor:

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

Si, en el ejemplo anterior, ALLOW_CREATE_SNAPSHOT es true y MAX_SNAPSHOTS. es mayor que la cantidad real de instantáneas que tiene el usuario actualmente la IU de Snapshot predeterminada ofrece a los jugadores un botón para crear una nueva guardar una partida, en lugar de seleccionar una existente. (Cuando se muestra, el botón está en la parte inferior de la IU). Cuando un jugador haga clic en este botón, La respuesta SnapshotSelectUIResponse es válida, pero no tiene datos.

Cómo abrir y leer los juegos guardados

Para acceder a un juego guardado y leer o modificar su contenido, primero abre el objeto SnapshotMetadata que representa ese juego guardado Luego, llama al SnapshotManager::Read*().

En el siguiente ejemplo, se muestra cómo abrir un juego guardado:

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

Detectar y resolver conflictos de datos

Cuando abres un objeto SnapshotMetadata, el servicio de Juegos guardados detecta si existe un juego guardado en conflicto. Pueden producirse conflictos de datos cuando el archivo el juego almacenado en el dispositivo local del jugador no está sincronizado con la versión remota almacenados en los servidores de Google.

La política de conflictos que especifiques al abrir un juego guardado le indica Servicio de juego cómo resolver automáticamente un conflicto de datos La política puede ser una de las siguientes:

Política de conflictos	Descripción
`SnapshotConflictPolicy::MANUAL`	Indica que el servicio de Juegos guardados no debe realizar resolución. En cambio, el juego realizará combinación personalizada.
`SnapshotConflictPolicy::LONGEST_PLAYTIME`	Indica que el servicio de Juegos guardados debe elegir el juego guardado con el mayor valor de tiempo de juego.
`SnapshotConflictPolicy::BASE_WINS`	Indica que el servicio de Juegos guardados debe elegir la base. juego guardado.
`SnapshotConflictPolicy::REMOTE_WINS`	Indica que el servicio de Juegos guardados debe elegir el control remoto. juego guardado. La versión remota es una versión de la que se detecta en uno de los dispositivos del jugador y tiene una configuración marca de tiempo que la versión base.

Si especificaste una política de conflictos distinta de GPGSnapshotConflictPolicyManual, el servicio de Juegos guardados combinará el juego guardado y devolverá la versión actualizada. hasta el valor SnapshotManager::OpenResponse resultante. Se puede abrir el juego el juego guardado, escribir en él y, luego, llamar a SnapshotManager::Commit(...) para confirmar el juego guardado en los servidores de Google.

Realiza una combinación personalizada

Si especificaste SnapshotConflictPolicy::MANUAL como política de conflicto, tu juego debe resolver cualquier conflicto de datos que se detecte antes de seguir avanzando. operaciones de lectura o escritura en el juego guardado.

En este caso, cuando se detecta un conflicto de datos, el servicio devuelve los siguientes parámetros a través de SnapshotManager::OpenResponse:

Un conflict_id para identificar este conflicto de forma única (usarás este valor) cuando se confirma la versión final del juego guardado).
La versión base en conflicto del juego guardado y
La versión remota en conflicto del juego guardado

Tu juego debe decidir qué datos guardar y, a continuación, llama Método SnapshotManager::ResolveConflictBlocking() para confirmar o resolver la situación a los servidores de Google.

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

Cómo escribir juegos guardados

Para escribir un juego guardado, primero abre el objeto SnapshotMetadata que representa esa partida guardada, resuelve los conflictos de datos detectados y llama al Método SnapshotManager::Commit() para confirmar tu los cambios en el juego.

El siguiente ejemplo muestra cómo podrías crear un cambio y confirmar un juego guardado.

Primero, abre la instantánea que quieres editar y asegúrate de que todos los conflictos se se resuelve eligiendo 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
        }
      });

A continuación, crea un cambio de juego guardado que incluya los datos de la imagen que se usan para la imagen de portada:

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

Por último, confirma los cambios del juego guardado.
```
gpg::SnapshotManager::CommitResponse commitResponse =
    service_->Snapshots().CommitBlocking(metadata, metadata_change, SetupSnapshotData());
```
El parámetro de datos contiene todos los datos del juego guardado que almacenas. El cambio también incluye metadatos adicionales de los juegos guardados, como el tiempo y una descripción del juego guardado.

Si la operación de confirmación se completó correctamente, los jugadores pueden ver el juego guardado en la IU de selección de Juegos guardados.