टक्कर से पावर-अप मिलता है या गेम खत्म हो जाता है, आपको इसका पता लगाने में सक्षम होना चाहिए। यहां बताया गया है कि पायथन की आर्केड लाइब्रेरी के साथ ऐसा कैसे करें।

टकराव वीडियो गेम की कई शैलियों में गेमप्ले का मूलभूत पहलू है। वे खेलों में चुनौती और उत्साह की एक परत जोड़ते हैं, जिससे खिलाड़ियों को बाधाओं को नेविगेट करने, दुश्मनों को चकमा देने और पुरस्कार इकट्ठा करने की आवश्यकता होती है।

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

एक साधारण खेल बनाना

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

पिप आर्केड स्थापित करें

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

आप पूरा पा सकते हैं इस GitHub रेपो में कोड.

instagram viewer

यहाँ खेल के लिए कोड है:

आयात आर्केड
स्क्रीन_WIDTH = 640
स्क्रीन_हाइट = 480
MOVEMENT_SPEED = 5


कक्षामेरा खेल(आर्केड। खिड़की):
डीईएफ़__इस में__(स्वयं, चौड़ाई, ऊंचाई):
 सुपर ()। __init__ (चौड़ाई, ऊंचाई, "मेरा खेल")
 आर्केड.सेट_बैकग्राउंड_कलर (आर्केड.रंग। सफ़ेद)
 सेल्फ.प्लेयर = आर्केड। स्प्राइटठोस रंग (50, 50, आर्केड. रंग। नीला)
 Self.player.center_x = SCREEN_WIDTH // 3
 सेल्फ.प्लेयर.सेंटर_वाई = 50
 स्व.दुश्मन = आर्केड। स्प्राइटठोस रंग (50, 50, आर्केड. रंग। लाल)
 Self.enemy.center_x = SCREEN_WIDTH // 2
 स्व.शत्रु.केंद्र_य = 50


डीईएफ़on_draw(खुद):
 आर्केड. start_render ()
 सेल्फ.प्लेयर.ड्रा ()
 स्व.शत्रु.ड्रा ()


डीईएफ़on_key_press(स्वयं, कुंजी, संशोधक):
अगर कुंजी == आर्केड.की। बाएं:
 Self.player.center_x -= MOVEMENT_SPEED
elif कुंजी == आर्केड.की। सही:
 Self.player.center_x += MOVEMENT_SPEED


डीईएफ़अद्यतन(स्वयं, डेल्टा_टाइम):
अगर आर्केड.चेक_फॉर_कोलिशन (स्व.खिलाड़ी, स्व.दुश्मन):
 प्रिंट ("खेल खत्म")


डीईएफ़मुख्य():
 game = MyGame (SCREEN_WIDTH, SCREEN_HEIGHT)
 आर्केड.रन ()
अगर __नाम__ == "__मुख्य__":
 मुख्य()

आर्केड की टक्कर का पता लगाने वाली विशेषताएं

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

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

यहाँ अद्यतन कोड है:

डीईएफ़अद्यतन(स्वयं, डेल्टा_टाइम):
अगर आर्केड.चेक_फॉर_कोलिशन (स्व.खिलाड़ी, स्व.दुश्मन):
 प्रिंट ("खेल खत्म")
अन्य:
 सेल्फ.प्लेयर.अपडेट ()

इस बदलाव के साथ, आपका गेम टक्करों का पता लगाएगा और प्रिंट करेगा खेल खत्म पाठ यदि खिलाड़ी दुश्मन से टकराता है।

अधिक सुविधाएँ जोड़ना

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

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

आयात अनियमित
कक्षामेरा खेल(आर्केड। खिड़की):
डीईएफ़__इस में__(स्वयं, चौड़ाई, ऊंचाई):
 सुपर ()। __init__ (चौड़ाई, ऊंचाई, "मेरा खेल")
 आर्केड.सेट_बैकग्राउंड_कलर (आर्केड.रंग। सफ़ेद)
 सेल्फ.प्लेयर = आर्केड। स्प्राइटठोस रंग (50, 50, आर्केड. रंग। नीला)
 Self.player.center_x = SCREEN_WIDTH // 2
 सेल्फ.प्लेयर.सेंटर_वाई = 50
 स्व.दुश्मन = आर्केड। स्प्राइटलिस्ट ()
 सेल्फ.स्कोर = 0
के लिए मैं में श्रेणी(3):
 शत्रु = आर्केड। स्प्राइटठोस रंग (50, 50, आर्केड. रंग। लाल)
 शत्रु.केंद्र_x = यादृच्छिक.रैंडिंट (0, स्क्रीन_WIDTH)
 दुश्मन.सेंटर_वाई = रैंडम.रैंडिंट (SCREEN_HEIGHT // 2, स्क्रीन_हाइट)
 स्व.दुश्मन।परिशिष्ट (दुश्मन)
डीईएफ़on_draw(खुद):
 आर्केड. start_render ()
 सेल्फ.प्लेयर.ड्रा ()
 स्व.दुश्मन.ड्रा ()
 आर्केड। ड्रा_टेक्स्ट (च "स्कोर: {स्व.स्कोर}", 10, स्क्रीन_हाइट - 30, आर्केड. रंग। काला, 16)
डीईएफ़अद्यतन(स्वयं, डेल्टा_टाइम):
अगर आर्केड.check_for_collision_with_list (स्वयं खिलाड़ी, स्वयं शत्रु):
 प्रिंट ("खेल खत्म")
 आर्केड.क्लोज़_विंडो ()
अन्य:
 सेल्फ.प्लेयर.अपडेट ()
के लिए दुश्मन में स्व.दुश्मन:
 शत्रु.केंद्र_य -= MOVEMENT_SPEED / 2
अगर शत्रु.केंद्र_य < 0:
 शत्रु.केंद्र_x = यादृच्छिक.रैंडिंट (0, स्क्रीन_WIDTH)
 दुश्मन.सेंटर_वाई = रैंडम.रैंडिंट (SCREEN_HEIGHT // 2, स्क्रीन_हाइट)
 सेल्फ.स्कोर += 1

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

टक्करों के साथ उपयोगकर्ता जुड़ाव में सुधार करें

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

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