🕒 💟 🌡️ गोडोट इंजन पर खेल "सिक्कों की तरह" का निर्माण। भाग 1 🤴🏽 🚷 😍

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

परिचय

सबसे आसान चीज जो आप सोच सकते हैं, वह एक खेल है जिसमें हमारा मुख्य चरित्र सिक्के एकत्र करेगा। इसे थोड़ा जटिल करने के लिए, एक सीमित कारक के रूप में, एक बाधा और समय जोड़ें। खेल में 3 दृश्य होंगे: Player , Coin और HUD (यह लेख नहीं माना जाता है), जिसे एक Main दृश्य में जोड़ा जाएगा।

प्रोजेक्ट सेटिंग्स

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

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

प्रोग्राम मेनू में, Project -> Project Settings ।

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

Display/Window अनुभाग ढूंढें और चौड़ाई को 800 और ऊंचाई को 600 सेट करें। इस खंड में, Stretch/Mode को 2D सेट करें और Keep लिए Aspect । यह आकार बदलने पर खिड़की की सामग्री को खींचना और विरूपण को रोक देगा, लेकिन खिड़की को आकार बदलने से रोकने के लिए, बस Resizable बॉक्स को अनचेक करें। मैं आपको इन विकल्पों के साथ खेलने की सलाह देता हूं।

अब Rendering/Quality सेक्शन में जाएं और राइट पेन में Use Pixel Snap को ऑन Use Pixel Snap । यह किस लिए है? गोडोट इंजन में वैक्टर के निर्देशांक फ्लोटिंग पॉइंट नंबर हैं। चूंकि वस्तुओं को केवल आधे पिक्सेल से नहीं खींचा जा सकता है, यह विसंगति उन खेलों के लिए दृश्य दोष पैदा कर सकती है जो pixelart उपयोग करते हैं। और यह ध्यान देने योग्य है कि 3 डी में यह विकल्प बेकार है। इसे ध्यान में रखें।

खिलाड़ी दृश्य

चलिए पहला दृश्य बनाना शुरू करते हैं - Player ।

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

दृश्य बनाना एक सामान्य रूप से सरल क्रिया है - Scene टैब पर, + (जोड़ें / बनाएं) पर क्लिक करें और Area2D नोड का चयन करें और तुरंत इसका नाम बदल दें ताकि भ्रमित न हों। यह हमारा मूल नोड है, और आपको बाल नोड्स को जोड़ने के लिए आवश्यक कार्यक्षमता का विस्तार करना है। हमारे मामले में, ये AnimatedSprite और CollisionShape2D , लेकिन चलो जल्दी नहीं है, लेकिन चलो क्रम में शुरू करते हैं। अगला, रूट नोड को तुरंत "लॉक" करें:

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

AnimatedSprite

Area2D बहुत ही उपयोगी नोड है यदि आपको अन्य वस्तुओं के साथ या उनके टकराव के बारे में एक ओवरलैप घटना के बारे में जानने की आवश्यकता है, लेकिन अपने आप से यह आंख के लिए अदृश्य है और Player ऑब्जेक्ट को AnimatedSprite एडप्रिटसाइट जोड़कर दिखाई दे सकता है। नोड का नाम हमें बताता है कि हम एनिमेशन और स्प्राइट से निपटेंगे। Inspector विंडो में, Frames पैरामीटर पर जाएं और एक नया SpriteFrames । SpriteFrames पैनल के साथ काम करना आवश्यक एनिमेशन बनाना और उनके समान स्प्राइट्स को लोड करना है। हम एनिमेशन बनाने के सभी चरणों का विस्तार से विश्लेषण नहीं करेंगे, इसे स्वतंत्र अध्ययन के लिए छोड़ दें, मैं केवल यह कहूंगा कि हमारे पास तीन एनिमेशन होने चाहिए: walk (एनीमेशन walk ), idle (आराम करना राज्य) और die (मृत्यु या विफलता एनीमेशन)। SPEED (FPS) का मान मत भूलना 8 होना चाहिए (हालाँकि आप एक अलग मूल्य चुन सकते हैं - उपयुक्त)।

