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

मुझे आशा है कि आप लेख के दूसरे भाग की प्रतीक्षा करते हुए थक गए होंगे, जो कि गोडोट इंजन के उपयोग से खेल के विकास के पहलुओं से संबंधित है, जैसे सिक्कों के खेल का उदाहरण? सब कुछ "स्वादिष्ट" और "स्वस्थ" एजेंडे पर तैयार किया गया है। तुरंत एक आरक्षण करें कि इस लेख में हम पहले से शुरू किए गए गेम को पूरा करेंगे, जिसकी शुरुआत आप यहाँ पढ़ सकते हैं - गेमोट इंजन पर "लाइक सिक्के" गेम बनाना। भाग 1 , लेकिन लेखों की श्रृंखला जारी रहेगी, क्योंकि इतनी सारी सामग्री थी, जिसने मुझे इसके अलग हिस्से को स्थापित कर दिया, लेकिन हम निश्चित रूप से बाद में वापस आएंगे। चलो "gamedev" शुरू करो!

दृश्य "मुख्य"

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

ColorRect ("पृष्ठभूमि") - पृष्ठभूमि का रंग भरें;
Player - "प्लेयर" ऑब्जेक्ट (मुझे आशा है कि आप भ्रमित नहीं हैं क्योंकि मैं Player सीन को ऑब्जेक्ट कहता हूं;);
Node ("कंटेनर") - सिक्कों के अस्थायी भंडारण के लिए "कंटेनर";
Position2D ("प्लेयरस्टार्ट") - खेल की शुरुआत में "प्लेयर" ऑब्जेक्ट की प्रारंभिक स्थिति सेट करता है;
Timer ("GameTimer") - समय सीमा काउंटर;

ColorRect चयन करें और टूलबार पर चयन करें: Layout -> Full Rect इसे स्क्रीन के पूरे क्षेत्र में फैलाने के लिए Layout -> Full Rect खंड (भविष्य में हम अक्सर इस फ़ंक्शन का सहारा लेंगे, इसलिए मैं आपको सलाह देता हूं कि आप इस Layout लिए Layout सूची में निर्दिष्ट अन्य कार्यों का अध्ययन Layout ), इस नोड के लिए। संपत्ति में "रंग" वांछित रंग भरें। आप TextureRect साथ भी ऐसा कर सकते हैं, केवल भरने के बजाय आपको "बनावट" संपत्ति के माध्यम से छवि को लोड करने की आवश्यकता होगी। Position2D , "स्थिति" संपत्ति में, "x" और "y" के मान निर्दिष्ट करें - यह Player लिए प्रारंभिक स्थिति के रूप में काम करेगा। बेशक, स्क्रिप्ट की मदद से, आप सीधे Player ही पोजिशनिंग मान सेट कर सकते हैं, लेकिन हम न केवल गेम विकसित करना सीखते हैं, बल्कि "गोडोट" का भी अध्ययन करते हैं, इसलिए एक समस्या को हल करने के लिए विभिन्न विकल्पों पर विचार करना अतिरेक नहीं होगा।

"मुख्य" के लिए स्क्रिप्ट

Node लिए एक स्क्रिप्ट जोड़ें और निम्नलिखित प्रिंट करें:

 extends Node #PackedScene        export (PackedScene) var Coin export (int) var playtime var level #  var score # var left_time #     var window_size #   var playing = false #    

गुण "सिक्का" और "प्लेटाइम" Inspector में प्रदर्शित किए जाएंगे। "Coin.tscn" दृश्य को "Coin" संपत्ति में खींचें और "playtime" को "40" (सेकंड में गेम की अवधि) सेट करें।

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

 func _ready(): randomize() #        window_size = get_viewport().get_visible_rect().size #    $Player.window_size = window_size #    "" $Player.hide() #   

