Descoperă cum să adaugi un element imprevizibil jocului tău.

În dezvoltarea jocului, elementele aleatorii și imprevizibilitatea pot contribui foarte mult la experiența generală de joc. O modalitate specială de a introduce un astfel de element este prin intermediul obiectelor în mișcare aleatorie, care adaugă un strat suplimentar de interacțiune și provocare.

Dacă lucrați cu Godot, puteți obține acest efect folosind GDScript, limbajul nativ de scripting al Godot.

Configurarea jocului Godot

Înainte de a începe, configurați o scenă de joc 2D de bază motorul de joc Godot. Creați o nouă scenă 2D și adăugați un CharacterBody2D nod pentru personajul jucător. The CharacterBody2D nodul este elementul principal pentru reprezentarea personajelor care se pot deplasa și interacționa cu mediul lor.

Codul folosit în acest articol este disponibil în acest articol Depozitul GitHub și este gratuit pentru utilizare sub licența MIT.

Adăugați două noduri copil la personajul jucătorului: a CollisionShape2D cu formă dreptunghiulară și a Sprite2D pentru reprezentarea grafică a jucătorului.

instagram viewer

Pentru a adăuga mobilitate personajului, puteți folosi următorul cod GDScript:

extends CharacterBody2D
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)

Definiți o variabilă, viteză, pentru viteza de mișcare a playerului dvs. The _proces_fizică (delta) funcția controlează mișcarea personajului ca răspuns la intrările jucătorului. Normalizați viteza și direcția personajului pentru a asigura o mișcare constantă, indiferent de direcție.

Crearea de obiecte statice cu StaticBody2D

Apoi, creați obiecte cu care jucătorul dvs. poate interacționa. Următorul exemplu demonstrează crearea unui obiect static folosind StaticBody2D nodul:

extends StaticBody2D
func _ready():
 var collision_shape = CollisionShape2D.new()
 collision_shape.shape = RectangleShape2D.new()
 add_child(collision_shape)

Adăugarea unui algoritm de mișcare aleatorie pentru obiecte statice

Acum că obiectele tale statice sunt gata, este timpul să adaugi aleatoriu jocului tău. Pentru a face acest lucru, puteți utiliza un algoritm simplu de mișcare aleatorie:

extends StaticBody2D
var speed = 100
var value = randf_range(-1, 1)
var direction = Vector2(value, value).normalized()
func _physics_process(delta):
 position += direction * speed * delta

Definiți viteza obiectului dvs. static. De asemenea, creați o direcție Vector2 și inițializați-o cu valori aleatorii între -1 și 1 pentru ambele axe.

În _proces_fizică (delta) funcția, incrementează poziția obiectului cu produsul direcției sale, vitezei și deltei timpului, făcându-l să se miște în direcția cu viteza dată.

Poziții aleatorii și traiectorii pentru obiecte statice

Puteți crește aleatorietatea și imprevizibilitatea nu numai variind viteza și direcția obiectelor, ci și pozițiile și traiectoriile inițiale ale acestora.

extends StaticBody2D
var speed = randf_range(50, 150)
var value = randf_range(-1, 1)
var direction = Vector2(value, value).normalized()


func _ready():
 var val1 = randf_range(0, get_viewport().size.x)
 var val2 = randf_range(0, get_viewport().size.y)
 position = Vector2(val1, val2)
func _physics_process(delta):
 position += direction * speed * delta

Aici viteza este o valoare aleatorie între 50 și 150. Poziția inițială a obiectului este determinată aleatoriu în dimensiunea ferestrei de vizualizare în _gata() funcția și poziția obiectului este actualizată în _proces_fizică (delta) functioneaza la fel ca inainte.

Ajustarea vitezei, direcției și aleatoriei

Puteți proiecta un joc mai interactiv și mai captivant, manipulând viteza, direcția și caracterul aleatoriu al mișcării obiectelor statice. Puteți crea aceste controale folosind GDScript:

extends StaticBody2D
var speed = randf_range(50, 150)
var value = randf_range(-1, 1)
var direction = Vector2(value, value).normalized()
var speed_variation_rate = 0.5
var direction_variation_rate = 0.5


func _ready():
 var val1 = randf_range(0, get_viewport().size.x)
 var val2 = randf_range(0, get_viewport().size.y)
 position = Vector2(val1, val2)


func _physics_process(delta):
 randomize_speed_and_direction()
 position += direction * speed * delta


