आप जैसे पाठक MUO का समर्थन करने में मदद करते हैं। जब आप हमारी साइट पर लिंक का उपयोग करके खरीदारी करते हैं, तो हम संबद्ध कमीशन अर्जित कर सकते हैं। और पढ़ें।

Pygame गेम ऑब्जेक्ट्स के बीच टकराव का पता लगाने के लिए कई अंतर्निहित कार्य प्रदान करता है। ये अमूल्य हैं क्योंकि वास्तव में काम करना कब और कैसे चलती वस्तुओं को ओवरलैप करना एक जटिल कार्य हो सकता है।

pygame मॉड्यूल का उपयोग करके अपने खेल में बुनियादी भौतिकी और टकराव जोड़ना सीखें।

Pygame का बिल्ट-इन कोलिशन डिटेक्शन फ़ंक्शंस

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

Colled_sprites = pygame.sprite.spritecollide (sprite1, sprite_group, सत्य)

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

instagram viewer 

Collision_dict = pygame.sprite.groupcollide (समूह 1, समूह 2, सत्य, सत्य)

स्प्राइटकोलाइड फ़ंक्शन का उपयोग करके एक बुनियादी प्लेटफ़ॉर्मर गेम बनाना

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

आरंभ करना, पाइप का उपयोग करके पायगम मॉड्यूल स्थापित करें:

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

इसके बाद, सरल वर्ग बनाएँ प्लेयर और प्लेटफ़ॉर्म के लिए, दोनों को Pygame के स्प्राइट क्लास से विरासत में मिलना चाहिए। वेग के आधार पर प्लेयर की स्थिति को संभालने के लिए प्लेयर क्लास में एक अद्यतन विधि होनी चाहिए। साथ ही, गुरुत्वाकर्षण प्रभाव लागू करने के लिए इसमें y_velocity चर होना चाहिए। प्लेटफ़ॉर्म वर्ग में एक __init__ विधि होनी चाहिए जो प्लेटफ़ॉर्म के निर्देशांक लेती है और उस आकार के साथ एक सतह बनाती है।

खिलाड़ी वर्ग

आप pygame.sprite का उपयोग करके प्लेयर क्लास बना सकते हैं। स्प्राइट मॉड्यूल। यह वर्ग खिलाड़ी को दिए गए x और y निर्देशांक के साथ प्रारंभ करेगा। फिर, अद्यतन विधि y_वेग मान को बढ़ाकर खिलाड़ी की स्थिति को अद्यतन करेगी।

आयात pygame
कक्षाखिलाड़ी(पायगैम.स्प्राइट. स्प्राइट):
डीईएफ़__इस में__(स्वयं, एक्स, वाई):
 सुपर ()। __init__ ()
 सेल्फ.इमेज = पायगेम. सतह((32, 32))
 सेल्फ.रेक्ट = सेल्फ.इमेज.गेट_रेक्ट (टॉपलेफ्ट=(x, y))
 स्व.य_वेग = 0
डीईएफ़अद्यतन(खुद):
 Self.rect.y += self.y_velocity

प्लेटफार्म वर्ग

प्लेटफ़ॉर्म वर्ग भी pygame.sprite का उपयोग करता है। स्प्राइट मॉड्यूल। यह वर्ग दिए गए x और y निर्देशांक के साथ-साथ चौड़ाई और ऊंचाई के साथ मंच को प्रारंभ करेगा।

कक्षाप्लैटफ़ॉर्म(पायगैम.स्प्राइट. स्प्राइट):
डीईएफ़__इस में__(स्वयं, एक्स, वाई, चौड़ाई, ऊंचाई):
 सुपर ()। __init__ ()
 सेल्फ.इमेज = पायगेम. सतह ((चौड़ाई, ऊंचाई))
 सेल्फ.रेक्ट = सेल्फ.इमेज.गेट_रेक्ट (टॉपलेफ्ट=(x, y))

गेम लूप

गेम लूप आपको 640x480 के आकार के साथ एक विंडो बनाने की अनुमति देगा। फिर, यह एक लूप चलाएगा जो किसी भी घटना की जाँच करेगा, जैसे कि एक क्विट कमांड। यह खिलाड़ी और प्लेटफॉर्म के बीच किसी टकराव की भी जांच करेगा। अंत में, यह स्क्रीन को सफेद रंग से भर देगा, प्लेयर और प्लेटफॉर्म को ड्रा करेगा, और फिर डिस्प्ले को फ्लिप करेगा।

खिलाड़ी = खिलाड़ी (100, 300)
प्लेयर_ग्रुप = पायगेम.स्प्राइट। समूह()
खिलाड़ी_समूह.एड (खिलाड़ी)
मंच = प्लेटफार्म (50, 400, 100, 20)
platform_group = pygame.sprite। समूह()
platform_group.add (मंच)


# Pygame को इनिशियलाइज़ करें और विंडो बनाएँ
pygame.init ()
स्क्रीन = pygame.display.set_mode ((640, 480))


# मुख्य गेम लूप
चल रहा है = सत्य


जबकि दौड़ना:
के लिए आयोजन में pygame.event.get ():
अगर event.type == pygame. छोड़ना:
 चल रहा है = असत्य

 खिलाड़ी_ग्रुप.अपडेट ()
 टकराया = pygame.sprite.spritecollide (खिलाड़ी, platform_group, असत्य)


