Skapa ett dialogsystem i Godot med GDScript

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

En korrekt utförd dialogmekanism gör det möjligt för karaktärer att konversera, utbyta data och få kontakt med spelare, vilket ökar spelupplevelsens rikedom och uppslukande kvalitet.

Konfigurera ditt Godot-spel

Inled utvecklingsprocessen med att bygga upp den grundläggande strukturen för ditt spel. I det här fallet ska du skapa en grundläggande tvådimensionell miljö med en avatar som kan navigera med hjälp av piltangenterna.

Källkoden som används i denna publikation kan nås via ett offentligt arkiv på GitHub, som erbjuder den utan kostnad för din bekvämlighet enligt villkoren i den allmänt accepterade MIT-licensen.

Införliva det givna kodavsnittet i Unity genom att skapa en ny miljö för spelarens karaktär. Introducera en instans av CharacterBody2D -objektet och anslut det till scenen. Lägg sedan till en CollisionShape2D -komponent som har en rektangulär form för att bestämma gränserna inom vilka spelaren interagerar med andra objekt i spelvärlden.

Införliva karaktärsrörlighet och interaktivitet med plattformsbaserade objekt genom att använda GDScript för att ersätta standardskriptet för CharacterBody2D-komponenten. Den medföljande koden är följande:

 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)

Den aktuella koden gör det möjligt för huvudpersonen att navigera med hjälp av piltangentkommandon, vilket underlättar deras progression genom en mängd olika plattformar samtidigt som hänsyn tas till eventuella interaktioner eller kollisioner som kan uppstå.

Lägga till dialogruta

När man börjar utveckla ett dialogsystem är den första fasen att införliva ett gränssnitt som visar text vid interaktion mellan spelarens karaktär och särskilda objekt eller icke-spelarkaraktärer (NPC:er).

För att förbättra funktionaliteten i vårt skript CharacterBody2D bör vi lägga till ytterligare variabler som gör att vi kan hantera dialogrutan och dess innehåll på ett effektivt sätt. Detta kan uppnås genom att införa nya variabler som _dialogBox , _previousLine , och _currentLine . Den förstnämnda innehåller referensen till dialogboxobjektet, medan de två sistnämnda representerar den aktuella raden som skrivs i textfältet respektive den föregående raden. Genom att använda dessa variabler kan vi implementera funktioner som historikåterkallning och realtidsuppdatering av textfältet när du skriver.

 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 

dialogue_box är utformad för att visa konversationsinnehållet, och close_button fungerar som ett sätt för användare att avfärda dialogrutan när de anser att det är nödvändigt.

I funktionen ready kommer jag att skapa och initiera en dialogruta för vår applikation. Denna dialogruta är nödvändig för att skapa ett gränssnitt mellan användaren och programmet, så att de kan interagera med det på ett meningsfullt sätt. Dialogrutan kan visa olika meddelanden eller uppmaningar beroende på vilka åtgärder som utförs av användaren eller programmet. Dessutom fungerar dialogrutan som en behållare för andra komponenter som vi kommer att lägga till senare, t.ex. knappar eller textfält, som gör att användaren kan mata in data eller utföra specifika uppgifter i programmet.

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

Visa dialogtext

Du kan nu koncentrera dig på att presentera innehållet i dialogrutan. Det är möjligt att förlänga texten över flera rader och aktivera scrollning, så att endast en rad visas åt gången.

Följ dessa steg för att modifiera fysikprocessfunktionen så att den kan visa dialograder:1. Lägg till en ny variabel som heter “dialogueLines” för att lagra textdata för varje dialograd. Detta kan göras genom att skapa en tom array och tilldela den nyckeln “dialogueLines” i önskat objekt eller skript.2. Uppdatera simuleringsloopen så att den inkluderar hantering av dialograder. I denna loop hämtar du textdata från “dialogueLines”-arrayen med indexvärdet som identifierare. Uppdatera sedan positioneringen och renderingen av pratbubblan baserat på de egenskaper som definierats i det ursprungliga designdokumentet.

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

Det angivna kodstycket utvärderar om värdet på variabeln line\_timer överskrider ett visst tröskelvärde. Om detta villkor är sant minskas timerns värde med det angivna deltavärdet. Om timern för närvarande är inaktiv och det återstår ytterligare dialoginnehåll som ska visas, anropas dessutom subrutinen show\_next\_dialogue\_line.

Implementera funktionen show_next_dialogue_line 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 

Funktionen present-day ändrar texten i pratbubblan med det senaste uttalandet och höjer värdet på räknaren för aktuell rad. En timer, kallad “line\_timer”, reglerar hur länge varje uttalande ska vara synligt på skärmen innan man går vidare till nästa meddelande.

Lägga till en Stäng-knapp

