Hvordan legge til tilfeldige bevegelige objekter i Godot

I spillutvikling kan elementer av tilfeldighet og uforutsigbarhet i stor grad bidra til den totale spillopplevelsen. En spesiell måte å introdusere et slikt element på er gjennom tilfeldige bevegelige objekter, som legger til et ekstra lag med interaksjon og utfordring.

Hvis du jobber med Godot, kan du oppnå denne effekten ved å bruke GDScript, Godots opprinnelige skriptspråk.

Sette opp ditt Godot-spill

Før du starter, sett opp en grunnleggende 2D-spillscene i Godot-spillmotoren. Lag en ny 2D-scene og legg til en CharacterBody2D node for spillerkarakteren. De CharacterBody2D node er hovedelementet for å representere karakterer som kan bevege seg rundt og samhandle med miljøet sitt.

Koden som brukes i denne artikkelen er tilgjengelig i denne GitHub-depot og er gratis for deg å bruke under MIT-lisensen.

Legg til to underordnede noder til spillerkarakteren: a CollisionShape2D med en rektangulær form, og en Sprite2D for spillerens grafiske representasjon.

For å legge til mobilitet til karakteren, kan du bruke følgende GDScript-kode:

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)

Definer en variabel, hastighet, for bevegelseshastigheten til spilleren din. De _fysikkprosess (delta) funksjonen kontrollerer karakterens bevegelse som svar på spillerinnspill. Normaliser karakterens hastighet og retning for å sikre konsekvent bevegelse uavhengig av retning.

Opprette statiske objekter med StaticBody2D

Deretter lager du objekter som spilleren din kan samhandle med. Følgende eksempel demonstrerer opprettelsen av et statisk objekt ved hjelp av StaticBody2D node:

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

Legge til en tilfeldig bevegelsesalgoritme for statiske objekter

Nå som de statiske objektene dine er klare, er det på tide å legge til tilfeldighet i spillet ditt. For å gjøre dette kan du bruke en enkel tilfeldig bevegelsesalgoritme:

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

Definer hastigheten til ditt statiske objekt. Lag også en Vector2-retning og initialiser den med tilfeldige verdier mellom -1 og 1 for begge aksene.

I _fysikkprosess (delta) funksjon, øker objektets posisjon med produktet av dets retning, hastighet og tidsdelta, noe som får det til å bevege seg i retningen med den gitte hastigheten.

Tilfeldige posisjoner og baner for statiske objekter

Du kan øke tilfeldigheten og uforutsigbarheten ved ikke bare å variere hastigheten og retningen til objektene, men også deres utgangsposisjoner og baner.

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

Her er hastigheten en tilfeldig verdi mellom 50 og 150. Objektets utgangsposisjon bestemmes tilfeldig innenfor visningsportens størrelse i _klar() funksjon og objektets posisjon oppdateres i _fysikkprosess (delta) fungerer akkurat som før.

Justering av hastighet, retning og tilfeldighet

Du kan designe mer interaktivt og engasjerende spill ved å manipulere hastigheten, retningen og tilfeldigheten i bevegelse for statiske objekter. Du kan opprette disse kontrollene ved hjelp av 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()

Tilleggsfunksjoner for dine tilfeldige bevegelige objekter

Mens den grunnleggende tilfeldige bevegelsen legger til en uforutsigbar dynamikk til spillet ditt, er det utallige tilleggsfunksjoner du kan legge til for å forbedre spillet ditt ytterligere. Noen eksempler inkluderer:

Fargevariasjon

I likhet med hvordan du randomiserte hastigheten og retningen til objektene, kan du også randomisere fargene deres. Dette kan legge til et mer levende og visuelt tiltalende aspekt til spillet ditt. Du kan gjøre dette ved å endre modulere egenskapen til spriten.

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

Størrelsesvariasjon

Tilfeldig endring av størrelsen på objektene gir enda et vanskelighetsnivå og uforutsigbarhet. Spillere må hele tiden tilpasse seg skiftende størrelser på objekter. Du kan endre størrelsen på et objekt ved å justere dets skala eiendom:

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

Objektgyting

I stedet for å ha et fast antall tilfeldige bevegelige objekter, kan du implementere et system som skaper nye objekter med jevne mellomrom eller under visse forhold. Dette kan legge til et nytt vanskelighetslag ettersom spilleren må justere strategien sin etter hvert som flere objekter vises på skjermen.

Objektets levetid

I tillegg til å skape nye objekter, kan du også få objekter til å ødelegge seg selv automatisk etter en viss tidsperiode. Dette kan forhindre at skjermen blir for rotete og holde spillingen frisk.

Interaksjoner

Tenk på å legge til spesifikke interaksjoner mellom spilleren og de bevegelige objektene. For eksempel kan kollisjon med visse objekter øke spillerens poengsum, endre spillerens hastighet eller til og med endre spillmiljøet. Du kan også la spilleren hoppe når du står på en plattform.

Beste praksis for å legge til tilfeldige bevegelige objekter

Når du legger til tilfeldige objekter i bevegelse, er det viktig å vurdere noen beste fremgangsmåter for å sikre et velbalansert, engasjerende spill:

Ytelseshensyn

Selv om det er fristende å legge til så mange objekter som mulig, husk at hvert objekt øker beregningsbelastningen på spillmotoren. Test alltid spillet ditt på målmaskinvare for å sikre at ytelsen ikke påvirkes negativt.

Balansering av tilfeldighet og spillbarhet

Mens tilfeldige objekter kan legge til morsomme uforutsigbarhet, kan for mye tilfeldighet føre til frustrasjon. Sørg for å teste grundig for å finne den rette balansen mellom utfordring og nytelse.

Kollisjoner og respons

Sørg for at spillet håndterer kollisjoner mellom spilleren og objektene på riktig måte. Tilfeldige objekter i bevegelse kan forårsake uventede kollisjonsscenarier, så planlegg disse og test dem grundig.

Visuell klarhet

Tilfeldige bevegelige objekter skal skille seg ut fra bakgrunnen og andre ikke-interaktive elementer. Dette hjelper spillere til å raskt forstå spillsituasjonen og planlegge handlingene deres deretter. Du kan også legge til lydeffekter til objektene dine for å få dem til å skille seg ut.

Innvirkningen av tilfeldige bevegelige objekter på ditt Godot-spill

Tilfeldige bevegelige objekter kan bidra betydelig til å gjøre Godot-spillet ditt mer engasjerende. De introduserer et element av uforutsigbarhet som holder spillerne på tå hev. Hver gang en spiller starter spillet, vil den hilse dem med en annen konfigurasjon av objekter, noe som øker gjenspillbarheten.

Siden spillere ikke kan forutsi banen til objekter i bevegelse, må de forbli fokuserte og lydhøre for å navigere i spillmiljøet