Skapa ett dialogsystem i Godot med GDScript

Inom spelutveckling är engagerande spel och fängslande berättande nyckeln till att skapa minnesvärda upplevelser. Ett kraftfullt verktyg som kan hjälpa dig att uppnå detta är ett dialogsystem.

Med ett välimplementerat dialogsystem kan karaktärer kommunicera, dela information och interagera med spelaren, vilket ger djup och fördjupning till ditt spel.

Konfigurera ditt Godot-spel

Börja med att skapa grunden för ditt spel. För det här exemplet, skapa en enkel 2D-miljö med en kontrollerbar karaktär som kan flytta runt med hjälp av piltangenterna.

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.

Börja med att skapa en ny scen för din spelarkaraktär. Lägg till de nödvändiga komponenterna i den här scenen. Skapa en CharacterBody2D nod för att representera spelarkaraktärens kropp. Bifoga en CollisionShape2D med en rektangulär form för att definiera spelarens kollisionsområde.

Nu, lägga till karaktärsrörelse och interaktion med plattformar som använder GDScript. Ersätt standardskriptet för CharacterBody2D-noden med följande kod:

extends CharacterBody2D
var speed = 300
func _physics_process(delta):
 var input_dir = Vector2.ZERO
if Input.is_action_pressed("ui_left"):
 input_dir.x -= 1
if Input.is_action_pressed("ui_right"):
 input_dir.x += 1
if Input.is_action_pressed("ui_up"):
 input_dir.y -= 1
if Input.is_action_pressed("ui_down"):
 input_dir.y += 1
 velocity = input_dir.normalized() * speed
 move_and_collide(velocity * delta)

Det här skriptet låter din karaktär flytta sig åt vänster, höger, upp och ner baserat på piltangenterna. De flytta_och_krocka funktion säkerställer att karaktären interagerar med plattformar och reagerar på kollisioner.

Lägger till dialogrutan

Nu kan du börja skapa dialogsystemet. Det första steget är att lägga till en dialogruta som visar text när din karaktär interagerar med specifika objekt eller NPC: er.

I din CharacterBody2D skript, introducera några fler variabler för att hantera dialogrutan och dess innehåll:

var dialogue_box: Label
var close_button: Button
var dialogue_lines: Array = ["Hello, adventurer!", "Welcome to our village."]
var current_line: int = 0
var line_timer: float = 0

De dialogruta kommer att ansvara för att visa dialogtexten, medan stäng_knapp kommer att tillåta spelare att stänga dialogrutan när det behövs.

I den _redo funktion, skapa och initiera dialogrutan:

func _ready():
 dialogue_box = Label.new()
 dialogue_box.visible = false
 add_child(dialogue_box)

Visar dialogtext

Nu kan du fokusera på att visa texten i dialogrutan. Du kan få texten att sträcka sig över mer än en rad och rulla den så att en rad text i taget visas.

Ändra din _fysikprocess funktion för att hantera visningen av dialograder:

if line_timer > 0:
 line_timer -= delta
elif current_line < dialogue_lines.size():
 show_next_dialogue_line()

Detta kodsegment kontrollerar om linje_timer är större än 0. Om den är det, minskar den timern med deltavärdet. Om timern inte är aktiv och det finns fler dialograder att visa, anropar den show_next_dialogue_line fungera.

Implementera show_next_dialogue_line fungerar enligt följande:

func show_next_dialogue_line():
 dialogue_box.text = dialogue_lines[current_line]
 current_line += 1
# Display each line for 3 seconds
 line_timer = 3.0

Denna funktion uppdaterar texten i dialogrutan med den aktuella dialograden och ökar den aktuell_linje index. De linje_timer ser till att varje rad visas under en kort period innan du går vidare till nästa rad.

Lägga till en stängningsknapp

