Technical Tools for Authoring Branching Dialogue

[Music] before we get started we'll introduce ourselves i'm carrie patel i'm a senior narrative designer and writer at obsidian entertainment and i'm dave simcheck i'm the tech director for our tools team and today we're going to talk about the key features of conversation editors that can aid in the creation of branching dialogue our main reference point here will be obsidian entertainment incorporated tools which we refer to as oei tools which dave and his team have iterated on for years for the purposes of helping us better create branching dialogue our hope is that you'll leave this talk with a better understanding of how good software can facilitate both the creative and the technical work of authoring branching dialogue and that you can use that information to either guide in the development of your own in-house tools or to seek out third party options there are plenty of alternatives to microsoft excel and our goal is to encourage developers to build or seek out

more robust options so what is branching dialog simply put it's dialog that does not follow a single linear path this is a screenshot from oei tools we'll get into specific features over the course of the talk but here you can see the dialog tree in the main editor window which is made up of dialog nodes that we can individually write and edit and on the right hand side of the screen panes to set properties and scripts which can allow us to fine-tune the behavior of individual nodes and branches now why is branching dialogue important that's a talk all of its own but suffice to say that it allows us to build stories that are reactive and player driven and it allows players to drive the flow of conversations and to define their characters in those conversations we've used some version of this conversation editor for over eight years to ship titles including dungeon siege iii the pillars of eternity games

south park the stick of truth tyranny and our upcoming rpg the outer worlds while you can see that the presentation of dialogue varies between games all of them require some level of branching and the conversation editor allows us to build that structure without further ado let's get into how the conversation editor allows us to turn a dialogue tree like this into a conversation like this so the conversation you see on the left is part of a file from deadfire with a character named zuhira and the video that's playing on the right shows the highlighted path of that conversation playing in game now you can see the editor's strengths are not only that it optimizes the creation of dialogue but also that it helps us integrate the presentation of that dialogue in game so for the first part of the talk i'll discuss how narrative designers and writers

use the conversation editor to structure dialogues to quickly write and revise dialogue text and to script the flow of a conversation and for the second part dave will cover the conversation debugger and the script tracker which are two of the tools department's most recent innovations the first thing the conversation editor allows us to do is create a conversation structure and here i'm going to show you an example of what it looks like to create a very short simple dialogue tree in our tools so here i hit insert and that automatically creates a talk node i can quickly add in some placeholder text right click drop down and i can place three player response nodes quickly writing some placeholder text that someone can come by and do a better job of later i'm selecting the top insert again and

there's another talk node write some text correct my typo and now by holding ctrl and dragging i can link that node to other branches in this file so for the purposes of our examples this is a simplified version of the zuhira dialog you saw earlier it's what we refer to as a stub the conversation editor builds trees out of different kinds of nodes and as you could see oei tools automatically spaces these nodes for us and builds from left to right and top to bottom which makes the creation of a dialog tree very fast and easy now this sounds like a small thing unless you've worked with a tool that looks more like this this is an example flowchart from godiagram which is the foundational software of our conversation editor the size spacing and flow of nodes is chaotic and managing them becomes a chore for the developer it's an annoyance for a small file like this but the problem gets a lot messier

when you consider a dialogue of 100 nodes or more a structure like this in which the designer need only adjust the ordering of nodes allows designers to quickly create dialogue trees and for other designers to understand the size complexity and flow of a conversation at a glance this makes it a lot easier to both create dialogues and to pass them between designers which is often crucial on larger teams this also helps designers diagnose potential problems with a dialogue at a glance this can include long stretches of the npc talking at the player moments where we're branching too widely or moments where we aren't offering enough player dialogue options so to understand how the conversation editor helps us structure a dialogue let's quickly look at the types of nodes designers can place talk nodes are the most common these are for npcs each talk node is assigned a speaker and

that's the npc saying the line and a listener which is usually the player player responses are dialog options for the player character you can include as many or as few as you'd like depending on the role-playing experience you're offering and also on the limitations of your in-game dialogue display you can also link nodes talk nodes and player nodes to other parts of the conversation the faded nodes you see here are all linked and they'll preserve the same text and scripting as their originals this allows us to funnel the player to a central branch from any number of alternate dialogue paths for instance in this stub example we're giving the player three options to greet the npc but we still want to guide the player back to the critical path of the conversation so that the npc can deliver key quest information similarly we may choose to link a player response to another point in the conversation as we've done at the end of this stub this allows us to account for different

