पायथन का उपयोग करके मेमोरी टाइल गेम कैसे बनाएं

मेमोरी टाइल या मैचिंग गेम संज्ञानात्मक क्षमताओं को बढ़ावा देने, याददाश्त बढ़ाने और फोकस में सुधार करने का एक उत्कृष्ट और मजेदार तरीका है। गेम में टाइलों का एक सेट है जिसे आपको एक-एक करके पलटना है, याद रखना है और मिलान करने वाली टाइलों का चयन करना है। सभी टाइलों का सही मिलान करने पर, आप गेम जीत जाते हैं।

तो आप Python का उपयोग करके इस अद्भुत गेम को कैसे विकसित कर सकते हैं?

टिंकर और रैंडम मॉड्यूल

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

पिप टिंकर स्थापित करें

रैंडम मॉड्यूल एक अंतर्निहित पायथन मॉड्यूल है जिसका उपयोग छद्म-यादृच्छिक संख्या उत्पन्न करने के लिए किया जाता है। इसका उपयोग करना, आप एक यादृच्छिक पासवर्ड जनरेटर बना सकते हैं

, एक डाइस रोल सिमुलेशन एप्लिकेशन, या एक सूची शफलर। इसके अलावा आप भी कर सकते हैं हैंड क्रिकेट जैसे दिलचस्प खेल विकसित करें और संख्या अनुमान लगाने का खेल।

पायथन का उपयोग करके मेमोरी टाइल गेम कैसे बनाएं

आप इसमें पायथन का उपयोग करके मेमोरी टाइल गेम बनाने के लिए स्रोत कोड पा सकते हैं गिटहब रिपॉजिटरी.

टिंकर और रैंडम मॉड्यूल को आयात करके शुरू करें। रूट विंडो प्रारंभ करें, और पिक्सेल में शीर्षक और आयाम सेट करें।

से tkinter आयात *
आयात अनियमित
से tkinter आयात संदेश बॉक्स
रूट = टीके ()
जड़ शीर्षक ('मेमोरी टाइल गेम')
रूट.ज्यामिति ("760x550")

दो वैश्विक चर परिभाषित करें और विजेता चर को शून्य पर प्रारंभ करें। टाइल्स पर दिखाई देने वाली वस्तुओं की एक सूची घोषित करें। यादृच्छिक मॉड्यूल का उपयोग करके सूची को पुन: व्यवस्थित करें फेरबदल () तरीका। रूट विंडो में एक फ्रेम परिभाषित करें और ऊर्ध्वाधर दिशा में 10 की पैडिंग जोड़ें।

गिनती चर को 0 पर प्रारंभ करें और क्रमशः एक उत्तर सूची और शब्दकोश घोषित करें।

वैश्विक विजेता, मैच
विजेता = 0
मैच = ["सेब","सेब","केला","केला", "नारंगी","नारंगी", "ब्लूबेरी","ब्लूबेरी","शहतूत","शहतूत", "अंगूर","अंगूर"]
random.shuffle (मैच)
my_frame = फ़्रेम (रूट)
my_frame.pack (पैडी=10)
गिनती = 0
उत्तर_सूची = []
answer_dict = {}

एक समारोह परिभाषित करें, रीसेट(). का उपयोग करके लेबल के टेक्स्ट को खाली स्ट्रिंग पर सेट करें विन्यास () समारोह। प्रत्येक टाइल के लिए एक बटन सूची परिभाषित करें। सूची पर पुनरावृति करें और बटन टाइल पर पाठ को खाली स्ट्रिंग पर सेट करें, पृष्ठभूमि का रंग डिफ़ॉल्ट (SystemButtonFace), और राज्य सामान्य करने के लिए।

डीईएफ़रीसेट():
 my_label.config (पाठ ="")
 बटन_सूची = [बी0,बी1,बी2,बी3,बी4,बी5,बी6,बी7,बी8,बी9,बी10,बी11]
के लिए बटन में बटन_सूची:
 बटन.कॉन्फिग (पाठ =" ", बीजी ="सिस्टमबटनफेस", राज्य ="सामान्य")

