Upptäck hur du lägger till ett oförutsägbart element i ditt spelande.

I spelutveckling kan element av slumpmässighet och oförutsägbarhet i hög grad bidra till den övergripande spelupplevelsen. Ett särskilt sätt att introducera ett sådant element är genom slumpmässiga rörliga objekt, som lägger till ett extra lager av interaktion och utmaning.

Om du arbetar med Godot kan du uppnå denna effekt med GDScript, Godots ursprungliga skriptspråk.

Konfigurera ditt Godot-spel

Innan du börjar, ställ in en grundläggande 2D-spelscen i spelmotorn Godot. Skapa en ny 2D-scen och lägg till en CharacterBody2D nod för spelarkaraktären. De CharacterBody2D noden är huvudelementet för att representera karaktärer som kan röra sig och interagera med sin omgivning.

Koden som används i den här artikeln är tillgänglig i denna GitHub-förråd och är gratis för dig att använda under MIT-licensen.

Lägg till två underordnade noder till spelarkaraktären: a CollisionShape2D med en rektangulär form, och en Sprite2D för spelarens grafiska representation.

instagram viewer

För att lägga till rörlighet till karaktären kan du använda följande GDScript-kod:

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)

Definiera en variabel, fart, för din spelares rörelsehastighet. De _fysikprocess (delta) funktionen styr karaktärens rörelse som svar på spelarens inmatningar. Normalisera karaktärens hastighet och riktning för att säkerställa konsekvent rörelse oavsett riktning.

Skapa statiska objekt med StaticBody2D

Skapa sedan objekt som din spelare kan interagera med. Följande exempel visar skapandet av ett statiskt objekt med hjälp av StaticBody2D nod:

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

Lägga till en slumpmässig rörelsealgoritm för statiska objekt

Nu när dina statiska objekt är klara är det dags att lägga till slumpmässighet i ditt spel. För att göra detta kan du använda en enkel slumpmässig rörelsealgoritm:

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

Definiera hastigheten på ditt statiska objekt. Skapa också en Vector2-riktning och initiera den med slumpmässiga värden mellan -1 och 1 för båda axlarna.

I den _fysikprocess (delta) funktion, öka objektets position med produkten av dess riktning, hastighet och tidsdelta, vilket får det att röra sig i riktningen med den givna hastigheten.

Slumpmässiga positioner och banor för statiska objekt

Du kan öka slumpen och oförutsägbarheten genom att inte bara variera objektens hastighet och riktning utan även deras initiala positioner och banor.

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

Här är hastigheten ett slumpmässigt värde mellan 50 och 150. Objektets initiala position bestäms slumpmässigt inom visningsportens storlek i _redo() funktion och objektets position uppdateras i _fysikprocess (delta) fungerar precis som tidigare.

Justera hastighet, riktning och slumpmässighet

Du kan designa mer interaktivt och engagerande spel genom att manipulera hastigheten, riktningen och slumpmässigheten i rörelsen för statiska objekt. Du kan skapa dessa kontroller med 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()

Ytterligare funktioner för dina slumpmässiga rörliga objekt

Medan den grundläggande slumpmässiga rörelsen tillför en oförutsägbar dynamik till ditt spel, finns det otaliga ytterligare funktioner du kan lägga till för att ytterligare förbättra ditt spel. Några exempel inkluderar:

Färgvariation

I likhet med hur du randomiserade objektens hastighet och riktning, kan du också slumpvisa deras färger. Detta kan lägga till en mer levande och visuellt tilltalande aspekt till ditt spel. Du kan göra detta genom att ändra modulera spritens egendom.

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

Storleksvariation

Att slumpmässigt ändra storleken på föremålen ger ytterligare en svårighetsgrad och oförutsägbarhet. Spelare måste ständigt anpassa sig till de ändrade storlekarna på objekt. Du kan ändra storleken på ett objekt genom att justera dess skala fast egendom:

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

Objekt lek

Istället för att ha ett fast antal slumpmässigt rörliga objekt kan du implementera ett system som skapar nya objekt med jämna mellanrum eller under vissa förhållanden. Detta kan lägga till ett nytt svårighetslager eftersom spelaren kommer att behöva justera sin strategi när fler objekt dyker upp på skärmen.

Objektets livslängd

Förutom att skapa nya objekt kan du också låta objekt förstöra sig automatiskt efter en viss tidsperiod. Detta kan förhindra att skärmen blir för rörig och hålla spelet fräscht.

Interaktioner

Tänk på att lägga till specifika interaktioner mellan spelaren och de rörliga föremålen. Till exempel kan kollision med vissa objekt öka spelarens poäng, ändra spelarens hastighet eller till och med ändra spelmiljön. Du kan också låt spelaren hoppa när man står på en plattform.

Bästa metoder för att lägga till slumpmässiga rörliga objekt

När du lägger till slumpmässiga rörliga föremål är det viktigt att överväga några bästa metoder för att säkerställa ett välbalanserat, engagerande spel:

Prestandaöverväganden

Även om det är frestande att lägga till så många objekt som möjligt, kom ihåg att varje objekt ökar beräkningsbelastningen på spelmotorn. Testa alltid ditt spel på målhårdvara för att säkerställa att prestandan inte påverkas negativt.

Balansering av slumpmässighet och spelbarhet

Även om slumpmässiga föremål kan skapa roliga oförutsägbarheter, kan för mycket slumpmässighet leda till frustration. Var noga med att testa utförligt för att hitta rätt balans mellan utmaning och njutning.

Kollisioner och reaktion

Se till att spelet hanterar kollisioner mellan spelaren och föremålen på rätt sätt. Slumpmässigt rörliga föremål kan orsaka oväntade kollisionsscenarier, så planera för dessa och testa noggrant.

Visuell klarhet

Slumpmässigt rörliga objekt ska sticka ut från bakgrunden och andra icke-interaktiva element. Detta hjälper spelare att snabbt förstå spelsituationen och planera sina handlingar därefter. Du kan också lägga till ljudeffekter till dina föremål för att få dem att sticka ut.

Inverkan av slumpmässiga rörliga objekt på ditt Godot-spel

Slumpmässiga rörliga föremål kan bidra avsevärt till att göra ditt Godot-spel mer engagerande. De introducerar ett element av oförutsägbarhet som håller spelarna på tårna. Varje gång en spelare startar spelet kommer den att välkomna dem med en annan konfiguration av objekt, vilket ökar dess omspelbarhet.

Dessutom, eftersom spelare inte kan förutsäga vägen för rörliga föremål, måste de förbli fokuserade och lyhörda för att navigera i spelmiljön