Derularea paralaxă este o tehnică des utilizată în jocurile 2D pentru a genera o senzație de adâncime și pentru a îmbunătăți aspectul vizual al fundalului. Această iluzie optică se realizează prin deplasarea diferitelor straturi ale fundalului la viteze diferite, raportat la mișcarea camerei.
Godot 4 simplifică semnificativ implementarea derulării paralaxă. Motorul său 2D avansat include suport nativ pentru straturile paralaxă, ceea ce vă permite să creați efecte vizuale impresionante cu un efort minim.
Configurarea mediului de joc Godot
Începeți prin a crea un nou proiect 2D în motorul Godot și configurați scena de joc cu un personaj controlat de jucător.
Codul prezentat în acest articol este disponibil în depozitul GitHub și poate fi utilizat gratuit sub licența MIT.
Pentru acest exemplu, utilizați un nod CharacterBody2D pentru a gestiona mișcarea jucătorului. Adăugați, de asemenea, un CollisionShape2D cu o formă dreptunghiulară și un Sprite2D pentru a reprezenta vizual personajul.
extends CharacterBody2Dvar 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)
Acest cod permite personajului să se deplaseze la stânga, dreapta, sus și jos folosind tastele săgeți sau comenzi similare.
Crearea straturilor cu ajutorul nodurilor ParallaxLayer
Pentru a obține efectul paralaxă, adăugați mai multe noduri ParallaxLayer scenei. Fiecare nod ParallaxLayer va reprezenta un strat diferit al fundalului. Pentru un efect de paralaxă realist, straturile mai îndepărtate de cameră trebuie să se miște mai lent decât cele mai apropiate.
Adăugați noduri StaticBody2D cu CollisionShape2D în fiecare ParallaxLayer pentru a crea obiecte cu care se poate interacționa în fundal. Aceste obiecte vor interacționa cu jucătorul, adăugând profunzime jocului.
Iată codul GDScript pentru crearea straturilor de paralaxă cu obiecte cu care se poate interacționa:
extends ParallaxBackgroundfunc _ready():
var layer1 = ParallaxLayer.new()
layer1.motion_scale = Vector2(0.2, 0.2)
add_child(layer1)
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)
var layer2 = ParallaxLayer.new()
layer2.motion_scale = Vector2(0.5, 0.5)
add_child(layer2)
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)
var layer3 = ParallaxLayer.new()
layer3.motion_scale = Vector2(1.0, 1.0)
add_child(layer3)
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)
Prin acest cod, fiecare strat paralaxă conține acum un nod StaticBody2D cu un CollisionShape2D, reprezentând obiecte cu care se poate interacționa în fundal.
Aceste obiecte vor interacționa cu personajul jucătorului și cu alte elemente ale jocului, adăugând profunzime și complexitate experienței de joc.
Deplasarea straturilor cu viteze diferite
După configurarea straturilor paralaxă, trebuie să actualizați pozițiile acestora în funcție de mișcarea jucătorului. Aceasta va crea efectul paralaxă, în care straturile apropiate de cameră se mișcă mai repede decât cele îndepărtate.
Adăugați următorul cod GDScript scenei Player:
extends CharacterBody2Dfunc _physics_process(delta):
...
move_and_collide(velocity * delta)
var parallax_background = get_parent()
var motion = -velocity * delta
parallax_background.set_scroll_offset(parallax_background.scroll_offset + motion)
Acest cod calculează mișcarea straturilor paralaxă în funcție de deplasarea jucătorului și actualizează corespunzător offset-ul de defilare al nodului ParallaxBackground. Observați utilizarea semnului negativ pentru a asigura deplasarea straturilor în direcția opusă mișcării jucătorului.
Derularea paralaxă aleatorie adaugă un element de surpriză și imprevizibilitate fundalului jocului. Prin generarea și poziționarea dinamică a straturilor paralaxă în timpul jocului, puteți crea o experiență mai captivantă și dinamică pentru jucători.
Pentru a implementa derularea aleatorie cu paralaxă, adăugați noi straturi paralaxă cu scale și poziții de mișcare aleatorii.
extends ParallaxBackgroundconst 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():
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)
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():
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)
Acest cod definește constante pentru a controla gradul de aleatoriu al straturilor paralaxă. Utilizați funcția lerp pentru a interpola valori între MIN_SCALE și MAX_SCALE, generând o scală de mișcare aleatorie pentru fiecare strat nou. Această funcție are următoarea semnătură:
Variant lerp ( Variant from, Variant to, float weight )
Folosirea rezultatului lui randf() ca greutate vă permite să generați straturi cu o scală aleatorie.
Funcția randf_range oferă o altă metodă de generare a valorilor aleatorii într-un interval. Aici, funcția create_random_layer o folosește pentru a genera poziții aleatorii pentru noile straturi într-un interval specificat:
var x_position = randf_range(MIN_X_POSITION, MAX_X_POSITION)
Jocul demonstrativ ar trebui să arate acum similar cu:
Adăugarea de funcționalități suplimentare
Derularea paralaxă oferă o fundație solidă pentru a îmbunătăți atractivitatea vizuală a jocului dvs., dar puteți merge și mai departe prin încorporarea unor funcții suplimentare. Iată câteva idei de avut în vedere.
Obiecte de fundal
Creați mai multe elemente interactive în straturile paralaxă, cum ar fi platforme plutitoare, obstacole în mișcare sau personaje animate de fundal. Aceste obiecte pot adăuga profunzime și interactivitate jocului.
Iluminare dinamică
Integrați efecte de iluminare dinamică în straturile paralaxă. Prin adăugarea surselor de lumină și umbre, puteți genera o senzație de realism și adâncime în lumea jocului. Sistemul de iluminare Godot este eficient pentru jocurile 2D și poate îmbunătăți semnificativ calitatea vizuală.
Efecte de particule
Integrați sisteme de particule în straturile paralaxă pentru a adăuga efecte vizuale subtile. Frunzele care cad, norii în mișcare sau stelele strălucitoare pot îmbunătăți atmosfera și pot face lumea jocului să pară mai vie. De asemenea, puteți adăuga efecte sonore gratuite în joc.
Ciclu zi-noapte
Implementați un ciclu zi-noapte care modifică culoarea și intensitatea straturilor paralaxă în funcție de momentul zilei din joc. Această funcționalitate dinamică poate oferi jucătorilor o experiență în continuă schimbare pe măsură ce avansează în joc.
Deși derularea paralaxă poate îmbunătăți imaginea jocului, este esențial să urmați câteva dintre cele mai bune practici pentru a asigura o experiență fluidă și plăcută.
Optimizarea performanței
Fiți atenți la numărul de straturi paralaxă și la complexitatea lor. Prea multe straturi sau materiale de înaltă rezoluție pot cauza probleme de performanță, în special pe dispozitivele mai puțin puternice. Optimizați grafica și utilizați forme de coliziune simplificate acolo unde este posibil.
Aranjarea straturilor
Aranjați straturile paralaxă cu grijă. Luați în considerare ierarhia vizuală și efectul de adâncime dorit. Straturile apropiate de cameră trebuie să se miște mai repede, în timp ce cele îndepărtate ar trebui să se miște mai încet.
Limite ale camerei
Stabiliți limite pentru mișcarea camerei pentru a evita spațiul gol nedorit sau erorile vizuale când jucătorul ajunge la marginile lumii de joc. Acest lucru asigură o experiență perfectă pentru jucători.
Testarea și ajustarea
Testați derularea paralaxă pe diferite dispozitive și dimensiuni de ecran pentru a vă asigura că arată și funcționează corect pe diferite platforme. Modificarea scalelor de mișcare, a pozițiilor straturilor și a altor parametri poate optimiza efectul paralaxă pentru cele mai bune rezultate.
Adăugarea derulării aleatorii cu paralaxă poate îmbunătăți semnificativ gradul de implicare în jocul Godot. Derularea aleatorie cu paralaxă presupune generarea și poziționarea dinamică a straturilor paralaxă în timpul jocului.
Procedând astfel, creați o senzație de mișcare și dinamism în fundal, făcând lumea jocului să pară vie și imprevizibilă. Jucătorii vor experimenta un mediu vizual în continuă schimbare, adăugând un nivel suplimentar de entuziasm experienței de joc.