ध्यान दें कि Player ऑब्जेक्ट के नाम को निर्दिष्ट करते समय, "$" प्रतीक का उपयोग किया जाता है - यह "सिंटैक्टिक शुगर" है जो आपको वर्तमान दृश्य में नोड को सीधे एक्सेस करने की अनुमति देता है, get_node("Node1") विधि का एक अच्छा विकल्प (हालांकि उत्तरार्द्ध का उपयोग निषिद्ध नहीं है)। यदि "Node1" में "Node2" का वंशज है, तो आप इस विधि का उपयोग भी कर सकते हैं - $Node1/Node2 । ध्यान दें कि गोडोट में ऑटोफिल बहुत अच्छा काम करता है, इसलिए इसे उपेक्षित न करें। नोड्स के नाम में एक स्थान का उपयोग करना अवांछनीय है, लेकिन अभी भी मान्य है, इस मामले में उद्धरण चिह्नों का उपयोग करें - $"My best Node1" ।

नया खेल

एक नया गेम शुरू करने के लिए, हम इसके लिए संबंधित फ़ंक्शन को निर्धारित करेंगे, जिसे हम बाद में कॉल कर सकते हैं, उदाहरण के लिए, एक बटन दबाकर।

 func new_game(): playing = true #   level = 1 score = 0 time_left = playtime $Player.start($PlayerStart.position) $Player.show() $GameTimer.start() #    spawn_coins() #  

फ़ंक्शन "प्रारंभ ()" जिसका तर्क $PlayerStart.position है खिलाड़ी को प्रारंभिक स्थान पर ले जाएगा, और फ़ंक्शन "spawn_coins ()" जिम्मेदार है, जैसा कि आप अनुमान लगा सकते हैं, खेल के मैदान पर स्पॉन सिक्कों के लिए।

 func spawn_coins(): for i in range(4 + level): var c = Coin.instance() $CoinContainer.add_child(c) c.window_size = window_size c.position = Vector2(rand_range(0, window_size.x), rand_range(0, window_size.y)) 