CollisionShape2D

Area2D लिए Area2D का पता लगाने के लिए, आपको इसे एक वस्तु के आकार के साथ प्रदान करना होगा। आकार Shape2D पैरामीटर द्वारा निर्धारित किए Shape2D हैं और इसमें आयत, वृत्त, बहुभुज और अन्य अधिक जटिल प्रकार के आकार शामिल होते हैं, और आकार पहले से ही संपादक में संपादित किए जाते हैं, लेकिन आप हमेशा अधिक ठीक-ट्यूनिंग के लिए Inspector उपयोग कर सकते हैं।

परिदृश्यों

अब, हमारे खेल ऑब्जेक्ट को "पुनर्जीवित" करने के लिए, आपको इसके लिए एक स्क्रिप्ट सेट करने की आवश्यकता है, जिसके अनुसार हमारे द्वारा निर्धारित किए गए कार्य, जो इस परिदृश्य में निर्धारित किए गए हैं, का प्रदर्शन किया जाएगा। Scene टैब में, एक स्क्रिप्ट बनाएं, डिफ़ॉल्ट सेटिंग्स छोड़ दें, सभी टिप्पणियों को हटा दें ('#' चिह्न के साथ शुरू होने वाली लाइनें) और चर घोषित करने के लिए आगे बढ़ें:

 export (int) var speed var velocity = Vector2() var window_size = Vector2(800, 600)

export कीवर्ड का उपयोग करने से आप Inspector पैनल विंडो में speed चर का मान सेट कर सकते हैं। यह एक बहुत ही उपयोगी विधि है यदि हम कस्टम मान प्राप्त करना चाहते हैं जो Inspector विंडो में संपादित करने के लिए सुविधाजनक है। Speed 350 सेट करें। velocity मान आंदोलन की दिशा निर्धारित करेगा, और window_size खिलाड़ी के आंदोलन को प्रतिबंधित करने वाला क्षेत्र है।

हमारे कार्यों का आगे का क्रम निम्नानुसार है: हम get_input() फ़ंक्शन का उपयोग करके यह get_input() कि कीबोर्ड इनपुट बनाया जा रहा है या नहीं। फिर हम दबाए गए कुंजियों के अनुसार ऑब्जेक्ट को स्थानांतरित करेंगे, और फिर एनीमेशन खेलेंगे। खिलाड़ी चार दिशाओं में आगे बढ़ेगा। डिफ़ॉल्ट रूप से, गोडोट इंजन में तीर कुंजी ( Project -> Project Settings -> Input Map ) को असाइन किए गए ईवेंट हैं, इसलिए हम उन्हें अपने प्रोजेक्ट पर लागू कर सकते हैं। यह पता लगाने के लिए कि क्या कोई कुंजी दबाया गया है, आपको Input.is_action_pressed() उपयोग करके इसे उस घटना के नाम से Input.is_action_pressed() चाहिए जिसे आप ट्रैक करना चाहते हैं।

 func get_input(): velocity = Vector2() if Input.is_action_pressed("ui_left"): velocity.x -= 1 if Input.is_action_pressed("ui_right"): velocity.x += 1 if Input.is_action_pressed("ui_up"): velocity.y -= 1 if Input.is_action_pressed("ui_down"): velocity.y += 1 if velocity.length() > 0: velocity = velocity.normalized() * speed

पहली नज़र में, सब कुछ अच्छा लग रहा है, लेकिन एक छोटी सी बारीकियों है। दबाए गए कई कुंजी के संयोजन (उदाहरण के लिए, नीचे और बाएं) वैक्टर को जोड़ने का कारण बनेंगे और इस मामले में खिलाड़ी तेजी से आगे बढ़ेगा यदि वह बस नीचे चला गया। इससे बचने के लिए, हम normalized() विधि का उपयोग करेंगे - यह वेक्टर की लंबाई 1 को वापस कर देगा।

