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

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

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

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

अगर आपने अब तक ऐसा नहीं किया है, तो सेव किए गए गेम के कॉन्सेप्ट की समीक्षा करना आपके लिए मददगार हो सकता है.

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

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

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

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

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

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

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

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

  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 के सर्वर पर सेव करने के लिए, SnapshotManager::Commit(...) का इस्तेमाल कर सकता है.

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

अगर आपने डेटा के मेल न खाने की नीति के तौर पर 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());
```
डेटा पैरामीटर में, सेव किया गया वह सारा गेम डेटा होता है जिसे सेव किया जा रहा है. इस बदलाव में, सेव किए गए गेम का अतिरिक्त मेटाडेटा भी शामिल है. जैसे, गेम खेलने में लगा समय और सेव किए गए गेम के बारे में जानकारी.

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