Ontdek hoe je een onvoorspelbaar element toevoegt aan je gameplay.

Bij de ontwikkeling van games kunnen elementen van willekeur en onvoorspelbaarheid een grote bijdrage leveren aan de algehele gameplay-ervaring. Een bijzondere manier om zo'n element te introduceren, is door middel van willekeurig bewegende objecten, die een extra laag interactie en uitdaging toevoegen.

Als je met Godot werkt, kun je dit effect bereiken met GDScript, de oorspronkelijke scripttaal van Godot.

Je Godot-spel opzetten

Stel voordat u begint een eenvoudige 2D-spelscène in de Godot-game-engine. Maak een nieuwe 2D-scène en voeg een KarakterBody2D knooppunt voor het personage van de speler. De KarakterBody2D node is het belangrijkste element voor het vertegenwoordigen van personages die kunnen bewegen en communiceren met hun omgeving.

De code die in dit artikel wordt gebruikt, is hierin beschikbaar GitHub-opslagplaats en is gratis voor u om te gebruiken onder de MIT-licentie.

Voeg twee onderliggende knooppunten toe aan het personage van de speler: a

BotsingVorm2D met een rechthoekige vorm, en een Sprite2D voor de grafische weergave van de speler.

Om mobiliteit aan het personage toe te voegen, kunt u de volgende GDScript-code gebruiken:

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)

Definieer een variabele, snelheid, voor de bewegingssnelheid van uw speler. De _fysica_proces (delta) functie regelt de beweging van het personage als reactie op input van de speler. Normaliseer de snelheid en richting van het personage om consistente bewegingen te garanderen, ongeacht de richting.

Statische objecten maken met StaticBody2D

Maak vervolgens objecten waarmee je speler kan communiceren. Het volgende voorbeeld demonstreert het maken van een statisch object met behulp van de StatischBody2D knooppunt:

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

Een willekeurig bewegingsalgoritme toevoegen voor statische objecten

Nu je statische objecten klaar zijn, is het tijd om willekeur aan je spel toe te voegen. Om dit te doen, kunt u een eenvoudig willekeurig bewegingsalgoritme gebruiken:

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

Definieer de snelheid van uw statische object. Maak ook een Vector2-richting en initialiseer deze met willekeurige waarden tussen -1 en 1 voor beide assen.

In de _fysica_proces (delta) functie, verhoog de positie van het object met het product van zijn richting, snelheid en de tijdsdelta, waardoor het met de gegeven snelheid in de richting beweegt.

Willekeurige posities en trajecten voor statische objecten

Je kunt de willekeur en onvoorspelbaarheid vergroten door niet alleen de snelheid en richting van de objecten te variëren, maar ook hun beginposities en trajecten.

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

Hier is de snelheid een willekeurige waarde tussen 50 en 150. De beginpositie van het object wordt willekeurig bepaald binnen de grootte van de viewport in de _klaar() functie en de positie van het object wordt bijgewerkt in de _fysica_proces (delta) functioneren net als voorheen.

Snelheid, richting en willekeur aanpassen

Je kunt meer interactieve en boeiende gameplay ontwerpen door de snelheid, richting en willekeur van bewegingen voor statische objecten te manipuleren. U kunt deze besturingselementen maken met 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()

Extra functies voor uw willekeurig bewegende objecten

Hoewel de willekeurige basisbewegingen een onvoorspelbare dynamiek aan je spel toevoegen, zijn er talloze extra functies die je kunt toevoegen om je spel verder te verbeteren. Enkele voorbeelden zijn:

Kleurvariatie

Vergelijkbaar met hoe je de snelheid en richting van de objecten willekeurig hebt gemaakt, kun je ook hun kleuren willekeurig maken. Dit kan een levendiger en visueel aantrekkelijker aspect aan je spel toevoegen. Dit doe je door de moduleren eigenschap van de sprite.

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

Grootte variatie

Het willekeurig veranderen van de grootte van de objecten voegt een extra moeilijkheidsgraad en onvoorspelbaarheid toe. Spelers zullen zich voortdurend moeten aanpassen aan de veranderende afmetingen van objecten. U kunt de grootte van een object wijzigen door het aan te passen schaal eigendom:

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

Object spawnen

In plaats van een vast aantal willekeurig bewegende objecten te hebben, zou je een systeem kunnen implementeren dat met regelmatige tussenpozen of onder bepaalde voorwaarden nieuwe objecten voortbrengt. Dit kan een nieuwe moeilijkheidsgraad toevoegen, aangezien de speler zijn strategie moet aanpassen naarmate er meer objecten op het scherm verschijnen.

Objectlevensduur

Naast het spawnen van nieuwe objecten, kun je objecten ook automatisch laten vernietigen na een bepaalde tijd. Dit kan voorkomen dat het scherm te rommelig wordt en houdt de gameplay fris.

Interacties

Denk na over het toevoegen van specifieke interacties tussen de speler en de bewegende objecten. Een botsing met bepaalde objecten kan bijvoorbeeld de score van de speler verhogen, de snelheid van de speler veranderen of zelfs de spelomgeving veranderen. Je kan ook laat de speler springen wanneer u op een platform staat.

Best practices voor het toevoegen van willekeurige bewegende objecten

Bij het toevoegen van willekeurig bewegende objecten is het belangrijk om een ​​paar praktische tips in overweging te nemen om een ​​goed uitgebalanceerd, boeiend spel te garanderen:

Prestatieoverwegingen

Hoewel het verleidelijk is om zoveel mogelijk objecten toe te voegen, onthoud dat elk object de rekenkracht van de game-engine vergroot. Test je game altijd op doelhardware om er zeker van te zijn dat de prestaties niet negatief worden beïnvloed.

Evenwicht tussen willekeur en speelbaarheid

Hoewel willekeurige objecten leuke onvoorspelbaarheid kunnen toevoegen, kan te veel willekeur tot frustratie leiden. Zorg ervoor dat u uitgebreid test om de juiste balans te vinden tussen uitdaging en plezier.

Botsingen en reactie

Zorg ervoor dat het spel botsingen tussen de speler en de objecten op de juiste manier afhandelt. Willekeurig bewegende objecten kunnen onverwachte botsingsscenario's veroorzaken, dus plan deze en test grondig.

Visuele helderheid

Willekeurig bewegende objecten moeten afsteken tegen de achtergrond en andere niet-interactieve elementen. Dit helpt spelers om de spelsituatie snel te begrijpen en hun acties dienovereenkomstig te plannen. Je kan ook voeg geluidseffecten toe aan uw objecten om ze te laten opvallen.

Impact van willekeurig bewegende objecten op je Godot-spel

Willekeurig bewegende objecten kunnen aanzienlijk bijdragen aan het boeiender maken van je Godot-spel. Ze introduceren een element van onvoorspelbaarheid dat spelers scherp houdt. Elke keer dat een speler het spel start, begroet het hem met een andere configuratie van objecten, wat bijdraagt ​​aan de herspeelbaarheid.

Bovendien, aangezien spelers het pad van bewegende objecten niet kunnen voorspellen, moeten ze gefocust en responsief blijven om door de spelomgeving te navigeren