तो, कीस्ट्रोके घटनाओं को ट्रैक किया गया था, अब आपको Player ऑब्जेक्ट को स्थानांतरित करने की आवश्यकता है। _process() फ़ंक्शन हमें इसमें मदद करेगा, जिसे हर बार फ़्रेम परिवर्तन होने पर कहा जाता है, इसलिए इसे उन वस्तुओं के लिए उपयोग करना उचित है जो अक्सर बदलेंगे।

 func _process(delta): get_input() position += velocity * delta position.x = clamp(position.x, 0, window_size.x) position.y = clamp(position.y, 0, window_size.y)

मुझे उम्मीद है कि आप delta पैरामीटर को नोटिस करेंगे, जो बदले में गति से गुणा किया जाता है। यह समझाना आवश्यक है कि यह क्या है। खेल इंजन शुरू में 60 फ्रेम प्रति सेकंड की गति से संचालित करने के लिए कॉन्फ़िगर किया गया है। फिर भी, ऐसी परिस्थितियाँ हो सकती हैं जब कंप्यूटर या गोडोट इंजन स्वयं धीमा हो जाता है। यदि फ्रेम दर सुसंगत नहीं है (फ्रेम बदलने के लिए लिया गया समय), तो यह गेम ऑब्जेक्ट्स के आंदोलन की "चिकनाई" को प्रभावित करेगा (परिणामस्वरूप, आंदोलन "झटकेदार" है)। "गोडोट इंजन" delta चर पेश करके इस समस्या (जैसे अधिकांश समान इंजन) को हल करता है - यह उस मूल्य को देता है जिसके लिए फ्रेम बदल दिए गए थे। इन मूल्यों के लिए धन्यवाद, आप आंदोलन को "संरेखित" कर सकते हैं। एक और उल्लेखनीय कार्य पर ध्यान दें - clamp (दो निर्दिष्ट मापदंडों के भीतर मान लौटाता है), इसके लिए धन्यवाद हम उस क्षेत्र को सीमित करने में सक्षम हैं जो Player केवल क्षेत्र के न्यूनतम और अधिकतम मूल्य निर्धारित करके स्थानांतरित कर सकता है।

हमारी वस्तु को चेतन करना मत भूलना। कृपया ध्यान दें कि जब ऑब्जेक्ट दाईं ओर बढ़ता है, तो आपको AnimatedSprite ( flip_h का उपयोग flip_h ) को फ्लिप करना होगा और हमारा हीरो उस दिशा में दिखेगा जहां वह सीधे चलते हुए जा रहा है। सुनिश्चित करें कि AnimatedSprite में Playing पैरामीटर सक्षम है ताकि एनीमेशन खेलना शुरू हो जाए।

 if velocity.length() > 0: $AnimatedSprite.animation = "walk" $AnimatedSprite.flip_h = velocity.x < 0 else: $AnimatedSprite.animation = "idle"

जन्म और मृत्यु

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

 func start(pos): set_process(true) #     Vector2(x, y) position = pos $AnimatedSprite.animation = "idle"

जब समय समाप्त होता है या खिलाड़ी एक बाधा में चलता है, तो हम एक खिलाड़ी की मृत्यु की घटना भी प्रदान करते हैं, और set_process (false) सेट करने से _process () फ़ंक्शन को इस दृश्य के लिए निष्पादित नहीं किया जाएगा।

 func die(): $AnimatedSprite.animation = "die" set_process(false)

टकराव जोड़ना

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

 signal pickup signal die

Inspector विंडो ( Node टैब) में संकेतों की सूची ब्राउज़ करें, और हमारे संकेतों, और पहले से मौजूद संकेतों पर ध्यान दें। अब हम area_entered () में रुचि रखते हैं, यह मानता है कि जिन वस्तुओं के साथ टकराव होगा, वे भी प्रकार Area2D । हम कनेक्ट बटन का उपयोग करके area_entered () सिग्नल Connect करते हैं, और Connect Signal विंडो में, हाइलाइट किए गए नोड (प्लेयर) का चयन करें, बाकी को डिफ़ॉल्ट रूप से छोड़ दें।

 func _on_Player_area_entered( area ): if area.is_in_group("coins"): #  emit_signal("pickup") area.pickup()

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

