बेतरतीब चलती वस्तुओं को जोड़कर अपने आर्केड गेम्स को और भी मज़ेदार और रोमांचक बनाएं।

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

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

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

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

उसके बाद, का उपयोग करके एक विंडो बनाएं आर्केड। खिड़की क्लास और पृष्ठभूमि का रंग सफेद पर सेट करें।

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

खिलाड़ी की स्थिति को क्षैतिज रूप से स्क्रीन के मध्य में सेट करें और ऊपर से थोड़ी दूरी जोड़ें। आप तीर कुंजियों का उपयोग करके खिलाड़ी की गति को नियंत्रित कर सकते हैं।

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

आयात आर्केड
स्क्रीन_WIDTH = 800
स्क्रीन_हाइट = 600
PLAYER_RADIUS = 15


कक्षामेरा खेल(आर्केड। खिड़की):





instagram viewer


डीईएफ़__इस में__(स्वयं, चौड़ाई, ऊंचाई):
 सुपर ()। __init__ (चौड़ाई, ऊंचाई)
 आर्केड.सेट_बैकग्राउंड_कलर (आर्केड.रंग। सफ़ेद)


 Self.player_x = SCREEN_WIDTH // 2
 सेल्फ.प्लेयर_य = PLAYER_RADIUS + 10


डीईएफ़on_draw(खुद):
 आर्केड. start_render ()
 आर्केड.ड्रॉ_सर्कल_फिल्ड (सेल्फ.प्लेयर_एक्स, सेल्फ.प्लेयर_य, प्लेयर_रेडियस, आर्केड.कलर। नीला)


डीईएफ़अद्यतन(स्वयं, डेल्टा_टाइम):
उत्तीर्ण


डीईएफ़on_key_press(स्वयं, कुंजी, संशोधक):
अगर कुंजी == आर्केड.की। बाएं:
 स्व.खिलाड़ी_x -= 5
elif कुंजी == आर्केड.की। सही:
 सेल्फ.प्लेयर_x += 5
अगर __नाम__ == "__मुख्य__":
 game = MyGame (SCREEN_WIDTH, SCREEN_HEIGHT)
 आर्केड.रन ()

एकाधिक वस्तुओं को जोड़ना

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

अपने गेम कोड में, नामक एक सूची जोड़ें वस्तुओं यादृच्छिक चलती वस्तुओं की स्थिति को स्टोर करने के लिए। उसके बाद, वस्तुओं की संख्या उत्पन्न करें (NUM_OBJECTS) स्क्रीन सीमाओं के भीतर यादृच्छिक x और y निर्देशांक के साथ। का उपयोग करके वस्तुओं को लाल घेरे के रूप में खींचा जाता है आर्केड.ड्रॉ_सर्कल_फिल्ड समारोह।

आयात आर्केड
आयात अनियमित
स्क्रीन_WIDTH = 800
स्क्रीन_हाइट = 600
PLAYER_RADIUS = 15
OBJECT_RADIUS = 10
NUM_OBJECTS = 10


कक्षामेरा खेल(आर्केड। खिड़की):
डीईएफ़__इस में__(स्वयं, चौड़ाई, ऊंचाई):
 सुपर ()। __init__ (चौड़ाई, ऊंचाई)
 आर्केड.सेट_बैकग्राउंड_कलर (आर्केड.रंग। सफ़ेद)


 Self.player_x = SCREEN_WIDTH // 2
 सेल्फ.प्लेयर_य = PLAYER_RADIUS + 10


 स्व.ऑब्जेक्ट्स = []
के लिए _ में सीमा (NUM_OBJECTS):
 एक्स = यादृच्छिक रैंडिंट (0, स्क्रीन_WIDTH)
 वाई = यादृच्छिक रैंडिंट (0, स्क्रीन_हाइट)
 self.objects.append ((x, y))


डीईएफ़on_draw(खुद):
 आर्केड. start_render ()
 आर्केड.ड्रॉ_सर्कल_फिल्ड (सेल्फ.प्लेयर_एक्स, सेल्फ.प्लेयर_य, प्लेयर_रेडियस, आर्केड.कलर। नीला)


के लिए obj में सेल्फ.ऑब्जेक्ट्स:
 एक्स, वाई = ओबीजे
 आर्केड.ड्रॉ_सर्कल_फिल्ड (x, y, OBJECT_RADIUS, आर्केड.कलर। लाल)


डीईएफ़अद्यतन(स्वयं, डेल्टा_टाइम):
उत्तीर्ण


