इस पेज का अनुवाद Cloud Translation API से किया गया है.

सेव किए गए गेम अपने गेम में जोड़ना

चेतावनी: यह गाइड, Play की गेम सेवाओं के वर्शन 1 का इस्तेमाल करने के लिए है. Play के गेम सेवाओं के 2. वर्शन के लिए, C SDK टूल और इससे जुड़े दिशा-निर्देश जल्द ही उपलब्ध होंगे. इस बीच, आपको साइन इन करने के लिए गाइड में v2 के बारे में ज़्यादा जानकारी मिल सकती है. अगर आपको SDK टूल के नए वर्शन की जांच करनी है, तो ज़्यादा जानकारी के लिए Google प्रतिनिधि से संपर्क करें.

यह गाइड आपको C++ ऐप्लिकेशन में सेव किए गए गेम की सेवा का इस्तेमाल करके खिलाड़ी का गेम प्रोग्रेस डेटा सेव करने और लोड करने का तरीका बताती है. गेमप्ले के दौरान किसी भी समय प्लेयर गेम की प्रगति अपने-आप लोड करने और सेव करने के लिए इस सेवा का इस्तेमाल किया जा सकता है. इस सेवा की मदद से उपयोगकर्ता, मौजूदा सेव गेम को अपडेट या पहले जैसा करने के लिए, उपयोगकर्ता इंटरफ़ेस को ट्रिगर कर सकते हैं या नया गेम बना सकते हैं.

शुरू करने से पहले

अगर आपने पहले से ऐसा नहीं किया है, तो सेव किए गए गेम के सिद्धांतों को पढ़ना आपके लिए मददगार हो सकता है.

सेव किए गए गेम के एपीआई का इस्तेमाल करके कोड करने से पहले:

डेटा फ़ॉर्मैट और क्रॉस-प्लैटफ़ॉर्म के साथ काम करने की सुविधा

गेम के सेव किए गए उस डेटा को std::vector<uint8_t> फ़ॉर्मैट में होना चाहिए जिसे आप Google के सर्वर पर सेव करते हैं. 'सेव की गई गेम' सेवा, क्रॉस-प्लैटफ़ॉर्म के साथ काम करने के लिए आपके डेटा को कोड में बदलने का काम करती है; Android ऐप्लिकेशन इस डेटा को बाइट श्रेणी के रूप में पढ़ सकते हैं.

अपने सेव किए गए गेम के डेटा के लिए डेटा फ़ॉर्मैट चुनते समय, प्लैटफ़ॉर्म-विशिष्ट फ़ॉर्मैट का इस्तेमाल करने से बचें. हम आपको XML या JSON जैसे डेटा फ़ॉर्मैट का इस्तेमाल करने की सलाह देते हैं, जो कई प्लैटफ़ॉर्म पर काम करता है.

सेव किए गए गेम की सेवा चालू करना

सेव किए गए गेम की सेवा का इस्तेमाल करने से पहले, आपको उसका ऐक्सेस चालू करना होगा. ऐसा करने के लिए, gpg::GameServices::Builder की मदद से सेवा बनाते समय EnableSnapshots() को कॉल करें. इससे, अगली पुष्टि के इवेंट में सेव किए गए गेम के लिए ज़रूरी अतिरिक्त OAuth दायरे भी चालू हो जाएंगे.

सेव किए गए गेम दिखाए जा रहे हैं

अपने गेम में, आप खिलाड़ियों को वह विकल्प दे सकते हैं जिसे वे सेव किए गए गेम को सेव करने या उन्हें वापस पाने के लिए ट्रिगर कर सकते हैं. जब खिलाड़ी इस विकल्प को चुनते हैं, तो आपके गेम को एक ऐसी स्क्रीन लानी होगी जो मौजूदा सेव करने के स्लॉट दिखाती हो. साथ ही, खिलाड़ियों को इनमें से किसी एक स्लॉट में सेव करने या लोड करने दें या एक नया सेव किया गया गेम बनाएं. ऐसा करने के लिए नीचे दिए गए तरीके का इस्तेमाल करें:

  SnapshotManager::ShowSelectUIOperation(...)