func randomize_speed_and_direction():
if randf() < speed_variation_rate:
 speed = randf_range(50, 150)
if randf() < direction_variation_rate:
 direction = Vector2(value, value).normalized()

Caracteristici suplimentare pentru obiectele dvs. în mișcare aleatorie

În timp ce mișcarea aleatorie de bază adaugă o dinamică imprevizibilă jocului tău, există nenumărate caracteristici suplimentare pe care le poți adăuga pentru a-ți îmbunătăți și mai mult jocul. Câteva exemple includ:

Variația de culoare

Similar cu felul în care ați randomizat viteza și direcția obiectelor, puteți, de asemenea, să aleatorizați culorile acestora. Acest lucru poate adăuga un aspect mai vibrant și mai atrăgător din punct de vedere vizual jocului tău. Puteți face acest lucru schimbând modula proprietatea sprite-ului.

sprite.modulate = Color(randf(), randf(), randf())

Variația mărimii

Schimbarea aleatorie a dimensiunii obiectelor adaugă un alt nivel de dificultate și imprevizibilitate. Jucătorii vor trebui să se adapteze în mod constant la dimensiunile în schimbare ale obiectelor. Puteți modifica dimensiunea unui obiect ajustându-l scară proprietate:

sprite.scale = Vector2(randf_range(0.5, 2.0), randf_range(0.5, 2.0))

Apariția obiectelor

În loc să aveți un număr fix de obiecte în mișcare aleatoare, puteți implementa un sistem care generează noi obiecte la intervale regulate sau în anumite condiții. Acest lucru ar putea adăuga un nou nivel de dificultate, deoarece jucătorul va trebui să își ajusteze strategia pe măsură ce mai multe obiecte apar pe ecran.

Durata de viață a obiectului

Pe lângă generarea de noi obiecte, puteți, de asemenea, ca obiectele să se distrugă automat după o anumită perioadă de timp. Acest lucru poate împiedica ecranul să devină prea aglomerat și poate menține jocul proaspăt.

Interacțiuni

Gândiți-vă la adăugarea de interacțiuni specifice între jucător și obiectele în mișcare. De exemplu, ciocnirea cu anumite obiecte poate crește scorul jucătorului, poate schimba viteza jucătorului sau chiar poate schimba mediul de joc. Poti de asemenea permite jucătorului să sară când stați pe o platformă.

Cele mai bune practici pentru adăugarea de obiecte în mișcare aleatorie

Când adăugați obiecte în mișcare aleatoare, este important să luați în considerare câteva bune practici pentru a asigura un joc bine echilibrat și captivant:

Considerații de performanță

Deși este tentant să adăugați cât mai multe obiecte posibil, amintiți-vă că fiecare obiect crește sarcina de calcul a motorului de joc. Testați-vă întotdeauna jocul pe hardware-ul țintă pentru a vă asigura că performanța nu este afectată negativ.

Echilibrarea aleatorietății și redabilității

În timp ce obiectele aleatorii pot adăuga imprevizibilitate distractivă, prea multă aleatorie poate duce la frustrare. Asigurați-vă că testați pe larg pentru a găsi echilibrul potrivit între provocare și plăcere.

Coliziuni și răspuns

Asigurați-vă că jocul gestionează în mod corespunzător coliziunile dintre jucător și obiecte. Obiectele în mișcare aleatorie pot provoca scenarii de coliziune neașteptate, așa că planificați-le și testați-le cu atenție.

Claritate vizuală

Obiectele în mișcare aleatoare ar trebui să iasă în evidență din fundal și alte elemente neinteractive. Acest lucru îi ajută pe jucători să înțeleagă rapid situația jocului și să își planifice acțiunile în consecință. Poti de asemenea adăugați efecte sonore la obiectele tale pentru a le scoate în evidență.

Impactul obiectelor în mișcare aleatorie asupra jocului Godot

Obiectele în mișcare aleatoare pot contribui în mod semnificativ la a face jocul Godot mai captivant. Ele introduc un element de imprevizibilitate care îi ține pe jucători cu atenție. De fiecare dată când un jucător începe jocul, acesta îl va întâmpina cu o configurație diferită de obiecte, adăugând rejucabilitatea acestuia.

În plus, deoarece jucătorii nu pot prezice calea obiectelor în mișcare, ei trebuie să rămână concentrați și receptivi pentru a naviga în mediul de joc.