SCHEMA
<script lang="ts">
import { Dialogue } from "svelte-dialogue-tree";
const tree = {
branch1: [ // π dialogue starts from the tree's first key
// TextLeaf
// TextLeaf
// TextLeaf
// TextLeaf
// TextLeaf β
any number of TextLeafs can populate a branch
],
branch3: [
// TextLeaf
// ComponentLeaf
// TextLeaf
// ComponentLeaf
// ComponentLeaf β
any number of ComponentLeafs can be placed anywhere
],
branch4: [
// TextLeaf
// TextLeaf
// ChoiceLeaf β
ChoiceLeafs should always be at the end of branches
],
invalid1: [
// TextLeaf
// ChoiceLeaf β ChoiceLeafs should always be at the end of branches
// TextLeaf
],
invalid2: [
// TextLeaf
// ChoiceLeaf
// ChoiceLeaf β there cannot be more than one ChoiceLeaf in a single branch
],
};
const characters = { // β optional Dialogue parameter
character1: {
name: "name of character1",
avatarSrc: "character1.jpg" // β optional parameter
},
character2: {
name: "name of character2",
},
}
</script>
<!-- WITH CHARACTERS -->
<Dialogue {tree} {characters} /> β
<!-- OR WITHOUT CHARACTERS -->
<Dialogue {tree} /> β
TYPES
TextLeaf
A TextLeaf can be in following types: string
, TextObject, a function that returns a string
, a function that returns a TextObject.
// string
"something"
// narration string
"** something is being narrated **"
// HTML string
"<a href="/something">something</a>"
// TextObject
{ text: "something", character: "jason" }
// function that returns a string
() => "something"
// function that returns a TextObject
() => { text: "something", character: "jason" }
TextObject
A TextObject requires a text
property and at least one (1) additional property.
Additional properties are: onSpawn and character.
// TextObject
{
text: "something",
character: "jason"
}
// TextObject
{
text: "something",
onSpawn: () => console.log("something spawned.")
}
// TextObject (it can have both of the additional properties)
{
text: "something",
character: "jason",
onSpawn: () => console.log("something spawned.")
}
TextObject.text
The string that will be displayed.
const tree = {
start: [
"Hello",
{
text: "world",
onSpawn: () => console.log("spawned world")
}
]
}
TextObject.onSpawn
The function that is assigned to onSpawn
is executed when the TextObject enters the DOM.
let health = 100;
function fallFromCliff() {
health -= 50;
}
const tree = {
start: [
"** You wake up near a cliff. **",
{
text: "** You panic and fall from the cliff. **",
onSpawn: fallFromCliff
}
]
}
TextObject.character
character
should be a key of a CharacterCollection.
const characters = {
gotrek: {
name: "Gotrek the Trollslayer",
avatarSrc: "gotrek.jpg"
}
}
const tree = {
start: [
"** You open your eyes and see a dwarf looking at you in disdain **",
{
text: "Wake up, manling.",
character: "gotrek"
}
]
}
CharacterCollection
CharacterCollection
is an object which holds CharacterKeys as keys and Characters as values.
const characters = {
gotrek: {
name: "Gotrek the Trollslayer",
avatarSrc: "gotrek.jpg"
}
}
const tree = {
start: [
"** You open your eyes and see a dwarf looking at you in disdain **"
{ text: "Wake up, manling.", character: "gotrek" }
]
}
Character
A Character requires a name and can have an optional avatarSrc.
const gotrek = {
name: "Gotrek the Trollslayer",
avatarSrc: "gotrek.jpg"
}
const felix = {
name: "Felix Jaeger",
// avatarSrc is optional
}
ComponentLeaf
A ComponentLeaf requires a component
property which accepts a Svelte component. The other property is the optional args
property, which is passed to the given component as a destructured argument.
import { Component } from "./Component.svelte";
// ComponentLeaf
{
component: Component,
args: { // β optional
count: 5,
color: "red"
}
}
ChoiceLeaf
A ChoiceLeaf can be an array of ChoiceObjects or a function that returns an array of ChoiceObjects.
// ChoiceLeaf
[
// ChoiceObject
// ChoiceObject
]
// ChoiceLeaf
() => [
// ChoiceObject
// ChoiceObject
]
ChoiceObject
Prop | Type | Required |
---|---|---|
label | string |
β |
text | string |
β |
next | BranchKey | Branch<BranchKey, CharacterKey> | (() => BranchKey) |
β |
titleTag | string | () => string |
|
disabled | boolean | () => boolean |
{
/** REQUIRED */
label: "YES",
text: "I think that's right",
next: "yesBranch"
/** OPTIONAL */
titleTag: "some title"
disabled: true
}
ChoiceObject.label
label
is the text that will appear on the choice button.
{
// code
label: "YES",
}
ChoiceObject.text
text
is the content that will appear on the dialogue after choice is made.
{
// code
text: "I think so.",
}
ChoiceObject.next
next
is the key of the branch dialogue will jump to. You can use next
in three (3) different ways:
- 1.BranchKey
- 2.A function that returns a BranchKey
- 3.A nested branch
// (1) A BranchKey (string)
{
// code
next: "yesBranch"
}
// (2) A function that returns a BranchKey
{
// code
next: () => "yesBranch"
}
// (3) A nested branch
{
// code
next: [
"Great! Let's go bowling."
"How would you like to go?"
[
{
label: "π",
text: "How about we take your Honda?",
next: [
"Oh, it's actually broken. We can take a cab though."
]
},
{
label: "πΆββοΈ",
text: "It's not that far, we can walk.",
next: [
"Sure!"
"Would you like to race?"
[
{
label: "YES",
text: "I don't know. ** You start running **",
next: [
"** You win **"
// Nesting can go forever
]
},
{
label: "No",
text: "Nah, I don't feel like it.",
next: [
"** You don't race **"
// Nesting can go forever
]
}
]
]
},
{
label: "Cancel the date",
text: "You know what? I forgot I had some things to do.",
next: "cancelBranch"
},
]
]
}
ChoiceObject.titleTag
titleTag
is the title that will appear when a mouse is hovered over the choice button. It can be a string or a function that returns a string.
// a string
{
// code
titleTag: "some title",
}
// or a function that returns a string
{
// code
titleTag: () => Math.random() < 0.5 ? "Not enough." : "Good enough.",
}
ChoiceObject.disabled
disabled
determines whether the choice button is disabled or not. Can be boolean or a function that returns a boolean.
// boolean
{
// code
disabled: true,
}
// or a function that returns a boolean
{
// code
disabled: () => Math.random() < 0.5,
}
PROPS
Name | Type | Value | Description |
---|---|---|---|
tree Required | object |
- | Pass the DialogueTree object. |
characters | object |
{} | Pass the CharacterCollection object. |
containerClass | string |
sdt-container | Provide classes for the container of Dialogue component. |
choiceContainerClass | string |
sdt-choice-container | Provide classes for the container of choices. |
choiceClass | string |
sdt-choice | Provide classes for individual choice buttons. |
npcContainerClass | string |
sdt-npc-container | Provide classes for the container of npcText and charContainer. |
npcTextClass | string |
sdt-npc | Provide classes for NPC replies. |
charContainerClass | string |
sdt-char-container | Provide classes for the container of charName and charAvatar |
charNameClass | string |
sdt-char-name | Provide classes for NPC names. |
charAvatarClass | string |
sdt-char-avatar | Provide classes for NPC avatars (<img> element). |
playerTextClass | string |
sdt-player | Provide classes for player replies. |
narrationClass | string |
sdt-narration | Provide classes for narration texts. |
jumperClass | string |
sdt-jumper | Provide classes for the jumper. Jumper appears when the dialogue is scrolled up. |
jumperText | string |
JUMP TO BOTTOM | The text that will appear on jumper button. |
npcIn | Function |
fly | Provide intro functions for npc replies. |
npcInOptions | object |
{ x: -200 } | Provide options object for the npc intro function. |
playerIn | Function |
fly | Provide intro functions for player replies. |
playerInOptions | object |
{ x: 200 } | Provide options object for the player intro function. |
choiceIn | Function |
scale | Provide intro functions for choice buttons. |
choiceInOptions | object |
{} | Provide options object for the choice button intro function. |
choiceStaggerGap | number |
200 | Provide a number in ms for staggering button intro function. |
narrationIn | Function |
scale | Provide intro functions for narration texts. |
narrationInOptions | object |
{} | Provide options object for the narration text intro function. |
nextLineKey | string |
Space | Provide an event code to trigger next line. |
LAYOUT
EVENTS
Name | Detail | Description |
---|---|---|
dialogueEnd | - | Fires when dialogue has ended. |
componentEvent | user defined | Fires when a component dispatches componentEvent. |
componentEnd | user defined | Fires when a component dispatches componentEnd. If a component enters the Dialogue, Dialogue will not continue until this event is fired. |
BINDINGS
You can call nextLine
by binding the Dialogue component to a variable.
<script>
import { Dialogue } from 'svelte-dialogue-tree';
const tree = {
start: ['hello', 'world', 'what', 'is', 'up']
};
let dialogueComponent;
function nextLine() {
dialogueComponent.nextLine();
}
</script>
<Dialogue {tree} bind:this={dialogueComponent} />
<button class="..." on:click={nextLine}>NEXT LINE</button>
NARRATION
You can use narration to convey information as a third person. Wrap the content in double asterisk (**) to render it as a narration text.
TIP: You can include multiple narration texts inside a string. They will be rendered seperately.
const tree = {
start: [
'** You wake up near a cliff. **',
{
text: '** You panic and fall from the cliff. ** npc text',
onSpawn: () => console.log("fell from cliff")
},
'** narration ** npc text ** narration **'
]
};
TextObject.character information will not be rendered if TextObject.text is inside double asterisks.