Aggiunta di partite salvate al gioco

Questa guida ti mostra come salvare e caricare i dati relativi ai progressi di gioco di un giocatore il servizio Saved Games in un'applicazione C++. Puoi utilizzare questo per caricare e salvare automaticamente i progressi di gioco del giocatore in qualsiasi momento. durante il gameplay. Questo servizio può anche consentire ai giocatori di attivare un utente per aggiornare o ripristinare una partita salvata esistente o crearne una nuova.

Prima di iniziare

Se non l'hai ancora fatto, potrebbe essere utile consultare il Concetti sui giochi salvati dei giochi.

Prima di iniziare a programmare con l'API Saved Games:

• Installa l'SDK Play Giochi C++.
• Configura il tuo ambiente di sviluppo C++.
• Scarica ed esamina l'esempio di codice C++.
• Attiva il servizio Partite salvate in Google Play Console.

Formati dei dati e compatibilità multipiattaforma

I dati delle Partite salvate che salvi sui server di Google devono essere memorizzati Formato std::vector<uint8_t>. Il servizio Partite salvate si occupa della codifica i tuoi dati per garantire la compatibilità multipiattaforma; Le app per Android supportano la lettura gli stessi dati di un array di byte senza problemi di compatibilità multipiattaforma.

Evita di utilizzare formati specifici della piattaforma quando scegli un formato dei dati per il tuo Dati delle partite salvate. Ti consigliamo vivamente di utilizzare un formato dati come XML o JSON, che offre un solido supporto per le librerie su più piattaforme.

Attivazione del servizio Partite salvate

Per poter utilizzare il servizio Partite salvate, devi prima abilitare l'accesso a li annotino. Per farlo, chiama EnableSnapshots() quando crei il servizio con gpg::GameServices::Builder. Ciò abiliterà gli ambiti di autenticazione aggiuntivi richiesto da Giochi salvati al successivo evento di autenticazione.

Visualizzazione delle partite salvate

Nel tuo gioco puoi fornire un'opzione che i giocatori possano attivare per salvare o ripristinare le partite salvate. Se i giocatori selezionano questa opzione, il gioco dovrebbe una schermata che mostra le aree di salvataggio esistenti e consente ai giocatori salvare o caricare contenuti in una di queste slot oppure creare una nuova partita salvata. Utilizza la seguente per farlo:

  SnapshotManager::ShowSelectUIOperation(...)

L'interfaccia utente per la selezione delle Partite salvate consente ai giocatori di creare una nuova partita salvata, visualizzare i dettagli delle partite salvate esistenti e carica le partite salvate precedenti.

  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'esempio seguente illustra come visualizzare l'interfaccia utente predefinita Partite salvate e gestire la selezione dell'interfaccia utente del player:

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

Se, nell'esempio precedente, ALLOW_CREATE_SNAPSHOT è true e MAX_SNAPSHOTS è maggiore del numero effettivo di snapshot attualmente di cui l'utente ha l'interfaccia utente di Istantanea predefinita offre ai giocatori un pulsante per creare salvare la partita, invece di selezionarne una esistente. (Quando viene visualizzato, il pulsante si trova nella parte inferiore dell'interfaccia utente. Quando un giocatore fa clic su questo pulsante, La risposta SnapshotSelectUIResponse è valida, ma non contiene dati.

Apertura e lettura delle partite salvate

Per accedere a una partita salvata e leggerne o modificarne i contenuti, devi prima aprire l'oggetto SnapshotMetadata che rappresenta la partita salvata. Quindi, chiama il SnapshotManager::Read*().

L'esempio seguente mostra come aprire una partita salvata:

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

Rilevamento e risoluzione dei conflitti di dati

Quando apri un oggetto SnapshotMetadata, il servizio Partite salvate rileva se esiste una partita salvata in conflitto. Potrebbero verificarsi conflitti tra i dati quando Il gioco memorizzato sul dispositivo locale di un giocatore non è sincronizzato con la versione remota archiviati nei server di Google.

La norma di conflitto specificata all'apertura di una partita salvata indica Servizio giochi come risolvere automaticamente un conflitto di dati. Il criterio può essere uno dei seguenti:

Politica di conflitto	Descrizione
SnapshotConflictPolicy::MANUAL	Indica che il servizio Giochi salvati non deve eseguire azione di risoluzione. Il gioco eseguirà invece un unione personalizzata.
SnapshotConflictPolicy::LONGEST_PLAYTIME	Indica che il servizio Partite salvate deve selezionare partita salvata con il valore maggiore in termini di tempo di gioco.
SnapshotConflictPolicy::BASE_WINS	Indica che il servizio Partite salvate deve scegliere la base partita salvata.
SnapshotConflictPolicy::REMOTE_WINS	Indica che il servizio Partite salvate deve selezionare il telecomando partita salvata. La versione remota è una versione che viene rilevato su uno dei dispositivi del giocatore e ha una rispetto alla versione di base.

Se hai specificato un criterio di conflitto diverso da GPGSnapshotConflictPolicyManual, il servizio Partite salvate unirà la partita salvata e restituirà la versione aggiornata al valore SnapshotManager::OpenResponse risultante. Puoi aprire il gioco la partita salvata, scrivila e chiama SnapshotManager::Commit(...) per eseguire il commit della partita salvata sui server di Google.

Esecuzione di un'unione personalizzata

Se hai specificato SnapshotConflictPolicy::MANUAL come criterio di conflitto, il gioco deve risolvere gli eventuali conflitti di dati rilevati prima di esibirsi ulteriormente operazioni di lettura o scrittura sulla partita salvata.

In questo caso, quando viene rilevato un conflitto di dati, il servizio restituisce seguenti parametri fino a SnapshotManager::OpenResponse:

• Un conflict_id per identificare in modo univoco questo conflitto (utilizzerai questo valore quando si impegna la versione finale della partita salvata).
• La versione di base in conflitto della partita salvata. e
• La versione remota in conflitto della partita salvata.

Il gioco deve decidere quali dati salvare, quindi deve richiamare Metodo SnapshotManager::ResolveConflictBlocking() per eseguire il commit/la risoluzione finale ai server di Google.

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

Scrittura di partite salvate

Per scrivere una partita salvata, apri innanzitutto l'oggetto SnapshotMetadata che rappresenta la partita salvata, risolvi gli eventuali conflitti di dati rilevati e richiama Metodo SnapshotManager::Commit() per eseguire il commit dei dati salvati cambia il gioco.

L'esempio seguente mostra come creare una modifica ed eseguire il commit di partita salvata.

1. Innanzitutto, apri l'istantanea che vuoi modificare e assicurati che tutti i conflitti siano risolti scegliendo 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
           }
         });
   

2. Quindi, crea una modifica di gioco salvata che includa i dati di immagine utilizzati per immagine di copertina:

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

3. Infine, esegui il commit delle modifiche al gioco salvate.

   gpg::SnapshotManager::CommitResponse commitResponse =
       service_->Snapshots().CommitBlocking(metadata, metadata_change, SetupSnapshotData());
   

   Il parametro dei dati contiene tutti i dati delle partite salvate che stai memorizzando. La modifica contiene anche altri metadati delle partite salvate, come l'ora giocato e una descrizione per la partita salvata.

Se l'operazione di commit è stata completata correttamente, i giocatori possono la partita salvata nell'interfaccia utente di selezione Partite salvate.