सेव किए गए गेम चुनने के यूज़र इंटरफ़ेस (यूआई) में खिलाड़ी, सेव किए गए नए गेम बनाने, सेव किए गए मौजूदा गेम की जानकारी देखने, और सेव किए गए पिछले गेम लोड करने की सुविधा देते हैं.

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

नीचे दिए गए उदाहरण में, सेव किए गए डिफ़ॉल्ट गेम यूज़र इंटरफ़ेस (यूआई) को लाने और प्लेयर के यूज़र इंटरफ़ेस (यूआई) को मैनेज करने का तरीका बताया गया है:

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

अगर ऊपर दिए गए उदाहरण में, ALLOW_CREATE_SNAPSHOT true है और MAX_SNAPSHOTS, उपयोगकर्ता की ओर से बनाए गए स्नैपशॉट की वास्तविक संख्या से ज़्यादा है, तो डिफ़ॉल्ट स्नैपशॉट यूज़र इंटरफ़ेस (यूआई) पर एक मौजूदा बटन चुनने के बजाय, एक गेम सेव करने का बटन होता है. (दिखाए जाने पर, बटन यूज़र इंटरफ़ेस (यूआई) के नीचे होता है.) जब कोई खिलाड़ी इस बटन पर क्लिक करता है, तब SnapshotSelectUIResponse जवाब मान्य होता है, लेकिन उसमें कोई डेटा नहीं होता.

सेव किए गए गेम खोलना और पढ़ना

सेव किए गए गेम को ऐक्सेस करने और उसके कॉन्टेंट को पढ़ने या उसमें बदलाव करने के लिए, सबसे पहले सेव किए गए गेम को दिखाने वाला SnapshotMetadata ऑब्जेक्ट खोलें. इसके बाद, SnapshotManager::Read*() तरीके को कॉल करें.

नीचे दिए गए उदाहरण में, सेव किए गए गेम को खोलने का तरीका बताया गया है:

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

डेटा विरोधों का पता लगाना और उनका समाधान करना

जब आप SnapshotMetadata ऑब्जेक्ट खोलते हैं, तो सेव किए गए गेम की सेवा पता लगाती है कि सेव किया गया कोई विरोधी गेम मौजूद है या नहीं. डेटा विरोध तब हो सकते हैं, जब प्लेयर के स्थानीय डिवाइस पर सेव किया गया गेम Google के सर्वर में स्टोर किए गए रिमोट वर्शन से सिंक न हो.

किसी सेव किए गए गेम को खोलने पर दिखाई जाने वाली विरोधाभासी नीति, सेव किए गए गेम की सेवा को डेटा विरोध का अपने आप समाधान करने का तरीका बताती है. नीति इनमें से कोई एक हो सकती है:

विवाद नीति	जानकारी
`SnapshotConflictPolicy::MANUAL`	इससे पता चलता है कि गेम की सेव की गई सेवा का समाधान नहीं किया जाना चाहिए. इसकी जगह, आपका गेम पसंद के मुताबिक मर्ज किया जाएगा.
`SnapshotConflictPolicy::LONGEST_PLAYTIME`	यह बताता है कि सेव किए गए गेम की सेवा को, सेव किए गए ऐसे गेम को ज़्यादा से ज़्यादा चुनना चाहिए जिसमें ज़्यादा समय तक गेम खेलें.
`SnapshotConflictPolicy::BASE_WINS`	यह बताता है कि सेव किए गए गेम की सेवा को, सेव किया गया बेस गेम चुनना चाहिए.
`SnapshotConflictPolicy::REMOTE_WINS`	इससे पता चलता है कि सेव किए गए गेम की सेवा को सेव किया गया गेम चुनना चाहिए. रिमोट वर्शन, सेव किए गए गेम का ऐसा वर्शन होता है जिसका पता, प्लेयर के किसी एक डिवाइस पर चलता है. इसका बेस वर्शन से ज़्यादा नया टाइमस्टैंप होता है.