range(4 + level) फ़ंक्शन किसी श्रेणी के साथ एक सरणी लौटाएगा, जिसका मूल्य सिक्कों की संख्या और वर्तमान स्तर के मूल्य के बराबर है। एक सीमा में एक तर्क हो सकता है, जैसा कि हमारे मामले में, दो तर्क या तीन तर्क (तीसरा तर्क एक सरणी चरण होगा)। इस फ़ंक्शन में, हम "सिक्का" ऑब्जेक्ट के कई उदाहरण बनाते हैं और सिक्का तत्वों को बाल तत्वों के रूप में जोड़ते हैं (मुझे आशा है कि आप भूल नहीं गए हैं कि हम पहले से ही ऑब्जेक्ट तक पहुंच चुके हैं, PackedScene के लिए धन्यवाद)। याद रखें कि हर बार जब आप एक नया नोड ( instance() विधि का एक उदाहरण बनाते हैं, तो उसे add_child() का उपयोग करके पेड़ में जोड़ा जाना चाहिए। अगला, हम सिक्कों के संभावित स्पॉन के लिए क्षेत्र निर्धारित करते हैं ताकि वे गलती से स्क्रीन के पीछे दिखाई न दें, और फिर बेतरतीब ढंग से एक स्थिति असाइन करें। अंतिम पंक्ति थोड़ा सौंदर्यवादी रूप से मनभावन नहीं लगती है, इसलिए मैं सिंगलटन का सहारा लेकर इसे सरल बनाने का सुझाव देता हूं।

एकाकी वस्तु

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

ध्यान दें, प्रोजेक्ट की अपनी वैश्विक रिपॉजिटरी है, जिसकी सामग्री हम भी उपयोग कर सकते हैं, और आप ProjectSettings.get_setting(name) का उपयोग करके इसे एक्सेस कर सकते हैं, जहां name आवश्यक पैरामीटर का name है।

अब, रिपॉजिटरी "_G" से कुछ का उपयोग करने के लिए, इसे नाम से कॉल करने के लिए पर्याप्त है, और फिर कॉल की जाने वाली विधि, या हमारे पास जो कुछ भी है उसे निर्दिष्ट करें। इसलिए, एक खाली स्क्रिप्ट बनाएं और उसमें लिखें फ़ंक्शन नीचे दिए गए फ़ंक्शन में लिखा है:

 extends Node func rand(): var rrand = Vector2(rand_range(40, 760), rand_range(40, 540)) return rrand #   

अगला, इसे सहेजें और प्रोजेक्ट सेटिंग्स पर जाएं: Project -> Project Settings -> AutoLoad । हम अपनी नई बनाई गई स्क्रिप्ट का चयन करते हैं, इसके लिए एक नाम सेट करते हैं, उदाहरण के लिए, "_G", और "spawn_coins ()" फ़ंक्शन को समय सीमा को थोड़ा समायोजित करने के लिए वापस जाएं, इसे निम्न कोड के साथ प्रतिस्थापित करें:

  ... c.position = _G.rand() 

अब यह जांचने योग्य है कि "_ready ()" ब्लॉक में "spawn_coins ()" रखकर और F5 से एप्लिकेशन को चलाकर क्या हुआ। और मुख्य दृश्य के रूप में Main.tscn का चयन करना न भूलें, यदि किसी कारण से आपने चुनने में गलती की है, तो आप मुख्य दृश्य को मैन्युअल रूप से बदल सकते हैं, इसके लिए आपको प्रोजेक्ट सेटिंग्स पर जाने की आवश्यकता है: General -> Run -> MainScene । क्या यह काम करता है? फिर आगे बढ़ते हैं।

कितने सिक्के बचे हैं?

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

 func _process(delta): #   ?     ? if playing and $CoinContainer.get_child_count() == 0: #    level += 1 # ""   time_left += 5 #  spawn_coins() 

उपयोगकर्ता इंटरफ़ेस

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

गोडोट में तथाकथित "नियंत्रण नोड" हैं जो आपको माता-पिता के निर्दिष्ट मापदंडों के संबंध में स्वचालित रूप से बाल तत्वों को प्रारूपित करने की अनुमति देते हैं। प्रत्येक प्रकार के "कंट्रोल नोड्स" में विशेष गुण होते हैं जो नियंत्रित करते हैं कि वे अपने वंशजों के स्थान को कैसे नियंत्रित करते हैं। इस प्रकार का एक ज्वलंत प्रतिनिधि MarginContainer , जिसे दृश्य में जोड़ा जाना चाहिए। Layout -> Top Wide की मदद से Layout -> Top Wide इसे विंडो के शीर्ष पर फैलाएंगे, और इस ऑब्जेक्ट के गुणों में, Margin सेक्शन में किनारों से इंडेंट निर्दिष्ट करें: लेफ्ट, टॉप और राइट। MarginContainer पास निम्नलिखित नामों के साथ तीन चाइल्ड Label होने चाहिए: ScoreLabel , LevelLabel और TimeLabel । उन्हें दृश्य में जोड़ें। Align गुण का उपयोग करके, उन्हें बाईं ओर, केंद्र और दाईं ओर संरेखित करें। यह एक और Label ( Messagelabel ) जोड़ने के लिए बना हुआ है, इसे केंद्र में रखकर, सभी Layout , और बटन को थोड़ा नीचे रखें ( StartButton )।

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

 extends CanvasLayer signal start_game func update_score(value): $MarginContainer/ScoreLabel.text = str(value) func update_level(value): if len(str(value)) == 1: $MarginContainer/TimeLabel.text = "0: 0" + str(value) else: $MarginContainer/TimeLabel.text = "0: " + str(value) func update_timer(value): $MarginContainer/TimeLabel.txt = str(value) 

MessageLabel हमें संदेश की पाठ को छोटी अवधि के लिए बदलने के लिए एक टाइमर की आवश्यकता होती है। एक Timer नोड जोड़ें और उसका नाम MessageTimer बदलें। इंस्पेक्टर में, प्रतीक्षा समय 2 सेकंड सेट करें और One Shot फ़ील्ड में चेकबॉक्स चुनें। यह सुनिश्चित करता है कि टाइमर केवल एक बार स्टार्टअप पर चलता है।

 func show_message(text): $MessageLabel.text = text $MessageLabel.show() $MessageTimer.start() 

timeout() सिग्नल को "MessageTimer" से कनेक्ट करें और निम्नलिखित जोड़ें:

 func _on_MessageTimer_timeout(): $MessageLabel.hide() 

StartButton लिए "नोड" टैब पर, pressed() सिग्नल को कनेक्ट करें। जब आप StartButton बटन पर क्लिक करते हैं, तो उसे MessageLabel साथ एक साथ गायब हो जाना चाहिए, फिर मुख्य दृश्य को एक संकेत भेजें, जहां हम बाद में इसे सफलतापूर्वक निष्पादित करने के लिए फ़ंक्शन को खिसकाकर - "new_game ()"। हम इसे नीचे दिए गए कोड का उपयोग करके लागू करते हैं। खेल शुरू करने के लिए किसी भी टेक्स्ट कॉलिंग को सेट करने के लिए Text प्रॉपर्टी के बटन को न भूलें।

 func _on_StartButton_pressed(): $StartButton.hide() $MessageLabel.hide() emit_signal("start_game") 

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

 func show_game_over(): show_message("Game Over") yield($MessageTimer, "timeout") $StartButton.show() $MessageLabel.text = "LIKE COINS!" $MessageLabel.show() 

समाप्त?

HUD और Main बीच फीडबैक सेट करते हैं। HUD दृश्य को मुख्य दृश्य में जोड़ें और timeout() माध्यम से GameTimer सिग्नल को मुख्य दृश्य पर जोड़कर निम्नलिखित जोड़ें:

 func _on_GameTimer_timeout(): time_left -= 1 #  $HUD.update_timer(time_left) #   if time_left <= 0: game_over() #     

फिर pickup() और die() खिलाड़ी के संकेतों को कनेक्ट करें।

 func _on_Player_pickup(): score += 1 $HUD.update_score(score) func _on_Player_die(): game_over() 

खेल के अंत में, कई और चीजें होनी चाहिए जिन्हें अनदेखा नहीं किया जाना चाहिए। निम्नलिखित कोड लिखें, और मैं समझाऊंगा।

 func game_over(): playing = false $GameTimer.stop() for coin in $CoinContainer.get_children(): coin.queue_free() $HUD.show_game_over() $Player.die() 

यह फ़ंक्शन गेम को रोक देगा, और फिर शेष सिक्कों को show_game_over() किया जाएगा और शेष सिक्कों को show_game_over() जाएगा, फिर show_game_over() को HUD लिए बुलाया जाएगा। अगला कदम एनीमेशन को शुरू करना है और Player नोड को निष्पादित करने की प्रक्रिया को रोकना है।

अंत में, आपको StartButton को सक्रिय करना होगा, जो new_game() फ़ंक्शन से जुड़ा होना चाहिए। HUD नोड पर क्लिक करें और कनेक्शन संवाद में आपको Make Function to Off पर क्लिक करने की आवश्यकता है (यह एक नए फ़ंक्शन के निर्माण को रोक देगा) और Method In Node क्षेत्र में कनेक्ट होने वाले फ़ंक्शन का नाम निर्दिष्ट करें - new_game । यह एक नया बनाने के बजाय मौजूदा फ़ंक्शन को सिग्नल कनेक्ट करेगा।

अंतिम स्पर्श - _ready() फ़ंक्शन से new_game() निकालें और निम्नलिखित दो पंक्तियों को new_game() फ़ंक्शन में जोड़ें

 ... $HUD.update_score(score) $HUD.update_timer(time_left) 

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