एक समारोह परिभाषित करें, जीतना(). का उपयोग करके लेबल के टेक्स्ट पैरामीटर में विजयी संदेश सेट करें विन्यास () समारोह। बटन सूची को पहले की तरह परिभाषित करें और टाइल की पृष्ठभूमि के रंग को हल्के हरे रंग में सेट करने के लिए इसके माध्यम से पुनरावृति करें।

डीईएफ़जीतना():
 my_label.config (पाठ ="बधाई हो! आप जीतते हैं!")
 बटन_सूची = [बी0,बी1,बी2,बी3,बी4,बी5,बी6,बी7,बी8,बी9,बी10,बी11]
के लिए बटन में बटन_सूची:
 बटन कॉन्फिग (बीजी ="#90EE90")

एक समारोह परिभाषित करें, बटन_क्लिक () जो बटन और उसकी संख्या को इनपुट पैरामीटर के रूप में लेता है। वैश्विक चर, सूची और शब्दकोश का संदर्भ लें। यदि बटन का पाठ एक स्थान के बराबर है और गिनती दो से कम है तो बटन का पाठ सम्मिलित करें और प्रदर्शित करें। बटन संख्या को उत्तर सूची में और नाम को उत्तर शब्दकोश में जोड़ें। गिनती चर को एक से बढ़ाएँ।

डीईएफ़बटन_क्लिक(बी, संख्या):
वैश्विक गिनती, उत्तर_सूची, उत्तर_डिक्ट, विजेता
अगर बी["मूलपाठ"] == ' 'और गिनती < 2:
 बी["मूलपाठ"] = मैच [संख्या]
 answer_list.append (संख्या)
 answer_dict[बी] = मैच [संख्या]
 गिनती + = 1

यदि उत्तर सूची की लंबाई दो है, तो इसका अर्थ है कि उपयोगकर्ता ने दो टाइलों का चयन किया है। यदि पहली टाइल का पाठ दूसरे से मेल खाता है, तो लेबल को यह प्रदर्शित करने के लिए कॉन्फ़िगर करें कि दोनों सही ढंग से मेल खाते हैं। बटन की स्थिति को अक्षम करें। गिनती को शून्य पर सेट करें, और सूची और शब्दकोश को खाली करें। विजेता चर को एक से बढ़ाएँ और यदि यह छह हो जाता है, तो पहले घोषित जीत फ़ंक्शन को कॉल करें।

अगर लेन (उत्तर_सूची) == 2:
अगर मैच [जवाब_सूची]0]] == मैच [जवाब_सूची [1]]:
 my_label.config (पाठ ="यह एक मेल है!")
के लिए चाबी में answer_dict:
 चाबी["राज्य"] = "अक्षम"
 गिनती = 0
 उत्तर_सूची = []
 answer_dict = {}
 विजेता + = 1
अगर विजेता == 6:
 जीतना()

अन्यथा, गिनती चर और सूची को रीसेट करें। शीर्षक और सामग्री को गलत मिलान के रूप में दर्शाने वाला एक संदेश बॉक्स प्रदर्शित करें। उत्तर सूची पर पुनरावृति करें और टाइल के पाठ को एक स्थान पर सेट करें। लेबल को रीसेट करें और शब्दकोश को खाली करें। यह सुनिश्चित करता है कि उपयोगकर्ता द्वारा गलत टाइलों का चयन करने के बाद बटन और लेबल पर कोई दृश्य पाठ नहीं है।

अन्य:
 गिनती = 0
 उत्तर_सूची = []
 संदेशबॉक्स.शोइन्फो ("गलत!", "गलत")
के लिए चाबी में answer_dict:
 चाबी["मूलपाठ"] = " "
 my_label.config (पाठ =" ")
 answer_dict = {}

12 बटन परिभाषित करें। वह मूल विंडो सेट करें जिसमें आप उन्हें रखना चाहते हैं, वह पाठ जो उन्हें प्रदर्शित करना चाहिए, फ़ॉन्ट शैली जो उन्हें होनी चाहिए, उनकी ऊंचाई और चौड़ाई, और क्लिक करने पर निष्पादित करने का आदेश। डेटा को पास करने के लिए लैम्ब्डा फ़ंक्शन का उपयोग करना याद रखें बटन_क्लिक () समारोह। ठीक राहत के लिए पैरामीटर नाली बटन के चारों ओर 3-डी गहराई प्रभाव बनाने के लिए।