paths the conversation might take possibly due to the presence of a companion as in this example or to the state of a quest while preserving the player's ability to pursue key topics linked nodes allow us to create large branching reactive conversations much more cleanly and readably than if we had to depend on following flowchart arrows across the screen as in the go diagram example you saw and all of this means that any designer with a knowledge of our conversation editor can set up a working draft of a conversation to progress and iterate on content and also that a designer can understand the scope and flow of a conversation before the final writing is in the second key feature of the conversation editor is that it's easy to author and edit texts directly in the dialog nodes and this is beneficial for a couple of reasons the first and most obvious is workflow because we don't have to write dialogue in a separate interface and then port it into the conversation

editor this simplifies our work process which is especially critical when we get to the stage where we're making numerous small edits and revisions changes can be made quickly and easily which means we can fix bugs faster and get from first to final draft more efficiently the other advantage is that the writer is working in a structure that closely mirrors what the player will experience in game so it's easier to keep tabs on the scope and pacing of your dialog you can see when a particular node is getting wordy and revised as needed and as you're writing you can see the content of your node next to the nodes that proceed and follow it to help you maintain a smooth flow especially in situations where you may have several different nodes funneling back to one compare that interface with this which is from an older version of our conversation editor you have to open a separate window to edit node text which again may seem like a small thing until you're doing this across dozens or even hundreds of nodes

within a conversation and thousands across an entire project so what are the features that make it easy to write and edit the first is this convenient text box it feels like a simple but functional word processor which is what most writers are used to conversation files and individual nodes are protected through source control which helps prevent developers from overwriting each other's work you have to check out a node's text but once you do you can write an edit just by clicking it you can select copy and paste blocks of text and you can use keyboard shortcuts to quickly exit out of editing mode it even has a spell check feature the point is it feels a lot like writing in a small word processor so it's relatively easy for writers to adapt to it the editor also has a zoomable interface you can get as close to nodes as you need to read them clearly and then you can zoom out as far as you need to see them to see their placement in the greater node structure

the conversation editor also has a collapsible hierarchy you can hide and expand all of the child nodes that follow a particular node to focus on the part of the structure you're writing so in the example i'm going to show you here i want to see how well the three nodes near the center of the screen that are vertically spaced flow from their parent node however the number and positioning of those child nodes makes it hard for me to read these all together so let's see what it looks like to collapse these in the editor i'm just going to scroll down a little bit and zoom in click a button in the corner there and it collapses those child nodes do it two more times now all of these nodes are close together i can zoom in read them together and see how well they flow once i'm done i can easily click the same spot and expand everything again to restore the original structure

the editor also makes navigation very easy you can move around the file with scroll bars and with clicking and dragging and if you want to find something specific there are keyboard shortcuts to find nodes based on a text search or to jump to a specific node number finally the conversation editor allows designers and writers to integrate scripting directly in the dialog tree now if a dialog tree is a network of conversational roads then conditional scripting is what allows designers to regulate the flow of traffic between those roads without conditional scripts many of our conversation branches would be useless because there would be no way to set one branch to play instead of another in the example pictured here we have three different branches that can play depending on the background and chosen skills of the player character specifically a character with the mercenary background or with a decently high insight score can observe additional information about

a battle-fatigued soldier so here's a video of what it looks like to add these scripts in the editor 309 i'm going to search for the isbackground conditional script which is highlighted here this lets me look at the background the player might have chosen for their character i'm going to select the mercenary option from this list and then for 308 i'm going to search for the is skill value conditional script which as you can see i can also find by typing in the search box this lets me check the value of different skills the player might have picking insight from that list and then i'm inputting a value of 3 here alongside the other parameters and the operator is already set to greater than or equal to but i could adjust that if i wanted to so based on the order of these nodes if the player chose the mercenary background for their character 309 will always play because it's on top

if the player did not choose the mercenary background for their character but has an insight value of 3 or greater than 308 will always play and if neither of these conditions are true then 318 will play and the player will get no additional information about the npc they're talking to we can also connect multiple conditional scripts with and and or operators and we can even nest these scripts giving us an incredible level of control over the possible game states we're checking in terms of the player experience these scripting functionalities allow us to implement reactivity to choices the player has made in the game and to events that have occurred this facilitates our ability to cleanly progress and branch content and as you can see from the list in the middle of the window there are a lot of different conditional scripts we can use some of the most common include checking to see if a particular conversation note has already been played checking for the presence of a

particular companion checking a custom game variable three of those are pictured here checking quest status and checking the player's skills as you saw a moment ago now the conditional scripts we just looked at will control the flow of branching by determining which nodes can play but we can also set other scripts that activate certain in-game behaviors and game states this includes setting global variables and updating the player's journal giving or removing items and money from the player and adjusting reputation and disposition values to name just a few and once again as you can see from that window there's a lot we can do it's incredibly useful to be able to set these scripts within the conversation editor it allows the player's conversations to have meaningful impacts that are reflected in the rest of the game which is one of the key goals of reacted reactive dialogue in story driven games and now i'm going

