Opdag, hvordan du tilføjer et uforudsigeligt element til dit gameplay.

I spiludvikling kan elementer af tilfældighed og uforudsigelighed i høj grad bidrage til den overordnede spiloplevelse. En særlig måde at introducere et sådant element på er gennem tilfældige bevægelige objekter, som tilføjer et ekstra lag af interaktion og udfordring.

Hvis du arbejder med Godot, kan du opnå denne effekt ved hjælp af GDScript, Godots oprindelige scriptsprog.

Opsætning af dit Godot-spil

Inden du starter, skal du opsætte en grundlæggende 2D-spilscene i Godot spilmotoren. Opret en ny 2D-scene og tilføj en CharacterBody2D node for spillerkarakteren. Det CharacterBody2D node er hovedelementet til at repræsentere karakterer, der kan bevæge sig rundt og interagere med deres omgivelser.

Koden brugt i denne artikel er tilgængelig i denne GitHub-depot og er gratis for dig at bruge under MIT-licensen.

Tilføj to underordnede noder til spillerkarakteren: a CollisionShape2D med en rektangulær form, og en Sprite2D for spillerens grafiske repræsentation.

instagram viewer

For at tilføje mobilitet til karakteren kan du bruge 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, fart, for din spillers bevægelseshastighed. Det _fysikproces (delta) funktionen styrer karakterens bevægelse som svar på spillerens input. Normaliser karakterens hastighed og retning for at sikre ensartet bevægelse uanset retning.

Oprettelse af statiske objekter med StaticBody2D

Derefter skal du oprette objekter, som din afspiller kan interagere med. Følgende eksempel viser oprettelsen af ​​et statisk objekt ved hjælp af StaticBody2D node:

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

Tilføjelse af en tilfældig bevægelsesalgoritme for statiske objekter

Nu hvor dine statiske objekter er klar, er det tid til at tilføje tilfældighed til dit spil. For at gøre dette kan du bruge en simpel tilfældig bevægelsesalgoritme:

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 hastigheden på dit statiske objekt. Opret også en Vector2-retning og initialiser den med tilfældige værdier mellem -1 og 1 for begge akser.

I den _fysikproces (delta) funktion, forøger objektets position med produktet af dets retning, hastighed og tidsdelta, hvilket får det til at bevæge sig i retningen med den givne hastighed.

Tilfældige positioner og baner for statiske objekter

Du kan øge tilfældigheden og uforudsigeligheden ved ikke kun at variere objekternes hastighed og retning, men også deres indledende positioner 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 hastigheden en tilfældig værdi mellem 50 og 150. Objektets startposition bestemmes tilfældigt inden for visningsportens størrelse i _parat() funktion og objektets position opdateres i _fysikproces (delta) fungerer som før.

Justering af hastighed, retning og tilfældighed

Du kan designe mere interaktivt og engagerende gameplay ved at manipulere hastigheden, retningen og tilfældigheden af ​​bevægelser for statiske objekter. Du kan oprette disse kontroller ved hjælp af 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()

Yderligere funktioner til dine tilfældige bevægelige objekter

Mens den grundlæggende tilfældige bevægelse tilføjer en uforudsigelig dynamik til dit spil, er der utallige yderligere funktioner, du kan tilføje for at forbedre dit spil yderligere. Nogle eksempler omfatter:

Farvevariation

På samme måde som du randomiserede objekternes hastighed og retning, kan du også randomisere deres farver. Dette kan tilføje et mere levende og visuelt tiltalende aspekt til dit spil. Du kan gøre dette ved at ændre modulere spritens ejendom.

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

Størrelsesvariation

Tilfældig ændring af størrelsen af ​​objekterne tilføjer endnu en sværhedsgrad og uforudsigelighed. Spillere bliver nødt til konstant at tilpasse sig de skiftende størrelser af objekter. Du kan ændre størrelsen på et objekt ved at justere dets vægt ejendom:

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

Objekt gydning

I stedet for at have et fast antal tilfældige objekter i bevægelse, kan du implementere et system, der afføder nye objekter med jævne mellemrum eller under visse betingelser. Dette kan tilføje et nyt sværhedsgrad, da spilleren bliver nødt til at justere deres strategi, efterhånden som flere objekter vises på skærmen.

Objektets levetid

Udover at skabe nye objekter, kan du også få objekter til automatisk at ødelægge sig selv efter et vist tidsrum. Dette kan forhindre, at skærmen bliver for rodet og holde gameplayet frisk.

Interaktioner

Tænk på at tilføje specifikke interaktioner mellem spilleren og de bevægelige objekter. For eksempel kan kollision med visse objekter øge spillerens score, ændre spillerens hastighed eller endda ændre spilmiljøet. Du kan også tillade spilleren at hoppe når man står på en platform.

Bedste praksis for tilføjelse af tilfældige objekter i bevægelse

Når du tilføjer tilfældige objekter i bevægelse, er det vigtigt at overveje et par bedste fremgangsmåder for at sikre et velafbalanceret, engagerende spil:

Ydelsesovervejelser

Selvom det er fristende at tilføje så mange objekter som muligt, skal du huske, at hvert objekt øger den beregningsmæssige belastning på spilmotoren. Test altid dit spil på målhardware for at sikre, at ydeevnen ikke påvirkes negativt.

Afbalancering af tilfældighed og spilbarhed

Mens tilfældige objekter kan tilføje sjov uforudsigelighed, kan for meget tilfældighed føre til frustration. Sørg for at teste grundigt for at finde den rette balance mellem udfordring og nydelse.

Kollisioner og reaktion

Sørg for, at spillet håndterer kollisioner mellem spilleren og objekterne korrekt. Tilfældige objekter i bevægelse kan forårsage uventede kollisionsscenarier, så planlæg dem og test dem grundigt.

Visuel klarhed

Tilfældige bevægelige objekter skal skille sig ud fra baggrunden og andre ikke-interaktive elementer. Dette hjælper spillere til hurtigt at forstå spilsituationen og planlægge deres handlinger derefter. Du kan også tilføje lydeffekter til dine genstande for at få dem til at skille sig ud.

Indvirkningen af ​​tilfældige objekter i bevægelse på dit Godot-spil

Tilfældige bevægelige objekter kan bidrage væsentligt til at gøre dit Godot-spil mere engagerende. De introducerer et element af uforudsigelighed, der holder spillerne på tæerne. Hver gang en spiller starter spillet, vil den hilse på dem med en anden konfiguration af objekter, hvilket øger dets genspilbarhed.

Desuden, da spillere ikke kan forudsige objekternes vej, skal de forblive fokuserede og lydhøre for at navigere i spilmiljøet