Nu kan du ge spelare möjligheten att stänga dialogrutan och fortsätta spela spelet. Gör detta med en stängningsknapp som, när de trycker på den, döljer dialogrutan och låter spelaren fortsätta sin resa.

Först, ändra _redo funktion för att skapa en stängningsknapp och bifoga dess funktionalitet.

func _ready():
 dialogue_box = Label.new()
 dialogue_box.visible = false
 add_child(dialogue_box)
 close_button = Button.new()
 close_button.text = "Close"
 close_button.position = Vector2(50, 30)
 close_button.visible = false
 close_button.pressed.connect(_on_close_button_pressed)
 add_child(close_button)

Denna kod skapar en instans av Knapp klass och anpassar dess utseende och position. Den kopplar också ihop nedtryckt signal till _på_stäng_knappen_tryckt fungera.

Implementera nu _på_stäng_knappen_tryckt fungera. I den här funktionen ställer du in synligheten för både dialogrutan och stängningsknappen till falsk. Detta döljer effektivt dialoggränssnittet för spelaren.

Kom ihåg att återställa aktuell_linje indexera till 0 för att säkerställa att dialogen startar från början nästa gång spelaren startar en konversation:

func _on_close_button_pressed():
 dialogue_box.visible = false
 close_button.visible = false
 current_line = 0

Med dessa ändringar kommer spelare att kunna gå i dialog och stänga dialogrutan när de är redo att fortsätta utforska eller interagera med spelvärlden.

Bästa praxis för ditt dialogsystem

När du fortsätter att utveckla och förfina ditt dialogsystem, ha följande bästa praxis i åtanke kommer att bidra till att ditt system förbättrar ditt spels storytelling och spelarengagemang till fullo utsträckning.

Konsekvens är nyckeln

Upprätthåll en konsekvent ton, skrivstil och ordförråd genom hela ditt dialogsystem. Konsistens hjälper spelare att få kontakt med karaktärer och spelvärlden, vilket skapar en sömlös och uppslukande upplevelse.

Hantverk karaktärsröster

Varje karaktär bör ha en distinkt röst och personlighet som återspeglas i deras dialoger. Tänk på deras bakgrund, motiv och känslor när du skriver sina rader.

Denna differentiering ger djup till dina karaktärer och gör interaktioner mer minnesvärda. Du kan enkelt lägga till olika ljud för olika karaktärer i Godot.

Meningsfulla val

Designa dialogval som får meningsfulla konsekvenser. Val som påverkar spelets berättelse, relationer eller till och med spelmekanik uppmuntrar spelare att engagera sig i dialogsystemet och investera känslomässigt i sina beslut.

Testning och iteration

Testa dina dialogsekvenser noggrant för att fånga eventuella stavfel, grammatiska fel eller tempoproblem. Delta i speltestning för att samla feedback från spelare och göra nödvändiga justeringar för att säkerställa att dialogsystemet flyter smidigt och förbättrar den övergripande spelupplevelsen.

UI-konsistens

Se till att utformningen och presentationen av dialogsystemet stämmer överens med helheten användargränssnitt (UI) design av ditt spel. Konsekventa UI-element, typsnitt och färger skapar en sammanhängande visuell upplevelse som bidrar till spelets fördjupning.

Genom att följa dessa bästa metoder kan du skapa ett dialogsystem som inte bara förbättrar ditt spels berättelse utan också skapar en minnesvärd och uppslukande upplevelse för spelarna.

Lyft dina Godot-spel med dialogsystem

Att införliva ett dialogsystem i dina Godot-spel kan förbättra spelarens engagemang och revolutionera ditt berättande. Genom att göra det möjligt för karaktärer att kommunicera, uttrycka känslor och reagera på spelarbeslut skapar du en mer uppslukande och interaktiv spelvärld.

Med Godots användarvänliga miljö och kraften i GDScript har du verktygen att skapa övertygande dialogsystem som drar in spelare i din berättelse och förbättrar deras övergripande spelande erfarenhet.