b0 = बटन (my_frame, टेक्स्ट =' ', फॉन्ट=("हेल्वेटिका", 20), ऊंचाई =4, चौड़ाई =8, कमांड =लैम्ब्डा: बटन_क्लिक (बी 0, 0), राहत ="नाली")
बी 1 = बटन (my_frame, टेक्स्ट =' ', फॉन्ट=("हेल्वेटिका", 20), ऊंचाई =4, चौड़ाई =8, कमांड =लैम्ब्डा: बटन_क्लिक (बी 1, 1), राहत ="नाली")
बी 2 = बटन (my_frame, टेक्स्ट =' ', फॉन्ट=("हेल्वेटिका", 20), ऊंचाई =4, चौड़ाई =8, कमांड =लैम्ब्डा: बटन_क्लिक (बी2, 2), राहत ="नाली")
बी 3 = बटन (my_frame, टेक्स्ट =' ', फॉन्ट=("हेल्वेटिका", 20), ऊंचाई =4, चौड़ाई =8, कमांड =लैम्ब्डा: बटन_क्लिक (बी3, 3), राहत ="नाली")
बी 4 = बटन (my_frame, टेक्स्ट =' ', फॉन्ट=("हेल्वेटिका", 20), ऊंचाई =4, चौड़ाई =8, कमांड =लैम्ब्डा: बटन_क्लिक (बी 4, 4), राहत ="नाली")
बी 5 = बटन (my_frame, टेक्स्ट =' ', फॉन्ट=("हेल्वेटिका", 20), ऊंचाई =4, चौड़ाई =8, कमांड =लैम्ब्डा: बटन_क्लिक (बी 5, 5), राहत ="नाली")
बी 6 = बटन (my_frame, टेक्स्ट =' ', फॉन्ट=("हेल्वेटिका", 20), ऊंचाई =4, चौड़ाई =8, कमांड =लैम्ब्डा: बटन_क्लिक (बी 6, 6), राहत ="नाली")
बी 7 = बटन (my_frame, टेक्स्ट =' ', फॉन्ट=("हेल्वेटिका", 20), ऊंचाई =4, चौड़ाई =8, कमांड =लैम्ब्डा: बटन_क्लिक (बी 7, 7), राहत ="नाली")
बी 8 = बटन (my_frame, टेक्स्ट =' ', फॉन्ट=("हेल्वेटिका", 20), ऊंचाई =4, चौड़ाई =8, कमांड =लैम्ब्डा: बटन_क्लिक (बी 8, 8), राहत ="नाली")
बी 9 = बटन (my_frame, टेक्स्ट =' ', फॉन्ट=("हेल्वेटिका", 20), ऊंचाई =4, चौड़ाई =8, कमांड =लैम्ब्डा: बटन_क्लिक (बी 9, 9), राहत ="नाली")
बी 10 = बटन (my_frame, टेक्स्ट =' ', फॉन्ट=("हेल्वेटिका", 20), ऊंचाई =4, चौड़ाई =8, कमांड =लैम्ब्डा: बटन_क्लिक (बी 10, 10), राहत ="नाली")
b11 = बटन (my_frame, टेक्स्ट =' ', फॉन्ट=("हेल्वेटिका", 20), ऊंचाई =4, चौड़ाई =8, कमांड =लैम्ब्डा: बटन_क्लिक (बी 11, 11), राहत ="नाली")

टिंकर के ग्रिड प्रबंधक का उपयोग करके तीन पंक्तियों और चार स्तंभों वाले सारणीबद्ध प्रारूप में बटनों को व्यवस्थित करें। ऐसा करने के लिए, कॉल करें जाल() विधि और पंक्ति को उस कॉलम संख्या के साथ पास करें जिसमें आप इसे रखना चाहते हैं।