Du kan nu ge spelarna möjlighet att avfärda konversationsfönstret och fortsätta med spelet. Detta kan åstadkommas genom att lägga till en “stäng”-knapp i dialogrutan, som när den trycks in döljer det nämnda fönstret och gör det möjligt för deltagaren att återgå till spelets progression.

Modifiera den befintliga ready -funktionen för att generera en stängknapp med motsvarande funktionalitet genom att införliva den nödvändiga HTML-koden för stängknappen i den event listener-funktion som öppnar det modala fönstret.

 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) 

Den medföljande koden genererar ettButton-objekt, anpassar dess visuella presentation och placering och upprättar en koppling mellan händelsesignalen för tryck och funktionen\_on\_close\_button\_pressed\*.

Införliva en ny metod med namnet _on_close_button_pressed i klassen GameUIManager . I denna funktion ska du se till att både dialogrutans synlighet och dess stängningsknapp är inställda på false . På så sätt kan användaren inte längre se eller interagera med dialoggränssnittet.

För att börja om på nytt är det klokt att återställa det aktuella linjeindexet till dess ursprungliga tillstånd på noll för att garantera att vår diskurs börjar om på nytt vid varje tillfälle då deltagaren uppmanar till kommunikation:

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

Genom denna modifiering kommer deltagarna att ha möjlighet att delta i samtal och stänga av dialogrutan efter eget gottfinnande, så att de kan fortsätta att navigera eller interagera med den digitala miljön som de vill.

Bästa praxis för ditt dialogsystem

Genom att hålla fokus på dessa rekommenderade riktlinjer när du successivt förbättrar och finslipar din samtalsmodell kan du ge dina spelare ett optimalt berättardjup och fördjupa sig i berättelsen.

Konsekvens är nyckeln

Att upprätthålla en enhetlig språklig strategi är avgörande för att främja en autentisk koppling mellan spelaren och spelets karaktärer samtidigt som man främjar en sammanhängande atmosfär i den virtuella miljön. Denna orubbliga konsekvens gör det möjligt att skapa en relation mellan spelaren och berättelsen, vilket förbättrar deras helhetsupplevelse genom att säkerställa ett smidigt och absorberande äventyr.

Skapa karaktärsröster

För att skapa autentiska och övertygande karaktärer är det viktigt att ge varje individ en unik röst och temperament som härrör från deras bakgrundshistoria, mål och känslor. På så sätt kan läsarna eller tittarna bättre förstå och knyta an till dem på ett känslomässigt plan.

Att införliva distinkta talmönster och manér för varje karaktär förstärker inte bara deras individualitet utan bidrar också till minnesvärda utbyten mellan dem, eftersom det ger en unik identifierare som skiljer en personlighet från en annan. Lyckligtvis är det enkelt att implementera dessa variationer inom ramen för Godot, vilket gör det möjligt för utvecklare att skapa olika ljudsignaler med minimal ansträngning.

Meningsfulla val

Inkorporera valresultat som har betydande konsekvenser för både berättelsen och interaktionen mellan spelare och karaktärer. Genom att påverka aspekter som intrigutveckling, interpersonell dynamik eller centrala spelregler motiverar dessa konsekvensval användarna att aktivt delta i samtalssekvenser och främja känslomässigt engagemang för sina val.

Testning och Iteration

Gör en omfattande utvärdering av dina dialogsekvenser genom att noggrant kontrollera stavfel, grammatiska inkonsekvenser och obalans i tempot. Använd speltestningstekniker för att samla in insikter från spelare och implementera ändringar efter behov för att garantera sömlös interaktion och en förbättrad spelupplevelse genom dialogsystemet.

Konsistens i användargränssnittet

När man utformar ett dialogsystem för ett videospel är det viktigt att se till att dess utseende och layout stämmer överens med spelets användargränssnitt i stort. Genom att vara konsekvent när det gäller visuella komponenter som teckensnitt, färgscheman och andra grafiska element kan man bidra till en uppslukande spelmiljö genom att främja ett enhetligt utseende i alla aspekter av spelet.

Genom att följa dessa rekommendationer kan du utveckla ett dialogbaserat system som inte bara lyfter berättandet i ditt spel utan också skapar en oförglömlig och uppslukande upplevelse för spelarna.

Förbättra dina Godot-spel med dialogsystem

Integrering av ett dialogbaserat system i dina Godot-spel har potential att öka spelarnas engagemang och förändra berättartekniker. Genom att underlätta karaktärskommunikation, känslouttryck och respons på spelarens val skapas en alltmer uppslukande och sammankopplad spelmiljö.

Genom att använda den intuitiva plattform som Godot erbjuder och utnyttja funktionerna i dess skriptspråk, GDScript, kan utvecklare skapa fängslande dialogsystem som effektivt fördjupar spelarna i ett övertygande narrativ och höjer deras totala spelupplevelse.