निर्बाध गेमिंग अनुभव के लिए गेम प्रगति सुविधा को सहेजने और लोड करने का तरीका जानें।

आधुनिक गेम विकास में, गेम की प्रगति को सहेजने और लोड करने की क्षमता एक महत्वपूर्ण विशेषता है जो उपयोगकर्ता अनुभव और जुड़ाव को बढ़ाती है। PyGame, Python में 2D गेम बनाने के लिए एक लोकप्रिय लाइब्रेरी है, जो सेव और लोड सुविधा को सहजता से लागू करने के लिए आवश्यक उपकरण प्रदान करती है।

एक सरल गेम बनाना

शुरू करने से पहले, सुनिश्चित करें कि आपके पास है आपके डिवाइस पर पाइप इंस्टॉल हो गया है. पाइप इंस्टॉल करने के बाद, इंस्टॉल करने के लिए नीचे दिया गया कमांड चलाएँ pygame मापांक:

पिप इंस्टाल पायगेम

PyGame में सेव और लोड सिस्टम के कार्यान्वयन को स्पष्ट करने के लिए, एक सरल गेम बनाकर शुरुआत करें।

इस आलेख में प्रयुक्त कोड इसमें उपलब्ध है गिटहब रिपॉजिटरी और यह आपके लिए एमआईटी लाइसेंस के तहत उपयोग करने के लिए निःशुल्क है।

इस गेम में खिलाड़ी के पास बाएं और दाएं घूमने की क्षमता होगी। यहां एक उदाहरण कोड स्निपेट है जो मूल गेम संरचना को प्रदर्शित करता है:

आयात pygame
# Pygame को इनिशियलाइज़ करें
pygame.init()


# गेम विंडो सेट करें
विंडो_विड्थ = 





instagram viewer

800
विंडो_हाइट = 600
विंडो = pygame.display.set_mode((window_width, window_height))
pygame.display.set_caption("सिस्टम ट्यूटोरियल सहेजें और लोड करें")


# गेम वैरिएबल
प्लेयर_एक्स = 400
प्लेयर_वाई = 500
प्लेयर_स्पीड = 5


# गेम लूप
दौड़ना= सत्य
जबकि दौड़ना:
के लिए आयोजन में pygame.event.get():
अगर इवेंट.प्रकार == pygame. छोड़ना:
 दौड़ना= असत्य


 कुंजी = pygame.key.get_pressed()
अगर चाबियाँ[pygame. K_LEFT]:
 प्लेयर_एक्स - = प्लेयर_स्पीड
अगर चाबियाँ[pygame. K_दाएँ]:
 प्लेयर_एक्स += प्लेयर_स्पीड


# स्क्रीन साफ़ करें
 विंडो.फिल((0, 0, 0))


# खिलाड़ी को ड्रा करें
 pygame.draw.rect (विंडो, (255, 255, 255), (प्लेयर_एक्स, प्लेयर_वाई, 50, 50))


# डिस्प्ले को अपडेट करें
 pygame.display.flip()
# खेल छोड़ें
pygame.छोड़ें()

गेम स्थिति और डेटा दृढ़ता का प्रबंधन

सेव और लोड कार्यक्षमता को लागू करने से पहले, आपको गेम स्थिति को प्रबंधित करने और डेटा को बनाए रखने का एक तरीका स्थापित करना होगा। एक सामान्य दृष्टिकोण है पायथन डिक्शनरी का उपयोग करें प्रासंगिक गेम डेटा संग्रहीत करने के लिए। यहां एक उदाहरण दिया गया है कि आप गेम स्थिति प्रबंधन को शामिल करने के लिए पिछले कोड को कैसे संशोधित कर सकते हैं:

# गेम वैरिएबल
गेम_स्टेट = {
'प्लेयर_एक्स': 400,
'खिलाड़ी_y': 500
}
# गेम लूप
दौड़ना= सत्य
जबकि दौड़ना:
# ...


 कुंजी = pygame.key.get_pressed()
अगर चाबियाँ[pygame. K_LEFT]:
 गेम_स्टेट['प्लेयर_एक्स'] -= प्लेयर_स्पीड
अगर चाबियाँ[pygame. K_दाएँ]:
 गेम_स्टेट['प्लेयर_एक्स'] += प्लेयर_स्पीड


# ...
 pygame.display.flip()

सेव और लोड कार्यक्षमता को कार्यान्वित करना

गेम की प्रगति को सहेजने और लोड करने में सक्षम करने के लिए, आप पायथन के अंतर्निहित का लाभ उठा सकते हैं अचार मॉड्यूल, जो हमें पायथन ऑब्जेक्ट्स को क्रमबद्ध और डीसेरिएलाइज़ करने की अनुमति देता है। नामक एक नई फ़ाइल बनाएँ save-game.py और नीचे दिए गए अपडेट के साथ कोड जोड़ें:

गेम_स्टेट = {
'प्लेयर_एक्स': प्लेयर_एक्स,
'खिलाड़ी_y': खिलाड़ी_y
}
# गेम स्थिति सहेजें
डीईएफ़सेव_गेम_स्टेट(गेम_स्टेट, फ़ाइल_नाम):
कोशिश:
साथ खोलें (फ़ाइल_नाम, 'डब्ल्यूबी') जैसा फ़ाइल:
 अचार.डंप (गेम_स्टेट, फ़ाइल)
 प्रिंट("गेम स्थिति सफलतापूर्वक सहेजी गई!")
के अलावा आईओत्रुटि:
 प्रिंट("त्रुटि: गेम स्थिति सहेजने में असमर्थ।")


# गेम स्थिति लोड करें
डीईएफ़लोड_गेम_स्टेट(फ़ाइल का नाम):
कोशिश:
साथ खोलें (फ़ाइल_नाम, 'आरबी') जैसा फ़ाइल:
 गेम_स्टेट = अचार.लोड (फ़ाइल)
 प्रिंट("गेम स्थिति सफलतापूर्वक लोड हो गई!")
वापस करना गेम_स्टेट
के अलावा (IOError, अचार. अनपिकलिंग एरर):
 प्रिंट("त्रुटि: गेम स्थिति लोड करने में असमर्थ।")


# गेम लूप
दौड़ना= सत्य
जबकि दौड़ना:


# ...


 कुंजी = pygame.key.get_pressed()
अगर चाबियाँ[pygame. K_LEFT]:
 प्लेयर_एक्स - = प्लेयर_स्पीड
 गेम_स्टेट['प्लेयर_एक्स'] = प्लेयर_x
अगर चाबियाँ[pygame. K_दाएँ]:
 प्लेयर_एक्स += प्लेयर_स्पीड
 गेम_स्टेट['प्लेयर_एक्स'] = प्लेयर_x


अगर चाबियाँ[pygame. K_s]:
 सेव_गेम_स्टेट (गेम_स्टेट, 'सेव_गेम.अचार')
अगर चाबियाँ[pygame. K_l]:
 गेम_स्टेट = लोड_गेम_स्टेट('सेव_गेम.अचार')
 प्लेयर_एक्स = गेम_स्टेट['प्लेयर_एक्स']

# ...
# ...

नीचे आउटपुट है:

सेव स्लॉट के लिए एक यूजर इंटरफेस डिजाइन करना

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

एक बनाने के save_slots सूची जो उपलब्ध सेव स्लॉट का प्रतिनिधित्व करती है। इसके अलावा, एक जोड़ें चयनित_स्लॉट खिलाड़ी द्वारा चुने गए स्लॉट का ट्रैक रखने के लिए वैरिएबल।

जब खिलाड़ी सेव बटन दबाता है तो उपलब्ध सेव स्लॉट दिखाएं (के_एस). खिलाड़ी संबंधित संख्या कुंजी दबाकर एक स्लॉट चुन सकता है (क_1, K_2, या K_3). यदि कोई स्लॉट चुना गया है, तो गेम स्थिति चयनित स्लॉट के नाम वाली फ़ाइल में सहेजी जाती है।

इसी प्रकार, जब खिलाड़ी लोड बटन दबाता है (के_एल), सेव स्लॉट प्रदर्शित करें। खिलाड़ी कुंजियाँ दबाकर एक स्लॉट चुन सकता है K_a, क_बी, या के_सी गेम स्थिति लोड करने के लिए. वैकल्पिक रूप से, आप कर सकते हैं स्पर्श इनपुट का उपयोग करें स्लॉट चयन के लिए कीबोर्ड इनपुट के बजाय। यदि कोई स्लॉट चुना गया है, तो गेम स्थिति संबंधित फ़ाइल से लोड की जाती है।

