🦄 🤷 🛢️ गोडोट में 2 डी चरित्र बनाने की मूल बातें। भाग 2: संकलन टेम्पलेट्स, थोड़ा GDScript, आंदोलन और नायक के एनीमेशन के बारे में 🤸🏼 👩🏽‍🤝‍👨🏻 🌅

पिछले लेख में, हमने गोडोट में एक नई परियोजना बनाने की मूल बातें कवर कीं । और इस सतही ज्ञान के साथ, आप केवल खेलों के डेमो संस्करणों को देख सकते हैं।

एजेंडे के दूसरे भाग में, हमारे पास है:
1) चयनित वास्तुकला के लिए बाइनरी फ़ाइलों के लिए तैयार परियोजना का निर्यात।
2) नए एनिमेशन। चरित्र के विकल्प।
3) प्रबंधन।
3) जीडीएसस्क्रिप्ट। वास्तविक कोडिंग में आपका स्वागत है!
4) साधारण टाइलें आयात करें।
5) बोनस: सरलतम पृष्ठभूमि की डिवाइस का विश्लेषण।

खैर, हमेशा की तरह, बहुत सारी तस्वीरें!

संकलन ....?

पिछले लेख में, मैंने उल्लेख किया कि लेखकों ने linux x86 के लिए बायनेरिज़ प्रदान नहीं किया है। लेखन के समय, बायनेरिज़ अभी भी तैयार नहीं थे। लेकिन मैं पहले से ही तैयार परियोजनाओं, डेमो या सिर्फ परीक्षणों का निर्यात करना चाहता था। लेकिन क्या होगा यदि कोई निर्यात टेम्पलेट नहीं हैं? यह सही है! उन्हें खुद संकलित करें!

स्रोत फ़ाइलों के साथ निर्देशिका पर जाएं और संकलन करें

cd ./godot

डिबगिंग उपकरण:

 scons bin/godot target=release_debug tools=no

सफल संकलन के बाद, ताज़ा प्राप्त फ़ाइल को linux_x11_32_debug में बदलें

निर्यात टेम्पलेट स्वयं:

 scons bin/godot_rel target=release tools=no

Linux_x11_32_release का नाम बदलें

