← Blog

Een dialog system ontwerpen voor World Eater

Een dialog system vanaf nul in Unity: branching, callbacks, eigen teksteffecten en een architectuur die flow en rendering scheidt.

Het dialog system in actie.
Het dialog system in actie.
In het kort
  • Rol: onderzoek, ontwerp en implementatie van het dialog system, inclusief UI en teksteffecten.
  • Stack: Unity, C#, UI Toolkit.
  • Kern: een data-gedreven systeem met branching, callbacks, geluid en custom teksteffecten, waarbij flow en rendering gescheiden zijn.

Waarom zelf bouwen?

World Eater had een manier nodig om het verhaal te vertellen en de speler te laten weten wat er gebeurt. Voor dialog systems bestaan genoeg kant-en-klare assets. Ik koos er bewust voor om het zelf te bouwen: ik wilde begrijpen welke ontwerpkeuzes achter een goed dialog system zitten, in plaats van alleen een asset te configureren.

Onderzoek en eerste prototype

Ik begon met een analyse van dialog systems in bestaande games. Bijna allemaal komen ze neer op dezelfde kern: een portret van het personage, de tekst die het zegt, en eventueel keuzes om te reageren.

Dat werd mijn eerste datamodel: elke dialoog heeft een afbeelding, een string en een lijst keuzes. Dat prototype, met een eenvoudige UI, heb ik vroeg aan het team laten zien. Pas nadat zij akkoord waren, heb ik features toegevoegd.

Ontwerp van het prototype van het dialog system.
Ontwerp van het prototype van het dialog system.

Scope

Het systeem moest sfeer toevoegen, de speler informeren en keuzes mogelijk maken. Concreet:

  • branching dialogs en events die afgaan wanneer de speler een optie kiest;
  • geluid, afbeeldingen en teksteffecten per bericht;
  • vloeiende overgangen tussen berichten;
  • een prettige developer experience voor teamgenoten die dialogen schrijven.

Controller support liet ik bewust buiten scope: de game draait in de browser via WebGL, dus vrijwel iedereen speelt met muis en toetsenbord.

Architectuur

BaseDialog

BaseDialog is de kern: tekst, opties, het sprekende personage, en tekst- en geluidseffecten. Voor de meest voorkomende gevallen zijn er subclasses als SimpleContinuingDialog en SimpleEndingDialog, met minder constructor-argumenten. Zo blijft een simpel gesprek kort om te schrijven, terwijl BaseDialog beschikbaar blijft voor de uitzonderingen.

Een compacte weergave van de BaseDialog-class.
Een compacte weergave van de BaseDialog-class.

Flow en branching

DialogSystemController houdt bij welk bericht actief is, en elke dialoog krijgt een referentie naar die controller om door te schakelen. Branching werkt via de nextDialog-property, zodat een keuzeboom gewoon in code staat. Met callbacks als OnClickedOption en OnClickedNext kan een keuze ook gameplay aansturen, bijvoorbeeld een animatie starten of de gamestate aanpassen.

Implementatie van een dialog met de BaseDialog-class.
Implementatie van een dialog met de BaseDialog-class.

Logica los van rendering

De flow van de dialoog weet niets van hoe tekst op het scherm komt; dat doet een aparte class, DialogSystemUI. Daardoor kun je de UI aanpassen zonder de dialoglogica aan te raken, en andersom.

Het systeem bestaat in totaal uit deze classes en interfaces:

  • SimpleContinuingDialog
  • SimpleEndingDialog
  • BaseDialogCharacter
  • BaseDialogOption
  • SimpleContinueDialogOption
  • SimpleEndDialogOption
  • DialogSound
  • DialogSystemController
  • DialogSystemUI
  • IDialog
  • IDialogCharacter
  • IDialogOption
  • TestDialog (1–5)
  • TestDialogCharacter (1–2)

UI en game feel

De UI is donker en doorzichtig met afgeronde hoeken en lichte tekst, passend bij het ruimtethema: portret links, tekst rechts, opties rechtsonder. Opties worden groter bij hover, zodat duidelijk is wat klikbaar is.

Voorbeeld van de user interface in-game.
Voorbeeld van de user interface in-game.

Teksteffecten

Basisopmaak gebruikt de rich text van UI Toolkit, met tags die op HTML lijken:

<i>Hello</i>, <b>world</b>

Voor meer persoonlijkheid heb ik eigen effecten toegevoegd: regenboog, golvend, op en neer, schuddend, draaiend, en groter of kleiner. Ze zitten in één enum, DialogTextEffects, zodat je per bericht één of meer effecten kiest. Het regenboogeffect kan ook op een deel van de tekst, zoals “space dust” in de afbeelding bovenaan.

In DialogSystemUI.CreateDialogElement bepaalt een switch welke effecten actief worden. Alle effecten behalve de tekstgrootte draaien als coroutine die elke frame het Label aanpast. ShakeEffect verschuift het label bijvoorbeeld elke frame met een kleine willekeurige offset.

De DialogTextEffects-enum De ShakeEffect-method
De teksteffecten-enum en de implementatie van een teksteffect.
Regenboogkleurige tekst Schuddende tekst
Regenboogkleurige en schuddende teksteffecten.

Een beperking: door hoe de effecten zijn geïmplementeerd, zijn ze niet allemaal met elkaar te combineren. Veel combinaties werken wel.

Overgangen

Berichten faden uit en in, zodat duidelijk is wanneer een nieuw bericht begint. De uitdaging was dat animaties de input niet mochten vertragen. Dat heb ik opgelost met een cooldown die parallel aan de animatie loopt, in plaats van te wachten tot de animatie klaar is.

Testen

Ik heb het systeem getest met een testdialoog die alle features raakt: branching, geluid en teksteffecten.

De testdialoog.
De testdialoog.

Eén bekend probleem: een lus in de dialoogstructuur laat de game crashen. Omdat geen enkele dialoog in World Eater een lus nodig had, heb ik dat bewust niet opgelost en de tijd in andere features gestoken.

Wat ik anders zou doen

  • Dialogen als data: nu staan gesprekken in C#. Met ScriptableObjects of een eenvoudig bestandsformaat kunnen writers en designers dialogen aanpassen zonder code.
  • Lussen afvangen: een check op cycli bij het opbouwen van de dialoog, zodat een fout in de structuur een waarschuwing geeft in plaats van een crash.
  • Combineerbare effecten: effecten per teken toepassen in plaats van op het hele label, zodat ze elkaar niet meer in de weg zitten.

Verder lezen