गोडोट में लंबन स्क्रॉलिंग कैसे लागू करें

लंबन स्क्रॉलिंग एक ऐसी तकनीक है जिसका उपयोग कई 2डी गेम गहराई का भ्रम पैदा करने और गेम की पृष्ठभूमि में दृश्य रुचि जोड़ने के लिए करते हैं। यह कैमरे की गति के सापेक्ष पृष्ठभूमि की विभिन्न परतों को अलग-अलग गति से घुमाकर प्रभाव प्राप्त करता है।

गोडोट 4 लंबन स्क्रॉलिंग को लागू करना पहले से कहीं अधिक आसान बनाता है। इसका शक्तिशाली 2डी इंजन लंबन परतों के लिए अंतर्निहित समर्थन प्रदान करता है, जिससे आप न्यूनतम प्रयास के साथ आश्चर्यजनक दृश्य प्रभाव बना सकते हैं।

गोडोट गेम की स्थापना

आरंभ करने के लिए, एक नया 2D प्रोजेक्ट बनाएं गोडोट गेम इंजन और खिलाड़ी के चरित्र के साथ खेल का दृश्य सेट करें।

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

इस उदाहरण के लिए, एक जोड़ें कैरेक्टरबॉडी2डी खिलाड़ी की गति के लिए नोड. ए भी जोड़ें CollisionShape2D एक आयताकार आकार के साथ और एक स्प्राइट2डी खिलाड़ी के चरित्र का प्रतिनिधित्व करने के लिए।

extends CharacterBody2D

instagram viewer

var speed = 200
func _physics_process(delta):
 var velocity = Vector2()
if Input.is_action_pressed('ui_right'):
 velocity.x += 1
if Input.is_action_pressed('ui_left'):
 velocity.x -= 1
if Input.is_action_pressed('ui_down'):
 velocity.y += 1
if Input.is_action_pressed('ui_up'):
 velocity.y -= 1
 velocity = velocity.normalized() * speed
 move_and_collide(velocity * delta)

इस कोड के साथ, खिलाड़ी का चरित्र तीर कुंजियों या समान इनपुट का उपयोग करके बाएँ, दाएँ, ऊपर और नीचे जा सकता है।

ParallaxLayer नोड्स के साथ विभिन्न परतें बनाना

इसके बाद, एकाधिक जोड़कर लंबन प्रभाव बनाएं लंबन परत दृश्य के लिए नोड्स. प्रत्येक लंबन परत पृष्ठभूमि की एक अलग परत का प्रतिनिधित्व करेगा। एक ठोस लंबन प्रभाव प्राप्त करने के लिए, कैमरे से दूर की परतों को नज़दीकी परतों की तुलना में धीमी गति से चलना चाहिए।

जोड़ना स्टेटिकबॉडी2डी नोड्स के साथ CollisionShape2D प्रत्येक में लंबन परत पृष्ठभूमि में कुछ टकराने योग्य वस्तुएँ बनाने के लिए। ये टकराने योग्य वस्तुएं खिलाड़ी और अन्य गेम तत्वों के साथ बातचीत करेंगी, जिससे गेमप्ले में और अधिक गहराई आएगी।

टकराने योग्य वस्तुओं के साथ लंबन परतें बनाने के लिए जीडीस्क्रिप्ट कोड यहां दिया गया है:

extends ParallaxBackground
func _ready():
# Create the first parallax layer
 var layer1 = ParallaxLayer.new()
 layer1.motion_scale = Vector2(0.2, 0.2)
 add_child(layer1)
# Add a StaticBody2D with CollisionShape2D to the first layer
 var static_body1 = StaticBody2D.new()
 layer1.add_child(static_body1)
 var collision_shape1 = CollisionShape2D.new()
 var shape1 = RectangleShape2D.new()
 shape1.extents = Vector2(32, 32) 
 collision_shape1.shape = shape1
 static_body1.add_child(collision_shape1)
# Create the second parallax layer
 var layer2 = ParallaxLayer.new()
 layer2.motion_scale = Vector2(0.5, 0.5)
 add_child(layer2)
# Add a StaticBody2D with CollisionShape2D to the second layer
 var static_body2 = StaticBody2D.new()
 layer2.add_child(static_body2)
 var collision_shape2 = CollisionShape2D.new()
 var shape2 = RectangleShape2D.new()
 shape2.extents = Vector2(64, 64) 
 collision_shape2.shape = shape2
 static_body2.add_child(collision_shape2)
# Create the third parallax layer
 var layer3 = ParallaxLayer.new()
 layer3.motion_scale = Vector2(1.0, 1.0)
 add_child(layer3)
# Add a StaticBody2D with CollisionShape2D to the third layer
 var static_body3 = StaticBody2D.new()
 layer3.add_child(static_body3)
 var collision_shape3 = CollisionShape2D.new()
 var shape3 = RectangleShape2D.new()
 shape3.extents = Vector2(128, 128) 
 collision_shape3.shape = shape3
 static_body3.add_child(collision_shape3)