सिक्का दृश्य

एक सिक्के के साथ एक दृश्य बनाते समय, आपको "प्लेयर" दृश्य के साथ जो कुछ भी करना था, वह सब करने की आवश्यकता है, सिवाय इसके कि AnimatedSprite में केवल एक एनीमेशन (हाइलाइट) होगा। Speed (FPS) को 14 बढ़ाया जा सकता है। हम AnimatedSprite - 0,5, 0,5 के पैमाने को भी बदल देंगे। और CollisionShape2D के आयामों को सिक्के की छवि के अनुरूप होना चाहिए, मुख्य बात यह पैमाने पर नहीं है, अर्थात् 2 डी संपादक में फॉर्म पर उपयुक्त मार्करों का उपयोग करके आकार को बदल दें, जो
वृत्त की त्रिज्या को समायोजित करता है।

समूह नोड्स की लेबलिंग का एक प्रकार है जो आपको समान नोड्स की पहचान करने की अनुमति देता है। Player ऑब्जेक्ट को सिक्कों के साथ स्पर्श करने के लिए प्रतिक्रिया करने के लिए, सिक्कों को समूह से संबंधित होना चाहिए, चलो इसे coins कहते हैं। Area2D नोड ("सिक्का" नाम के साथ) का चयन करें और संबंधित समूह बनाते हुए Node -> Groups टैब में एक टैग असाइन करें।

Coin नोड के लिए, एक स्क्रिप्ट बनाएँ। pickup() फ़ंक्शन Player ऑब्जेक्ट की स्क्रिप्ट द्वारा बुलाया जाएगा और सिक्का को बताएगा कि जब वह काम करता है तो क्या करना है। queue_free() विधि सुरक्षित रूप से अपने सभी बच्चे नोड्स के साथ पेड़ से एक नोड को हटा देगी और मेमोरी को साफ कर देगी, लेकिन विलोपन तुरंत काम नहीं करेगा, इसे पहले वर्तमान फ्रेम के अंत में हटाए जाने वाली कतार में ले जाया जाएगा। यह एक नोड को तुरंत हटाने की तुलना में अधिक सुरक्षित है, क्योंकि खेल में अन्य "प्रतिभागियों" (नोड्स या दृश्य) को अभी भी इस नोड को मौजूद होने की आवश्यकता हो सकती है।

 func pickup (): queue_free ()

निष्कर्ष

अब हम Main दृश्य बना सकते हैं, दोनों दृश्यों को खींच सकते हैं: 2 डी एडिटर में माउस के Coin Player और Coin , और इस बात की जांच करें कि किस तरह से खिलाड़ी का मूवमेंट और सिक्का के साथ उसका संपर्क दृश्य (F5) को शुरू करके काम करता है। खैर, मैं यह कहने की जल्दी में हूं कि "लाइक सिक्के" गेम के निर्माण का पहला भाग समाप्त हो गया है, मुझे छुट्टी लेने और सभी को उनके ध्यान के लिए धन्यवाद देना चाहिए। यदि आपके पास कहने के लिए कुछ है, तो सामग्री को पूरक करें या आपने लेख में त्रुटियां देखीं, तो नीचे एक टिप्पणी लिखकर इसकी रिपोर्ट करना सुनिश्चित करें। कठिन और आलोचनात्मक होने से डरो मत। आपकी "प्रतिक्रिया" आपको बताएगी कि क्या मैं सही दिशा में आगे बढ़ रहा हूं और क्या सामग्री को और भी दिलचस्प और उपयोगी बनाने के लिए तय किया जा सकता है।

गोडोट इंजन पर खेल "सिक्कों की तरह" का निर्माण। भाग 1