डीईएफ़on_key_press(स्वयं, कुंजी, संशोधक):
अगर कुंजी == आर्केड.की। बाएं:
 स्व.खिलाड़ी_x -= 5
elif कुंजी == आर्केड.की। सही:
 सेल्फ.प्लेयर_x += 5
अगर __नाम__ == "__मुख्य__":
 game = MyGame (SCREEN_WIDTH, SCREEN_HEIGHT)
 आर्केड.रन ()

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

रैंडम मूवमेंट एल्गोरिथम को लागू करना

वस्तुओं को बेतरतीब ढंग से स्थानांतरित करने के लिए, में उनकी स्थिति को अपडेट करें अद्यतन एक यादृच्छिक आंदोलन एल्गोरिथ्म का उपयोग करने की विधि।

प्रत्येक वस्तु के माध्यम से पुनरावृति करें और इसके लिए यादृच्छिक मान उत्पन्न करें डीएक्स और डीवाई, x और y निर्देशांक में परिवर्तन का प्रतिनिधित्व करता है। फिर इन मानों को जोड़कर वस्तु की स्थिति को अद्यतन करें। यहाँ संशोधित कोड है:

डीईएफ़अद्यतन(स्वयं, डेल्टा_टाइम):
के लिए मैं में सीमा (NUM_OBJECTS):
 एक्स, वाई = स्व। ऑब्जेक्ट्स [i]
 डीएक्स = यादृच्छिक रैंडिंट (-5, 5)
 डीई = यादृच्छिक रैंडिंट (-5, 5)
 एक्स + = डीएक्स
 वाई + = डाई
 स्व। ऑब्जेक्ट्स [i] = (एक्स, वाई)

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

ऑब्जेक्ट खिलाड़ी की ओर बढ़ रहा है

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

इसके लिए, वस्तु और खिलाड़ी के बीच x और y निर्देशांक में अंतर की गणना करें। इन मानों को सामान्य करके, आप एक दिशा सदिश प्राप्त करते हैं। फिर इस सदिश को गति कारक (इस मामले में 3) से गुणा करें और इसे वस्तु की स्थिति में जोड़ें। यहाँ अद्यतन है अद्यतन तरीका:

डीईएफ़अद्यतन(स्वयं, डेल्टा_टाइम):
के लिए मैं में सीमा (NUM_OBJECTS):
 एक्स, वाई = स्व। ऑब्जेक्ट्स [i]
 डीएक्स = सेल्फ.प्लेयर_एक्स - एक्स
 डीई = स्व.प्लेयर_वाई - वाई
 दूरी = गणित.sqrt (dx ** 2 + डाई ** 2)
 डीएक्स / = दूरी
 डाई / = दूरी
 एक्स += डीएक्स * 3
 वाई + = डाई * 3
 स्व। ऑब्जेक्ट्स [i] = (एक्स, वाई)

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

जब खिलाड़ी आसपास में प्रवेश करता है तो वस्तुएं हिलना शुरू हो जाती हैं

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

डीईएफ़अद्यतन(स्वयं, डेल्टा_टाइम):
के लिए मैं में सीमा (NUM_OBJECTS):
 एक्स, वाई = स्व। ऑब्जेक्ट्स [i]
 डीएक्स = सेल्फ.प्लेयर_एक्स - एक्स
 डीई = स्व.प्लेयर_वाई - वाई
 दूरी = गणित.sqrt (dx ** 2 + डाई ** 2)

अगर दूरी < 100: # त्रिज्या को आवश्यकतानुसार समायोजित करें
 डीएक्स / = दूरी
 डाई / = दूरी
 एक्स += डीएक्स * 3
 वाई + = डाई * 3
 स्व। ऑब्जेक्ट्स [i] = (एक्स, वाई)

टक्कर का पता लगाने और बातचीत

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

डीईएफ़अद्यतन(स्वयं, डेल्टा_टाइम):
के लिए मैं में सीमा (NUM_OBJECTS):
 एक्स, वाई = स्व। ऑब्जेक्ट्स [i]
 डीएक्स = सेल्फ.प्लेयर_एक्स - एक्स
 डीई = स्व.प्लेयर_वाई - वाई
 दूरी = गणित.sqrt (dx ** 2 + डाई ** 2)

अगर दूरी < PLAYER_RADIUS + OBJECT_RADIUS:
# टक्कर हुई है तो यहां संभाल लें
 सेल्फ.ऑब्जेक्ट्स.पॉप (i)
 self.objects.append ((रैंडम.रैंडिंट (0, SCREEN_WIDTH), रैंडम.रैंडिंट (0, स्क्रीन_हाइट)))

elif दूरी < 100:
 डीएक्स / = दूरी
 डाई / = दूरी
 एक्स += डीएक्स * 3
 वाई + = डाई * 3
 स्व। ऑब्जेक्ट्स [i] = (एक्स, वाई)

यादृच्छिकता को संतुलित करना

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

अधिकतम गति को सीमित करना

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

डीईएफ़अद्यतन(स्वयं, डेल्टा_टाइम):
के लिए मैं में सीमा (NUM_OBJECTS):
 एक्स, वाई = स्व। ऑब्जेक्ट्स [i]
 डीएक्स = सेल्फ.प्लेयर_एक्स - एक्स
 डीई = स्व.प्लेयर_वाई - वाई
 दूरी = गणित.sqrt (dx ** 2 + डाई ** 2)
अगर दूरी < PLAYER_RADIUS + OBJECT_RADIUS:
 सेल्फ.ऑब्जेक्ट्स.पॉप (i)
 self.objects.append ((रैंडम.रैंडिंट (0, SCREEN_WIDTH), रैंडम.रैंडिंट (0, स्क्रीन_हाइट)))
elif दूरी < 100:
 डीएक्स / = दूरी
 डाई / = दूरी


 गति = 3# गति मान को आवश्यकतानुसार समायोजित करें
 dx = न्यूनतम (अधिकतम (dx * गति, -MAX_SPEED), MAX_SPEED)
 डाई = न्यूनतम (अधिकतम (डाई * गति, -MAX_SPEED), MAX_SPEED)
 एक्स + = डीएक्स
 वाई + = डाई
 स्व। ऑब्जेक्ट्स [i] = (एक्स, वाई)

स्पॉन दर को नियंत्रित करना

आप उस दर को भी नियंत्रित कर सकते हैं जिस पर खेल में नई वस्तुएं पैदा होती हैं। नई वस्तुओं को उत्पन्न करने के बीच विलंब शामिल करने के लिए कोड समायोजित करें:

आयात समय
कक्षामेरा खेल(आर्केड। खिड़की):
डीईएफ़__इस में__(स्वयं, चौड़ाई, ऊंचाई):
 सुपर ()। __init__ (चौड़ाई, ऊंचाई)
 आर्केड.सेट_बैकग्राउंड_कलर (आर्केड.रंग। सफ़ेद)


 Self.player_x = SCREEN_WIDTH // 2
 सेल्फ.प्लेयर_य = PLAYER_RADIUS + 10


 स्व.ऑब्जेक्ट्स = []
 self.last_spawn_time = समय.समय ()


डीईएफ़अद्यतन(स्वयं, डेल्टा_टाइम):
# यहां स्पॉनिंग रेट को नियंत्रित करें
अगर time.time() - self.last_spawn_time > SPAWN_DELAY:
अगर लेन (self.objects)  self.objects.append ((रैंडम.रैंडिंट (0, SCREEN_WIDTH), रैंडम.रैंडिंट (0, स्क्रीन_हाइट)))
 self.last_spawn_time = समय.समय ()


के लिए मैं में रेंज (लेन (सेल्फ.ऑब्जेक्ट्स)):
 एक्स, वाई = स्व। ऑब्जेक्ट्स [i]
 डीएक्स = सेल्फ.प्लेयर_एक्स - एक्स
 डीई = स्व.प्लेयर_वाई - वाई
 दूरी = गणित.sqrt (dx ** 2 + डाई ** 2)


अगर दूरी < PLAYER_RADIUS + OBJECT_RADIUS:
 सेल्फ.ऑब्जेक्ट्स.पॉप (i)
 self.objects.append ((रैंडम.रैंडिंट (0, SCREEN_WIDTH), रैंडम.रैंडिंट (0, स्क्रीन_हाइट)))
elif दूरी < 100:
 डीएक्स / = दूरी
 डाई / = दूरी
 एक्स += डीएक्स * 3
 वाई + = डाई * 3
 स्व। ऑब्जेक्ट्स [i] = (एक्स, वाई)

समायोजित SPWN_DELAY और MAX_OBJECTS अपने खेल के लिए सही संतुलन खोजने के लिए मूल्य। एक लंबी देरी या वस्तुओं की अधिकतम संख्या कम होने से खेल कम भीड़ वाला हो जाएगा। जबकि, कम विलंब या अधिक अधिकतम कठिनाई को बढ़ा देगा।

गतिमान वस्तुओं का उपयोग करके खेलों को और मज़ेदार बनाएं

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