to hand it over to dave who can tell you about some of the exciting features our programming team has recently added to the editor hey everyone i'm the programmer that worked on the conversation editor and do you know what question i get most often from our writers why doesn't my conversation work so here's what usually happens a writer plays the game and their conversation isn't behaving as expected they look at a complicated flow chart and everything appears to be fine so they find a programmer and ask for help the programmer uses visual studio to try to figure out which what's going on and this can take up to an hour to set up and profile this is very frustrating to the writer and it can make them feel helpless this is also time consuming to the programmer who has their own

tasks to work on so our solution was to create a conversation debugger the conversation debugger communicates with unity or unreal using a udp listener it automatically attaches to the game when it's opened and provides users with a ton of useful information about the current conversation it shows which conversation is playing and what's the current node it shows the current state of all nodes in the conversation has it not been previously visited does the node pass all of its conditions if a node doesn't pass its conditions the user can click on the node and see the result of each individual script call on that node the live values for all global variables in the conversation are displayed here all of this data is updated in real time as the conversation plays users can even manipulate the conversation through the debugger

users can jump to any node in the conversation at any time they can change global variables in the debugger and have them updated in the game in this example a writer is expecting four player responses to appear but only two are showing up we can see that two of the nodes aren't passing their conditions a deeper look shows that a script is checking if a global variable is set to four but it's currently set to zero so the user is going to update the global variable value and go back a node and now all four player responses are showing up so there appears to be a scripting problem in the game where a global

variable is not being updated correctly so using these tools writers can usually figure out what's wrong with their conversation and don't need to go to a programmer for help one inch one issue with branching dialogues is there a lot of possible player builds to test and we wanted a way to quickly test these builds without generating save games or having to restart the game so we do this with profiles a writer can quickly set up a character to simulate gender race class stats skills and who is in the party profiles can be saved and loaded on the fly allowing users to quickly test various branches of their conversation in this example we're going to load a fighter profile and we're going to take a look at the fighter's intellect stat which is currently set to five when we play the conversation we get a

fighter specific line but one of the player responses is disabled because we failed the intellect check of 12. we're now going to load a wizard profile and you can see that the wizard has an intellect stat of 14. we'll go back a node and now we get a wizard specific line and the player response is enabled because we passed the intellect check another issue that arises is when we have play days where everyone on the team plays the game for a day if a non-writer is playing the game and something unexpected happens they'll go and grab a writer and show them what's happening the writer will ask what were all the choices you made leading up to this point and the usual response is i don't know

it's like i don't remember what i did so this is a crucial piece of information that's needed to track down the issue so what we can do is we can open the conversation debugger and we can go to the history pane there the writer can see the exact play order of each node they can copy the history to the clipboard or they can save that data to a file so this has been really useful for helping reproduce bugs now i'd like to talk about branching balance we've seen that player responses can be conditionalized by skill checks it's very important that we have about the same number of skill checks for each stat type otherwise certain skills become more valuable than others if a player gets more dialogue choices for investing in skill a than skill b then players who invested in skill b will feel like they made a mistake with their choices so how do we figure out how many times each stat is used in the game pillars of eternity had over 1200

conversations and over 25 000 nodes of dialogue so it's not practical for someone to open up every file and check every node so instead i wrote a script tracking tool it parses every conversation in the game and gathers every script call from every node in the scripts pane users can see each script type in the game and how many times it's used in this case we're looking at a skill value comparison call which is being used 1646 times here we can see every individual skill check call in the game there are columns for the file the call is made in the node id and each parameter passed in double-clicking one of these calls will open the conversation editor and select the node calling the script there's also a set of filter controls here we can force the tool to only show scripts with certain parameter values here we are specifically looking for

skill checks referencing their survival skill this limits the display to only calls with survival as the second parameter so now we can see that our 112 survival skill checks in the game in about five minutes our game director was able to account for all stat skill and ability checks in the game so he could make a balanced pass so one additional benefit of the script tracker was i was able to validate every script call here we can see all the scripting errors currently in the game these usually come from game objects or global variables being deleted but are still referenced in scripts there is a repair feature to correct the scripting errors without having to open the conversation file so if your studio is using notepad or using excel to write branching conversations i highly recommend moving towards a flowchart based authoring tool if you don't have the resources to create your own there are some good third-party tools available such as chat mapper and articy

so i'd like to thank everybody for coming today and if you have any questions you can come to the microphone and again thank you very much [Applause] yes hi um so i was really struck by the contrast between the diagram the the go diagram i think you said it was and the main diagram you've been exhibiting here uh it was clear that the go diagram was a mess and this one wasn't but i wasn't exactly sure why it wasn't it seemed like the main thing that was different was that in this tool when you have two when you have two nodes that link to the same place in go the arrows would cross and that's what's going to make the mess but here the nodes would be duplicated would they be completely duplicated including all of their children um yeah they would be well they wouldn't be duplicated