इस कोड के साथ, प्रत्येक लंबन परत में अब एक शामिल है स्टेटिकबॉडी2डी ए के साथ नोड CollisionShape2D पृष्ठभूमि में टकराने योग्य वस्तुओं का प्रतिनिधित्व करना।

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

अलग-अलग परतों को अलग-अलग गति से ले जाना

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

प्लेयर दृश्य में निम्नलिखित GDScript कोड जोड़ें:

extends CharacterBody2D
func _physics_process(delta):
 ...
 move_and_collide(velocity * delta)
# Update parallax layers based on player movement
 var parallax_background = get_parent()
 var motion = -velocity * delta
 parallax_background.set_scroll_offset(parallax_background.scroll_offset + motion)

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

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

यादृच्छिक लंबन स्क्रॉलिंग को लागू करने के लिए, यादृच्छिक गति स्केल और स्थिति के साथ नई लंबन परतें जोड़ें।

extends ParallaxBackground
const MAX_LAYERS = 5
const MIN_SCALE = 0.2
const MAX_SCALE = 1.5
const MIN_SPEED = 0.01
const MAX_SPEED = 0.03
const MIN_X_POSITION = -500
const MAX_X_POSITION = 500
const MIN_Y_POSITION = -300
const MAX_Y_POSITION = 300
func _ready():
for i in range(MAX_LAYERS):
 create_random_layer()
func create_random_layer():
# Add a new parallax layer with a random motion scale
 var layer = ParallaxLayer.new()
 var scale = lerp(MIN_SCALE, MAX_SCALE, randf())
 layer.motion_scale = Vector2(scale, scale)
 var x_position = randf_range(MIN_X_POSITION, MAX_X_POSITION)
 var y_position = randf_range(MIN_Y_POSITION, MAX_Y_POSITION)
 layer.global_transform.origin.x = x_position
 layer.global_transform.origin.y = y_position
 add_child(layer)
# Add a StaticBody2D with CollisionShape2D to the new layer
 var static_body = StaticBody2D.new()
 layer.add_child(static_body)
 var collision_shape = CollisionShape2D.new()
 var shape = RectangleShape2D.new()
 shape.extents = Vector2(32, 32) 
 collision_shape.shape = shape
 static_body.add_child(collision_shape)
func remove_random_layer():
# Remove a random parallax layer
if get_child_count() > 0:
 var random_index = randi() % get_child_count()
 var layer_to_remove = get_child(random_index)
 remove_child(layer_to_remove)

यह कोड लंबन परतों की यादृच्छिकता को नियंत्रित करने के लिए स्थिरांक को परिभाषित करता है। उपयोग लेर्प के बीच मूल्यों को प्रक्षेपित करने का कार्य करता है न्यूनतम पैमाने और MAX_SCALE, प्रत्येक नई परत के लिए एक यादृच्छिक गति पैमाना तैयार करना। इस फ़ंक्शन में निम्नलिखित हस्ताक्षर हैं:

Variant lerp ( Variant from, Variant to, float weight )

से परिणाम पारित करना रैंडफ़() चूँकि वजन आपको यादृच्छिक पैमाने के साथ परतें उत्पन्न करने देता है।

randf_range फ़ंक्शन किसी सीमा के भीतर यादृच्छिक मान उत्पन्न करने का एक और तरीका प्रदान करता है। यहां, create_random_layer फ़ंक्शन एक निर्दिष्ट सीमा के भीतर नई परतों के लिए यादृच्छिक स्थिति उत्पन्न करने के लिए इसका उपयोग करता है:

var x_position = randf_range(MIN_X_POSITION, MAX_X_POSITION)

आपका डेमो गेम अब कुछ इस तरह दिखना चाहिए:

अतिरिक्त सुविधाओं सहित

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

पृष्ठभूमि वस्तुएँ

अपनी लंबन परतों में अधिक इंटरैक्टिव तत्व बनाएं, जैसे फ़्लोटिंग प्लेटफ़ॉर्म, चलती बाधाएँ, या एनिमेटेड पृष्ठभूमि वर्ण। ये ऑब्जेक्ट आपके प्लेटफ़ॉर्मर गेम में गहराई और अन्तरक्रियाशीलता जोड़ सकते हैं।

गतिबोधक प्रकाश

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

कण प्रभाव

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

दिन-रात का चक्र

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

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

प्रदर्शन अनुकूलन

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

परत व्यवस्था

अपनी लंबन परतों को सोच-समझकर व्यवस्थित करें। दृश्य पदानुक्रम और वांछित गहराई प्रभाव पर विचार करें। कैमरे के निकटतम परतों को तेजी से आगे बढ़ना चाहिए, जबकि दूर की परतों को धीमी गति से चलना चाहिए।

कैमरा सीमाएँ

जब खिलाड़ी खेल की दुनिया के किनारों पर पहुँचता है तो अवांछित खाली जगह या दृश्य गड़बड़ियों को रोकने के लिए कैमरे की गति के लिए सीमाएँ निर्धारित करें। यह खिलाड़ियों के लिए एक सहज अनुभव सुनिश्चित करता है।

परीक्षण और बदलाव

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

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

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