नामक एक नई फ़ाइल बनाएँ इंटरफ़ेस.py और नीचे दिए गए अपडेट के साथ कोड जोड़ें:

# गेम वैरिएबल
save_slots = ['स्लॉट 1', 'स्लॉट 2', 'स्लॉट 3']
चयनित_स्लॉट = कोई नहीं
# गेम लूप
दौड़ना= सत्य
जबकि दौड़ना:
के लिए आयोजन में pygame.event.get():
अगर इवेंट.प्रकार == pygame. छोड़ना:
 दौड़ना= असत्य


अगर इवेंट.प्रकार == pygame. चाबी नीचे:
अगर इवेंट.की == पायगेम। के_एस:
# सेव स्लॉट दिखाएं
 चयनित_स्लॉट = कोई नहीं
के लिए मैं, स्लॉट में गणना करें (save_slots):
 प्रिंट(f"स्लॉट सहेजें {मैं+1}: {छेद}")
 प्रिंट("गेम को सेव करने के लिए एक स्लॉट चुनें।")


अगर इवेंट.की == पायगेम। के_एल:
 प्रिंट("स्लॉट चुनें:- ए - स्लॉट 1, बी - स्लॉट 3, सी - स्लॉट 3")
# सेव स्लॉट दिखाएं
 चयनित_स्लॉट = कोई नहीं
के लिए मैं, स्लॉट में गणना करें (save_slots):
 प्रिंट(f"स्लॉट सहेजें {मैं+1}: {छेद}")
 प्रिंट("गेम लोड करने के लिए एक स्लॉट चुनें।")


अगर घटना.कुंजी में [पाइगेम. K_1, पायगेम. K_2, पायगेम. K_3]:
# चयनित स्लॉट के आधार पर गेम को सेव या लोड करें
 स्लॉट_इंडेक्स = इवेंट.की - पायगेम। क_1
 चयनित_स्लॉट = save_slots[slot_index]

 सेव_गेम_स्टेट (गेम_स्टेट, एफ"{चयनित_स्लॉट}.अचार")
 प्रिंट(f"गेम सहेजा गया {चयनित_स्लॉट}!")


अगर घटना.कुंजी में [पाइगेम. K_a, pygame. K_b, pygame. K_c]:

 स्लॉट_इंडेक्स = इवेंट.की - पायगेम। K_a
 चयनित_स्लॉट = save_slots[slot_index]
 गेम_स्टेट = लोड_गेम_स्टेट(एफ"{चयनित_स्लॉट}.अचार")
 प्लेयर_एक्स = गेम_स्टेट['प्लेयर_एक्स']
 प्रिंट(f"गेम से लोड किया गया {चयनित_स्लॉट}!")
# ...


 pygame.display.flip()
# ...

नीचे आउटपुट है:

किसी श्रेय की आवश्यकता नहीं: इमरान द्वारा स्क्रीनशॉट

ओवरराइटिंग विकल्पों को संभालना

मौजूदा सेव को ओवरराइट करने के विकल्प प्रदान करने के लिए, आप एक चेतावनी संदेश लागू कर सकते हैं जो सेव फ़ाइल को ओवरराइट करने से पहले प्लेयर को पुष्टि के लिए संकेत देता है। नामक एक नई फ़ाइल बनाएँ ओवरराइटिंग-save.py और नीचे दिए गए अपडेट के साथ कोड को संशोधित करें:

# गेम स्थिति सहेजें
डीईएफ़सेव_गेम_स्टेट(गेम_स्टेट, फ़ाइल_नाम):
अगर os.path.मौजूद (फ़ाइल_नाम):
# मौजूदा सेव फ़ाइल को अधिलेखित करने की पुष्टि के लिए संकेत दें
 अधिलेखित = इनपुट("सेव फ़ाइल पहले से मौजूद है। क्या आप इसके ऊपर लिखना चाहते हैं? (Y n): ")
अगर अधिलेखित करें.निचला() != 'य':
 प्रिंट("सहेजें रद्द कर दिया गया।")