हम इसे ज़िप आर्काइव में पैक करते हैं।

 find ./* -name "linux_x11_32_*" -exec zip ./linux_x11_32_templates.zip "{}" +

हम गोडोट संग्रह को खिलाते हैं। Voila, अब आप किसी भी क्षमता के GNU / Linux OS के लिए एक परियोजना निर्यात कर सकते हैं।

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

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

चल रहा है और एनीमेशन कूद

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

 run: Len(s): 0.9 Step(s): 0.1 Looping: yes jumping: Len(s): 1 Step(s): 0.1 Animation: ○○○○○○○ ,   -    24  30,   -  . Looping: no

हां, एक छलांग सिर्फ एक छलांग है। इसलिए आपको अधिक गिरावट वाले एनीमेशन की आवश्यकता है।

 falling: Len(s): 0.1 Step(s): 0.1 Animation:  №30 Looping: yes

चरित्र विकल्प

तीन बिंदु:

कैमरा
जमीन को छूना
चरित्र ज्यामिति

1) मैं आपको याद दिलाता हूं। जांचें कि क्या कैमरा 2 डी / करंट पैरामीटर पर एक चेकमार्क है, जो कैमरा ऑब्जेक्ट को प्लेयर ऑब्जेक्ट को बाइंड करने के लिए जिम्मेदार है।

2) नोड CollisionShape2D जोड़ें। यह "नोडा" 2 डी अंतरिक्ष में हमारे कप्तान की स्थिति के लिए जिम्मेदार है।

इंस्पेक्टर में, CollisionShape2D -> Shape -> New RayShape2D का चयन करें। 2 मिलीमीटर के दाईं ओर एक छोटा तीर दिखाई देगा - उस पर क्लिक करें - RayShape2D पैरामीटर खुल जाएगा।
हम पैरामीटर RayShape2D / Lenght 20 को छोड़ देते हैं, लेकिन कस्टम सॉल्वर पूर्वाग्रह 0.5 सेट करता है (यह थोड़ा सा पूर्वाग्रह देगा)
अब भविष्य में खेल में, यदि चरित्र "फर्श पर लात नहीं मारता है", तो उसकी स्थिति को इस तीर के साथ समायोजित किया जा सकता है। यह वह है जो जांचता है कि स्प्राइट फर्श को छू रहा है या नहीं।

3) ज्यामिति के साथ और अधिक मज़ा। सबसे पहले आपको Node CollisionPolygon2D को जोड़ना होगा। अब हमें इसी बहुभुज को खींचने की जरूरत है, जो चरित्र को "द्रव्यमान" देता है। अर्थात, हमें यह आकर्षित करने की आवश्यकता है कि नायक उनके साथ टकराव में "दीवारों के खिलाफ हरा" देगा। अन्यथा, यह बस दीवारों से होकर गुजरेगा।

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

हो गया, हमारा चरित्र एक ब्लॉकहेड तैयार है। अब सबसे आसान बात प्रबंधन है।

नियंत्रण कुंजी बनाना

मानक प्रबंधन।

इसे बनाना काफी आसान है। दृश्य पर जाएँ -> परियोजना सेटिंग्स -> इनपुट मानचित्र

3 नियंत्रण कुंजी बनाएँ - Move_left, Move_right और jump। उन्हें चाबी सौंप दें। हो गया!
जैसा कि आप देख सकते हैं, गोडोट गेमपैड्स के साथ भी काम कर सकता है, हालांकि सभी के लिए यह अपने स्वयं के नियंत्रण को कॉन्फ़िगर करने के लिए आवश्यक होगा। लेकिन इसके बारे में कुछ और समय।
एक टचस्क्रीन के साथ प्रबंधन।
विशेष रूप से जटिल कुछ भी नहीं है। "उई" नाम के साथ हमारे नायक नोड कैनवासलेयर को बांधें। और उसके बदले में, टचस्क्रीनबटन की 3 प्रतियां। उन्हें बाएं, दाएं और कूदें।
हम प्रत्येक के लिए एक महत्वपूर्ण छवि देते हैं। वे तुरंत कार्यक्रम के कार्यक्षेत्र में दिखाई देंगे। हम इसकी व्यवस्था करते हैं क्योंकि यह हमें अधिक सुविधाजनक लगता है। यह मत भूलो कि नीली खिड़की "कैमरा डिस्प्ले एरिया" है।
क्रिया अनुभागों में, क्रमशः मूव_लेफ्ट, मूव_एफ़ और जंप, पैरामीटर दर्ज करें। खैर, हम टचस्क्रीन में ही विजिबिलिटी मोड पैरामीटर सेट करते हैं। हो गया!

GDScript

यहां मैं थोड़ा बेवकूफ हूं। तथ्य यह है कि मेरे लिए, एक प्रोग्रामर ईमानदारी से बहुत ईमानदार नहीं है। मैं खुद को ज्यादा नहीं समझता। और मैंने इस मुद्दे को बेहतर ढंग से समझने के लिए पायथन पर किताबें पढ़ीं। क्योंकि GDScript इससे काफी मिलता-जुलता है।

चेतावनी!

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

एक छोटा सा अनुरोध - यदि आप जानते हैं कि इसे बेहतर तरीके से कैसे व्यवस्थित किया जाए - कृपया लिखें। मुझे सभी टिप्पणियों को ध्यान में रखते हुए खुशी होगी।

मुझे सबसे सरल एनीमेशन प्रदर्शित करने के लिए पिछले कोड की याद दिलाते हैं:

क्या था

 extends RigidBody2D var anim="" func _integrate_forces(s): var new_anim=anim new_anim=«idle» if (new_anim!=anim): anim=new_anim get_node(«anim»).play(anim)

कोड जोड़ें और बदलें:

विविधताएँ घोषित करें

 extends RigidBody2D var anim="" #  var siding_left=false #   var jumping=false #  var stopping_jump=false #   var WALK_ACCEL = 800.0 #    var WALK_DEACCEL= 800.0 #  var WALK_MAX_VELOCITY= 800.0 #  var GRAVITY = 900.0 # var AIR_ACCEL = 200.0 #      var AIR_DEACCEL= 200.0 #  (   )  . ,         Mario Bros' var JUMP_VELOCITY=460 #  var STOP_JUMP_FORCE=900.0 #   var MAX_FLOOR_AIRBORNE_TIME = 0.15 # ,     . - ,       .  ,    ""   . var airborne_time=1e20 #   var floor_h_velocity=0.0

हम Integrated_forces फ़ंक्शन शुरू करते हैं। यहाँ मदद में कुछ शब्द क्या कहते हैं:
अपने भौतिकी इंटरैक्शन का उपयोग करने के लिए फ़ंक्शन को संशोधित करें। ठीक है, हम क्या करते हैं।
PS मुझे नहीं पता कि आगे कोड पर टिप्पणी कैसे करें। तो बस इसे इस तरह से छोड़ दें:

हम इंटरैक्शन फ़ंक्शन लिखते हैं

 func _integrate_forces(s): var lv = s.get_linear_velocity() var step = s.get_step() var new_anim=anim var new_siding_left=siding_left

हमें नियंत्रण मिलता है

  var move_left = Input.is_action_pressed("move_left") var move_right = Input.is_action_pressed("move_right") var jump = Input.is_action_pressed("jump") #   x () lv.x-=floor_h_velocity floor_h_velocity=0.0

पृथ्वी खोज (फर्श के साथ बनावट संपर्क की जाँच करें)

  var found_floor=false var floor_index=-1 for x in range(s.get_contact_count()): var ci = s.get_contact_local_normal(x) if (ci.dot(Vector2(0,-1))>0.6): found_floor=true floor_index=x if (found_floor): airborne_time=0.0 else: airborne_time+=step #,    var on_floor = airborne_time < MAX_FLOOR_AIRBORNE_TIME

कूदने की प्रक्रिया

  if (jumping): if (lv.y>0): #     (   ) jumping=false elif (not jump): stopping_jump=true if (stopping_jump): lv.y+=STOP_JUMP_FORCE*step

पृथ्वी पर चरित्र आंदोलन

  if (on_floor): if (move_left and not move_right): if (lv.x > -WALK_MAX_VELOCITY): lv.x-=WALK_ACCEL*step elif (move_right and not move_left): if (lv.x < WALK_MAX_VELOCITY): lv.x+=WALK_ACCEL*step else: var xv = abs(lv.x) xv-=WALK_DEACCEL*step if (xv<0): xv=0 lv.x=sign(lv.x)*xv #  if (not jumping and jump): lv.y=-JUMP_VELOCITY jumping=true stopping_jump=false #     if (lv.x < 0 and move_left): new_siding_left=true elif (lv.x > 0 and move_right): new_siding_left=false if (jumping): new_anim="jumping" elif (abs(lv.x)<0.1): new_anim="idle" else: new_anim="run"

हवा में चरित्र आंदोलन

  else: if (move_left and not move_right): if (lv.x > -WALK_MAX_VELOCITY): lv.x-=AIR_ACCEL*step elif (move_right and not move_left): if (lv.x < WALK_MAX_VELOCITY): lv.x+=AIR_ACCEL*step else: var xv = abs(lv.x) xv-=AIR_DEACCEL*step if (xv<0): xv=0 lv.x=sign(lv.x)*xv if (lv.y<0): new_anim="jumping" else: new_anim="falling"

चरित्र आंदोलन

  if (new_siding_left!=siding_left): if (new_siding_left): get_node("sprite").set_scale( Vector2(-1,1) ) else: get_node("sprite").set_scale( Vector2(1,1) ) siding_left=new_siding_left

एनीमेशन बदलें

  if (new_anim!=anim): anim=new_anim get_node("anim").play(anim)

जमीन की गति लागू करें

  if (found_floor): floor_h_velocity=s.get_contact_collider_velocity_at_pos(floor_index).x lv.x+=floor_h_velocity

इस सब गड़बड़ को गंभीरता से लागू करना

  lv+=s.get_total_gravity()*step s.set_linear_velocity(lv)

अरे, यह डरावनी थी।

अब सभी बिना टिप्पणी के एक साथ:

 extends RigidBody2D var anim="" var siding_left=false var jumping=false var stopping_jump=false var WALK_ACCEL = 300.0 var WALK_DEACCEL= 300.0 var WALK_MAX_VELOCITY= 400.0 var GRAVITY = 900.0 var AIR_ACCEL = 300.0 var AIR_DEACCEL= 300.0 var JUMP_VELOCITY=460 var STOP_JUMP_FORCE=200.0 var MAX_FLOOR_AIRBORNE_TIME = 0.15 var airborne_time=1e20 var floor_h_velocity=0.0 func _integrate_forces(s): var lv = s.get_linear_velocity() var step = s.get_step() var new_anim=anim var new_siding_left=siding_left var move_left = Input.is_action_pressed("move_left") var move_right = Input.is_action_pressed("move_right") var jump = Input.is_action_pressed("jump") lv.x-=floor_h_velocity floor_h_velocity=0.0 var found_floor=false var floor_index=-1 for x in range(s.get_contact_count()): var ci = s.get_contact_local_normal(x) if (ci.dot(Vector2(0,-1))>0.6): found_floor=true floor_index=x if (found_floor): airborne_time=0.0 else: airborne_time+=step var on_floor = airborne_time < MAX_FLOOR_AIRBORNE_TIME if (jumping): if (lv.y>0): jumping=false elif (not jump): stopping_jump=true if (stopping_jump): lv.y+=STOP_JUMP_FORCE*step if (on_floor): if (move_left and not move_right): if (lv.x > -WALK_MAX_VELOCITY): lv.x-=WALK_ACCEL*step elif (move_right and not move_left): if (lv.x < WALK_MAX_VELOCITY): lv.x+=WALK_ACCEL*step else: var xv = abs(lv.x) xv-=WALK_DEACCEL*step if (xv<0): xv=0 lv.x=sign(lv.x)*xv if (not jumping and jump): lv.y=-JUMP_VELOCITY jumping=true stopping_jump=false if (lv.x < 0 and move_left): new_siding_left=true elif (lv.x > 0 and move_right): new_siding_left=false if (jumping): new_anim="jumping" elif (abs(lv.x)<0.1): new_anim="idle" else: new_anim="run" else: if (move_left and not move_right): if (lv.x > -WALK_MAX_VELOCITY): lv.x-=AIR_ACCEL*step elif (move_right and not move_left): if (lv.x < WALK_MAX_VELOCITY): lv.x+=AIR_ACCEL*step else: var xv = abs(lv.x) xv-=AIR_DEACCEL*step if (xv<0): xv=0 lv.x=sign(lv.x)*xv if (lv.y<0): new_anim="jumping" else: new_anim="falling" if (new_siding_left!=siding_left): if (new_siding_left): get_node("sprite").set_scale( Vector2(-1,1) ) else: get_node("sprite").set_scale( Vector2(1,1) ) siding_left=new_siding_left if (new_anim!=anim): anim=new_anim get_node("anim").play(anim) if (found_floor): floor_h_velocity=s.get_contact_collider_velocity_at_pos(floor_index).x lv.x+=floor_h_velocity lv+=s.get_total_gravity()*step s.set_linear_velocity(lv)

काम करने के लिए गुरुत्वाकर्षण के लिए PS, आपको बॉक्स को देखना होगा -> प्रोजेक्ट सेटिंग्स -> Physics2D -> डिफ़ॉल्ट ग्रेविटी

टाइल आयात करें

मुझे टाइलसेट के बारे में विस्तार से बताने का समय नहीं है। मैं केवल अपने तैयार दृश्य (मेरी परियोजना से) की पेशकश कर सकता हूं या आप टाइलसेट से अपना खुद का बना सकते हैं। आप नीचे दिए गए लिंक से सेट डाउनलोड कर सकते हैं, और फिर इसे नोड टाइलमैप परियोजना में जोड़ सकते हैं। सेटिंग्स में, आपको इसके लिए तैयार टाइलसेट को जोड़ना होगा (टाइलसेट -> लोड -> टाइल्ससेट.एक्सएमएल)। आप सबसे सरल तल / ज़मीन खींच सकते हैं। स्तरों को कैसे आकर्षित किया जाए, मैं अगले पाठ में विस्तार से वर्णन करूंगा।

बोनस! पृष्ठभूमि जोड़ने!

एक नया दृश्य बनाएँ। इसमें "Node" ParallaxBackground जोड़ें। इसे parallax_bg कहें और इसे parallax_bg.xml के रूप में सहेजें।
हम इसके लिए ParallaxLayer के 4 टुकड़े बनाते हैं। उन्हें आकाश, बादल, माउंट_1, माउंट 2 कहें। तदनुसार, आकाश, बादल और पहाड़।
हमारे खेल का संकल्प 800x600 है (दृश्य में देखें -> परियोजना सेटिंग्स -> प्रदर्शन सेटिंग्स)। इसलिए, हम प्रत्येक "नोड" को मिररिंग पैरामीटर 800.0 सेट करते हैं - Y अक्ष के साथ मिररिंग करते हैं। "Node" बादलों के स्केल मापदंडों को बदलें। Mount_1, Mount_2 से 0.1.1; क्रमशः 0.2.1 और 0.4.1।

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

बादलों को नोड में जोड़ें। मुझे लगता है कि 3 में से प्रत्येक को डुप्लिकेट करना संभव होगा, ताकि अंत में 6 हो, दर्पण फिर से डुप्लिकेट होगा, कुल मिलाकर हमारे पास 12 बादल होंगे!

अब हम पर्वतों को Node Mount_1 और Mount_2 में जोड़ते हैं। लेकिन चलिए बढ़ते हैं।

दृश्य बचाओ। ओपन स्टेज। xml। और हमारे चरण में हम बैकड्रॉप्स के साथ "प्लस साइन" एक दृश्य के माध्यम से जोड़ते हैं।

और हमेशा की तरह गेमप्ले का एक छोटा सा वीडियो:

छोटे FAQ (अपडेट किया जाएगा):

यदि चरित्र नहीं चलता है, तो जांचें कि क्या कुंजियाँ जोड़ी गई हैं और सही तरीके से जोड़ी गई हैं
एनीमेशन के साथ समस्याएं - क्या एनीमेशन को सही ढंग से जोड़ा गया था। निष्क्रिय, चलाने और गिरने के पाश एनिमेशन देखें।
चरित्र फर्श में गिर जाता है / दीवारों, छत से गुजरता है - त्रिकोण CollisionPolygon2D को बढ़ाता है।
चरित्र को आंशिक रूप से बनावट में / उनके ऊपर - तीर CollisionShape2D के साथ काम करते हैं

डाउनलोड: