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

Google Sign-In API के बंद होने के बाद, हम 2026 में Games v1 एसडीके को हटा रहे हैं. फ़रवरी 2025 के बाद, Google Play पर ऐसे गेम पब्लिश नहीं किए जा सकेंगे जो Games v1 एसडीके के साथ अभी-अभी इंटिग्रेट किए गए हैं. हमारा सुझाव है कि आप इसके बजाय, Games v2 SDK का इस्तेमाल करें.
गेम के v1 इंटिग्रेशन वाले मौजूदा टाइटल, कुछ सालों तक काम करते रहेंगे. हालांकि, हमारा सुझाव है कि आप जून 2025 से v2 पर माइग्रेट करें.
यह गाइड, Play की गेम सेवाओं के v1 एसडीके का इस्तेमाल करने के लिए है. Play की गेम सेवाओं v2 के लिए C++ SDK टूल अभी उपलब्ध नहीं है.

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

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

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

Saved Games API का इस्तेमाल करके कोडिंग शुरू करने से पहले:

डेटा फ़ॉर्मैट और क्रॉस-प्लैटफ़ॉर्म कंपैटबिलिटी

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

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

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

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

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

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

  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 ऑब्जेक्ट खोलने पर, Saved Games सेवा यह पता लगाती है कि सेव किया गया कोई ऐसा गेम तो नहीं है जो मौजूदा गेम से मेल न खाता हो. डेटा में टकराव तब हो सकता है, जब किसी खिलाड़ी के डिवाइस पर सेव किया गया गेम, Google के सर्वर पर सेव किए गए रिमोट वर्शन के साथ सिंक न हो.

सेव किए गए गेम को खोलने पर, टकराव से जुड़ी जिस नीति के बारे में बताया जाता है उससे Saved Games सेवा को यह पता चलता है कि डेटा के टकराव को अपने-आप कैसे ठीक किया जाए. नीति इनमें से कोई एक हो सकती है:

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

अगर आपने GPGSnapshotConflictPolicyManual के अलावा कोई दूसरी टकराव नीति तय की है, तो Saved Games सेवा, सेव किए गए गेम को मर्ज कर देगी. साथ ही, SnapshotManager::OpenResponse की वैल्यू के ज़रिए अपडेट किया गया वर्शन दिखाएगी. आपका गेम, सेव किए गए गेम को खोल सकता है, उसमें लिख सकता है. इसके बाद, SnapshotManager::Commit(...) तरीके को कॉल करके, सेव किए गए गेम को Google के सर्वर पर सेव कर सकता है.

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

अगर आपने नीति के उल्लंघन के तौर पर 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() तरीके को कॉल करें.

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

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

    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. इसके बाद, सेव किए गए गेम में बदलाव करें. इसमें कवर इमेज के लिए इस्तेमाल किया गया इमेज डेटा शामिल होना चाहिए:

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

  3. आखिर में, सेव किए गए गेम में किए गए बदलावों को लागू करें.

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

    डेटा पैरामीटर में, सेव किए गए गेम का वह सारा डेटा होता है जिसे सेव किया जा रहा है. इस बदलाव में, सेव किए गए गेम का अतिरिक्त मेटाडेटा भी शामिल होता है. जैसे, गेम खेलने का समय और सेव किए गए गेम का ब्यौरा.

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