b0.ग्रिड (पंक्ति =0, स्तंभ =0)
b1.ग्रिड (पंक्ति =0, स्तंभ =1)
b2.ग्रिड (पंक्ति =0, स्तंभ =2)
b3.grid (पंक्ति =0, स्तंभ =3)
b4.ग्रिड (पंक्ति =1, स्तंभ =0)
b5.ग्रिड (पंक्ति =1, स्तंभ =1)
b6.ग्रिड (पंक्ति =1, स्तंभ =2)
b7.ग्रिड (पंक्ति =1, स्तंभ =3)
b8.ग्रिड (पंक्ति =2, स्तंभ =0)
b9.ग्रिड (पंक्ति =2, स्तंभ =1)
b10.ग्रिड (पंक्ति =2, स्तंभ =2)
b11.ग्रिड (पंक्ति =2, स्तंभ =3)

एक लेबल परिभाषित करें जो एक खाली स्ट्रिंग दिखाता है और लंबवत दिशा में 20 की पैडिंग जोड़ें। रूट विंडो पर एक शीर्ष-स्तरीय मेनू परिभाषित करें और इसे घुमाकर संलग्न करें चीरना के लिए पैरामीटर असत्य. एक उप-मेनू आइटम जोड़ें, विकल्प का उपयोग add_cascade पैरामीटर।

नाम के सबमेनू में क्लिक किए जाने पर निष्पादित होने वाली कमांड के साथ दो मेनू आइटम जोड़ें गेम रीसेट करें और खेल से बाहर जाएं. सीमांकन के लिए उनके बीच एक विभाजक जोड़ें।

my_label = लेबल (रूट, टेक्स्ट ="")
my_label.pack (पैडी=20)
my_menu = मेनू (रूट)
root.config (मेनू = my_menu)
विकल्प_मेनू = मेनू (my_menu, आंसू =असत्य)
my_menu.add_cascade (लेबल ="विकल्प", मेनू = विकल्प_मेनू)
option_menu.add_command (लेबल ="रीसेट गेम", कमांड = रीसेट)
option_menu.add_separator ()
option_menu.add_command (लेबल ="खेल से बाहर जाएं", कमांड = रूट.क्विट)

मुख्य घेरा() फ़ंक्शन पायथन को टिंकर इवेंट लूप चलाने के लिए कहता है और जब तक आप विंडो बंद नहीं करते तब तक ईवेंट सुनें।

रूट.मेनलूप ()

सभी कोड एक साथ रखें। अब मेमोरी टाइल गेम खेलने के लिए तैयार है।

मेमोरी टाइल गेम का आउटपुट

प्रोग्राम चलाने पर, खाली टेक्स्ट के साथ 12 बटन दिखाई देते हैं विकल्प मेन्यू। क्लिक करने पर गेम रीसेट करें, खिड़की इसी अंदाज में दिखाई देती है।

दो मेल खाने वाली टाइलों का चयन करने पर, बटन अक्षम दिखाई देते हैं और लेबल प्रदर्शित करता है कि चुनाव सही है।

मेल न खाने वाली दो टाइलों का चयन करने पर, एक संदेश बॉक्स प्रकट होता है जो दर्शाता है कि चयन गलत था। बटन और लेबल अपनी मूल खाली अवस्था में लौट आते हैं।

सभी विकल्पों का सफलतापूर्वक मिलान करने पर, कार्यक्रम सभी टाइलों को हरे रंग में बदल देता है और विजेता संदेश प्रदर्शित करता है।

गेम्स आप पायथन का उपयोग करके बना सकते हैं

पायथन गेम बनाने के लिए कई तरह के मॉड्यूल प्रदान करता है। हैंगमैन, टिक-टैक-टो, या रॉक पेपर कैंची जैसे सरल शब्द या पसंद-आधारित गेम बनाने के लिए आप टिंकर और रैंडम मॉड्यूल का उपयोग कर सकते हैं। ऐसे गेम विकसित करने के लिए जिनमें अधिक ग्राफिक्स की आवश्यकता होती है, आप Pygame का उपयोग कर सकते हैं।

Pygame Python मॉड्यूल का एक सेट है जो सभी प्लेटफॉर्म पर काम करता है। इसमें कंप्यूटर ग्राफिक्स और साउंड लाइब्रेरी शामिल हैं जो गेम को अधिक इंटरैक्टिव बनाती हैं। Pygame का उपयोग करके आप कुछ ऐसे गेम बना सकते हैं जिनमें स्नेक गेम, मेमोरी पज़ल गेम और सुडोकू शामिल हैं।