अगर टकराया:
 खिलाड़ी.y_वेग = 0
 स्क्रीन.फिल ((255, 255, 255))
 प्लेयर_ग्रुप.ड्रा (स्क्रीन)
 platform_group.draw (स्क्रीन)
 pygame.display.flip ()
pygame.quit ()

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

ग्रेविटी और जंपिंग बिहेवियर को लागू करना

अपने प्लेटफ़ॉर्मर गेम में ग्रेविटी और जंपिंग व्यवहार को लागू करने के लिए, आपको अपने प्लेयर स्प्राइट में एक y वेग जोड़ना होगा और प्रत्येक फ्रेम में इसकी y स्थिति को अपडेट करना होगा। ऐसा करने के लिए आप प्लेयर क्लास के अंदर अपडेट विधि का उपयोग कर सकते हैं और निम्न कोड स्निपेट जोड़ सकते हैं:

कक्षाखिलाड़ी(पायगैम.स्प्राइट. स्प्राइट):
डीईएफ़__इस में__(स्वयं, एक्स, वाई):
 सुपर ()। __init__ ()
 सेल्फ.इमेज = पायगेम. सतह((32, 32))
 सेल्फ.रेक्ट = सेल्फ.इमेज.गेट_रेक्ट (टॉपलेफ्ट=(x, y))
 स्व.य_वेग = 0
डीईएफ़अद्यतन(खुद):
 Self.rect.y += self.y_velocity
 स्व.य_वेग += गुरुत्वाकर्षण # गुरुत्वाकर्षण को y वेग पर लागू करें

अब हर बार जब आप अपडेट मेथड को कॉल करते हैं, तो यह प्लेयर की स्थिति को उसके वेग और गुरुत्वाकर्षण के अनुसार अपडेट करेगा।

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

JUMP_VELOCITY = -10
# गेम लूप के अंदर
अगर event.type == pygame. चाबी नीचे और event.key == pygame. के_स्पेस:
 खिलाड़ी.y_वेग = JUMP_VELOCITY

ध्यान दें कि कुंजी मान की जाँच करने से पहले आपको यह सुनिश्चित करने के लिए event.type की जाँच करनी होगी कि ईवेंट एक KEYDOWN ईवेंट है।

घर्षण और त्वरण जैसे बुनियादी भौतिकी को जोड़ना

अपने प्लेटफ़ॉर्मर गेम में घर्षण और त्वरण जैसी बुनियादी भौतिकी जोड़ने के लिए, आपको प्रत्येक फ्रेम में अपने प्लेयर स्प्राइट के x वेग को अपडेट करना होगा। आप खिलाड़ी वर्ग में x वेग जोड़ सकते हैं और इसे उसी तरह अद्यतन कर सकते हैं जैसे y वेग। घर्षण को लागू करने के लिए, आप प्रत्येक फ्रेम में प्लेयर स्प्राइट के x वेग को थोड़ी मात्रा में कम कर सकते हैं। उदाहरण के लिए, आप प्लेयर क्लास के अपडेट मेथड में निम्नलिखित कोड स्निपेट जोड़ सकते हैं:

घर्षण = 0.9
कक्षाखिलाड़ी(पायगैम.स्प्राइट. स्प्राइट):
डीईएफ़__इस में__(स्वयं, एक्स, वाई):
 सुपर ()। __init__ ()
 सेल्फ.इमेज = पायगेम. सतह((32, 32))
 सेल्फ.रेक्ट = सेल्फ.इमेज.गेट_रेक्ट (टॉपलेफ्ट=(x, y))
 स्व.य_वेग = 0
 स्व.x_वेग = 0
डीईएफ़अद्यतन(खुद):
 Self.rect.y += self.y_velocity
 स्व.आयत.x += स्व.x_वेग
 स्व.य_वेग += गुरुत्वाकर्षण # गुरुत्वाकर्षण को y वेग पर लागू करें
 स्व.x_वेग *= घर्षण # घर्षण को x वेग पर लागू करें

त्वरण लागू करने के लिए, आप क्षैतिज गति के लिए एक वेरिएबल, प्लेयर_मूवमेंट सेट कर सकते हैं, और प्लेयर_मूवमेंट मान के अनुसार प्लेयर स्प्राइट के एक्स वेग को अपडेट कर सकते हैं। आप गतिविधि को विशिष्ट कुंजियों या बटनों से बाइंड करके और इवेंट लूप में प्लेयर के x वेलोसिटी को अपडेट करके ऐसा कर सकते हैं, उदाहरण के लिए:

त्वरण = 0.5
प्लेयर_मूवमेंट = 0
अगर event.type == pygame. चाबी नीचे:
अगर event.key == pygame. K_LEFT:
 प्लेयर_मूवमेंट = -1
elif event.key == pygame. के_दाएं:
 प्लेयर_मूवमेंट = 1
elif event.type == pygame. तनाव के स्थिति में:
अगर घटना कुंजी में (पायगैम. K_LEFT, पायगेम. के_दाएं):
 प्लेयर_मूवमेंट = 0

खिलाड़ी.x_वेग += खिलाड़ी_आंदोलन * त्वरण

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

आप में पूरा कोड पा सकते हैं गिटहब रिपॉजिटरी.

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

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

कई खेलों में किसी प्रकार की टक्कर का पता लगाने की आवश्यकता होती है। आप टकराव का उपयोग गेम यांत्रिकी की एक विस्तृत श्रृंखला बनाने के लिए कर सकते हैं, साधारण प्लेटफ़ॉर्मर्स से लेकर जटिल भौतिकी-आधारित सिमुलेशन तक।

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