अगर आपने GPGSnapshotConflictPolicyManual के अलावा कोई विरोध नीति तय की है, तो सेव किए गए गेम की सेवा, सेव किए गए गेम को मर्ज कर देगी और अपडेट किए गए वर्शन को नतीजे के तौर पर SnapshotManager::OpenResponse वैल्यू के ज़रिए दिखाएगी. आपका गेम सेव किए गए गेम को खोल सकता है, उस पर लिख सकता है. इसके बाद, सेव किए गए गेम को Google के सर्वर पर भेजने के लिए, स्नैपशॉट मैनेजर::CommitDKIM कॉल करें.

कस्टम मर्ज करना

अगर आपने SnapshotConflictPolicy::MANUAL को विरोधी नीति के रूप में बताया था, तो आपके गेम को सेव किए गए गेम पर आगे पढ़ने या लिखने से पहले पहचानी गई किसी भी डेटा समस्या का समाधान करना होगा.

इस मामले में, जब डेटा के उल्लंघन का पता चलता है, तो सेवा SnapshotManager::OpenResponse के ज़रिए ये पैरामीटर दिखाती है:

conflict_id विशिष्ट रूप से इस विरोध की पहचान करने के लिए (आप सहेजे गए गेम का अंतिम वर्शन लेते समय इस मान का उपयोग करेंगे);
गेम के मूल वर्शन का विरोधी वर्शन; और
सेव किए गए गेम का आपस में मेल न खाने वाला वर्शन.

आपके गेम को यह तय करना होगा कि कौनसा डेटा सेव करना है. इसके बाद, आखिरी वर्शन को Google के सर्वर पर तय/सुलझाने के लिए, SnapshotManager::ResolveConflictBlocking() तरीके को कॉल करें.

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

सेव किए गए गेम लिखना

सेव किया गया कोई गेम लिखने के लिए, सबसे पहले उस SnapshotMetadata ऑब्जेक्ट को खोलें जो सेव किए गए गेम को दिखाता है. डेटा सेव करने से जुड़े किसी भी विवाद को ठीक करें. इसके बाद, सेव किए गए गेम में बदलाव करने के लिए, SnapshotManager::Commit() तरीके को कॉल करें.

नीचे दिए गए उदाहरण में बताया गया है कि आप बदलाव कैसे कर सकते हैं और गेम को कैसे सेव कर सकते हैं.

पहले, वह स्नैपशॉट खोलें जिसमें हम बदलाव करना चाहते हैं. साथ ही, आधार चुनकर यह पक्का करें कि सभी विवाद हल हो गए हैं.

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

इसके बाद, एक सेव किया गया गेम बदलाव बनाएं, जिसमें कवर इमेज के लिए इस्तेमाल किया गया इमेज डेटा शामिल हो:
```
gpg::SnapshotMetadataChange::Builder builder;
gpg::SnapshotMetadataChange metadata_change =
    builder.SetDescription("CollectAllTheStar savedata")
             .SetCoverImageFromPngData(pngData).Create();
```
आखिर में, सेव किए गए गेम में बदलाव करें.
```
gpg::SnapshotManager::CommitResponse commitResponse =
    service_->Snapshots().CommitBlocking(metadata, metadata_change, SetupSnapshotData());
```
डेटा पैरामीटर में सेव किया गया वह सभी गेम डेटा शामिल होता है जो सेव किया जा रहा है. इस बदलाव में, सेव किया गया अतिरिक्त गेम मेटाडेटा भी शामिल होता है, जैसे कि इस्तेमाल किए जाने का समय और सेव किए गए गेम का ब्यौरा.

अगर तय की गई कार्रवाई सही तरीके से पूरी हो जाती है, तो खिलाड़ी सेव किए गए गेम के चुनने के यूज़र इंटरफ़ेस (यूआई) में, सेव किया गया गेम देख सकते हैं.