they would just point to each other so if you had two nodes referencing the same node there would just be an arrow pointing to the exact same node which could be across the entire conversation with the way that we're doing it is we just have one single node and that points you can make a reference to that other node and you'll see it in the tool as a grayed out version of that node and so is that there was like one of the slides had an example of this i didn't look great out was it grayed out it was it's just a little bit more faded than the others and a lot of these visuals you can adjust in the tool if there's something that's easier for you to see but yeah if you if you double click one of those slightly faded nodes it will take you to the original node in its place in the conversation and you can follow from there to see where that note branches okay so i see i i think i didn't see the fadedness so in fact that reference is that reference the key thing that makes this diagram readable as well as collapsing children

those are the two yes right thank you okay hi uh our company is working on an authoring tool it's not just for conversations for controlling game objects in the world and i'm an engineer when you said that like you know companies should move to flow chart or flow based conversation authoring i totally agree with you i mean i totally understand you because i'm an engineer but don't you think that a writer who might come from like a movie uh like you know film background or like books background would be more familiar with like writing scripts for movies like you know just linear white page i mean that is you know speaking as a writer who had a background in novels and short fiction for branching i really like a tool like this we

actually have a feature in our conversation editor where you can export any dialogue file into a traditional screenplay format but following the progress of that branching dialogue through basically pages of microsoft word becomes very tedious it's very easy to lose the flow of the conversation because you have to you know jump from one node to back where that's continued elsewhere this just makes it a lot easier to visualize the structure and flow of that conversation uh in a way that's easy to see without having to jump around i mean i wouldn't write a linear novel in this format but for a branching dialogue i think it's very easy to use um and how like so if a writer that's not really familiar with software development how long do you think that like this person would like no need to get used to this set

i don't think it takes that long because at the very least all you even if you don't want to get into the scripting yourself all you really have to know how to do is add nodes and the talk nodes and the player response nodes are the two main kinds you're going to use so once you know how to add those and just how to move them around the file you can write in those nodes and then i think the challenge is really just getting a better sense for how something feels in the flow chart versus how it feels in the actual game but that's an issue anyone has to conquer by playing their content uh one final question is this tool available uh it is currently not available all right thanks hi um i was wondering uh when you were mentioning the variables like is background or is intellect um i'm not sure if if this just i wanted to confirm is that something that is since you work on a lot of

different types of games with the narrative in inside of it um is that can you change the variables or add new variables within the tool or is that something that gets separated out into outside of the tool itself uh so so all of the scripts are actually authored by programmers inside the game so we have a script class uh where we can make static functions and put attributes on them to to allow them to be displayed properly in the tool and that's for each game is going to be different and so for a unity based game we'll load up the assembly dll uh use reflection and get all that data from the game and get the exact same uh information that's in the game into the tool in an easy to see ui for unreal they have a similar thing but we do have to do an export where we have to use their blueprints uh exporter and get all that information and that's how we get our scripts into the game thanks uh

yeah i was curious if there were any organizational or like process barriers to getting some of your tools prioritized for development um i'm coming from a place where um i'm being tasked to sort of envision the future of authoring tools for our company and i wondered if you could speak to like making the business case because i thought it was really interesting how your tools went through multiple iterations like they seem quite different and i was wondering if you could speak to that at all so this really started when we worked on neverwinter nights 2 and we used their conversation editor which is pretty much a tree view where you just have nested uh just nested pluses and minuses and if you have 100 nodes or whatever in there it's just very difficult to use and see the flow for and so our like from the top we recognize that this was not a good workflow for making games with a million words in it that we needed a faster way to to author dialogues and

so the from the top down we recognized that and wanted to go and we have time for one more question from each microphone yay hey you're great uh so quick question for you as an engineer what was the engineering resource cost of making this tool in terms of time uh in terms of time we've been iterating on it for probably about 10 years but if i were to make it uh from scratch knowing all the the lessons that we've learned it'd probably take one person probably about four months to do okay thanks okay um first off when you were showing some of the play test footage um was it actually like an engine play testing where you were able to work on the dialogue then see what it looks like in engine uh so there's two separate applications running so the game is running and then the tool is a separate application that's also running uh but they're they're using a messaging system to talk to each other okay so like how long does the import export and what's the functions like to sort of get those things connected

um so we just use a c-sharp udp listener where we specify an exact port and so the designer doesn't have to do anything so we're automatically doing the connection behind the scenes so whenever we start up the tool we send a message looking if the game's running and the same thing with the game that's always looking at the conversation editors running and will sync up things automatically that's really cool thank you and if anyone has other questions we can move to the wrap-up room to address them there thanks