वापस करना
कोशिश:
साथ खोलें (फ़ाइल_नाम, 'डब्ल्यूबी') जैसा फ़ाइल:
 अचार.डंप (गेम_स्टेट, फ़ाइल)
 प्रिंट("गेम स्थिति सफलतापूर्वक सहेजी गई!")
के अलावा आईओत्रुटि:
 प्रिंट("त्रुटि: गेम स्थिति सहेजने में असमर्थ।")


# ...


# गेम स्थिति लोड करें
डीईएफ़लोड_गेम_स्टेट(फ़ाइल का नाम):
अगरनहीं os.path.मौजूद (फ़ाइल_नाम):
 प्रिंट("त्रुटि: फ़ाइल सहेजें मौजूद नहीं है।")
वापस करनाकोई नहीं


कोशिश:
साथ खोलें (फ़ाइल_नाम, 'आरबी') जैसा फ़ाइल:
 गेम_स्टेट = अचार.लोड (फ़ाइल)
 प्रिंट("गेम स्थिति सफलतापूर्वक लोड हो गई!")
वापस करना गेम_स्टेट
के अलावा (IOError, अचार. अनपिकलिंग एरर):
 प्रिंट("त्रुटि: गेम स्थिति लोड करने में असमर्थ।")
वापस करनाकोई नहीं
# ...

उपरोक्त कोड में, गेम स्थिति को सहेजने से पहले, आप जांचें कि क्या सेव फ़ाइल पहले से मौजूद है ओएस.पथ.मौजूद(). यदि ऐसा होता है, तो आप प्लेयर को मौजूदा सेव फ़ाइल को अधिलेखित करने की पुष्टि के लिए संकेत देते हैं। यदि खिलाड़ी ओवरराइट न करने का विकल्प चुनता है, तो सेव ऑपरेशन रद्द कर दिया जाता है।

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

सेव और लोड सिस्टम के लिए सर्वोत्तम अभ्यास

PyGame या किसी गेम डेवलपमेंट प्रोजेक्ट में सेव और लोड सिस्टम लागू करते समय, निम्नलिखित सर्वोत्तम प्रथाओं पर विचार करें:

  • खेल की स्थिति का प्रतिनिधित्व करने के लिए एक अच्छी तरह से परिभाषित डेटा संरचना का उपयोग करें और क्रमांकन लाइब्रेरी का उपयोग करके इसे क्रमबद्ध करें अचार. यह आपको संपूर्ण गेम स्थिति को आसानी से सहेजने और लोड करने की अनुमति देता है।
  • सहेजी गई फ़ाइलों को संग्रहीत करने के लिए एक समर्पित निर्देशिका या फ़ोल्डर बनाएँ। यह सहेजी गई फ़ाइलों को व्यवस्थित करने में मदद करता है और मुख्य गेम निर्देशिका को अव्यवस्थित होने से बचाता है।
  • त्रुटि प्रबंधन लागू करें और डिबगिंग और समस्या निवारण में सहायता के लिए सूचनात्मक त्रुटि संदेश प्रदान करें। इससे खिलाड़ियों को सेव और लोड ऑपरेशन के दौरान आने वाली किसी भी समस्या को समझने में मदद मिलती है।
  • खिलाड़ियों को कई गेम सेव करने की अनुमति देने के लिए मल्टीपल सेव स्लॉट लागू करने पर विचार करें। यह खिलाड़ियों को उनकी प्रगति को ओवरराइट किए बिना विभिन्न पथों का पता लगाने या गेम के विशिष्ट अनुभागों को दोबारा खेलने की सुविधा देता है।

सेव और लोड सिस्टम के साथ गेम्स को और अधिक आकर्षक बनाएं

सेव और लोड सुविधा के जुड़ने से गेम की व्यस्तता और आनंद में काफी वृद्धि हो सकती है। यह खिलाड़ियों को अपनी प्रगति को सहेजने और अपनी सुविधानुसार खेल में वापस लौटने की अनुमति देता है। इसके अलावा, यह जटिल गेम दुनिया बनाने की संभावनाओं को खोलता है, जहां खिलाड़ी की पसंद और कार्यों के स्थायी परिणाम होते हैं।

सेव और लोड सिस्टम लागू करके, आप अपने खिलाड़ियों को अधिक गहन और संतोषजनक गेमिंग अनुभव प्राप्त करने के लिए सशक्त बना सकते हैं।