# How Narrative Works In NarrativeFlow <a href="https://www.youtube.com/watch?v=4mDk_p6UUao" target="_blank"> <img src="https://narrativeflow.dev/DocsImages/Walkthrough%20Part%201%20Video%20Thumbnail.webp" alt="Walkthrough Part 1 Video Thumbnail"> </a> In NarrativeFlow, video game narrative is designed as Nodes connected together with links. This is called a narrative chain. Narrative chains can be organized into Experiences. For example, you could have a separate Experience for the conversations for each character in your game. Or perhaps your narrative could be organized into chapters or parts, with each part having its own Experience. Let's start by creating an Experience. > [!tip] What is an Experience? > **An Experience is simply a container, a way to group your Nodes.** > > An Experience could contain the conversations with a specific character, a branching interaction with a computer terminal, all the dialogue for a particular chapter or quest, etc. > > You can create unlimited Nodes per Experience. ## Creating Your First Experience First, make sure the "Experiences" tab in the Left Panel is selected. Now, you can simply click the "New Experience" button. You can also right-click your project's name or the blank area below that, then click "New Experience..." in the context menu. Then give your new Experience a name and click "Create Experience" (or hit Enter on your keyboard). Every Experience must have a unique, non-blank name. Once your new Experience has been created, it will show up as an item in the Experiences Left Panel tab. > [!tip] > The top-most item, the 'root', represents your project as a whole. Right-click this item and click the "rename" option to rename your project to whatever you'd like. Now, we need to open our new Experience in the main workspace. You can double-click any Experience in the Experiences Left Panel tab at any time to open that Experience in the main workspace. Open your new Experience by double-clicking it, and let's start creating some narrative! ## How To Create Narrative Chains While narrative chains can be a simple, linear series of Nodes, narrative chains can also have unlimited branches, loops, and extensively sophisticated webs of dynamic routes. Whether you want to create a simple linear narrative or a massive intertwined one, all narrative chains in NarrativeFlow follow a basic structure. ![[01 - Nodes.webp]] In the screenshot above, we have a Start Node linked to a Dialog Node, which is linked to an End Node. Every Experience must contain at least one Start and End Node. Let's create the Start Node first. Simply right-click anywhere in the workspace. This opens a context menu that allows you to choose which Node you'd like to create, as well as two options for selecting or pasting Nodes. We just need to create a Start Node, so select that option from the list. This will create a Start Node in your Experience. Start Nodes are the "entry point" for your Experience. Without them, your game engine won't know where a narrative chain starts. Let's create an End Node now. Just like we did with the Start Node, right-click in the workspace and click "Create End Node" in the context menu. You can also click the "Create Node" button in the toolbar above the main workspace to open the same context menu. End Nodes signal to your game engine that the current narrative chain has, well, ended, so it can react however you need it to. For example, many games will use a specific camera angle or lock movement during cutscenes or dialogue between characters. The End Node signals to your game engine that the end of the narrative chain was reached, so it knows to return to the regular camera angle and unlock character movement. Technically, if you linked the Start Node to the End Node, that would be a completely valid chain and wouldn't trigger any errors or warnings. And while there could be some uses for that, you'll almost always want some narrative content in your chain, right? Let's add some now. ## Dialog and Choice Nodes - Your Narrative Content In video games, narrative can almost always be categorized as either of the following: - Text to displayed to the player - Choices presented to the player for them to select options from Of course, narrative is much more than just text. Many games have voice-over and other audio, and some games will even tell a story without any words at all. And while you can definitely design narrative of those styles in NarrativeFlow, most narrative is text-based, even if just as subtitles or a simple dialogue box. This is where Dialog and Choice Nodes come in. --- ### Dialog Nodes ![[02 - Dialog Node.webp]] Dialog Nodes are where you write text that can be presented to the player in any way you define in your game engine. For example, if you're designing a retro RPG (i.e. Sea of Stars), Dialog Nodes are where you write the text that will be displayed in dialogue boxes when talking to characters. Or perhaps you simply need subtitles for your game to be displayed when VO files play during cutscenes. Dialog Nodes have you covered there as well. > [!question] > **Dialog vs. Dialogue.** > > Why is the term "Dialog" is used in NarrativeFlow instead of "Dialogue"? > > It's because NarrativeFlow is for designing ALL narrative and text-based information, not just conversations between characters. > > For example, say a character is reading information on a computer or in a book. Or perhaps you design a narrative chain that displays a tutorial to the player. > > Those are cases where the player is interacting with non-conversation (i.e. non-dialogue) narrative, but is interacting with the game's world and interface (i.e. a dialog). > > Put simply, "dialog" encompasses all text-based narrative and information, matching NarrativeFlow's powerful capabilities (which is much more than just text-based), while "dialogue" usually only represents conversations. ### Choice Nodes ![[03 - Choice Node.webp]] Whenever you want to present the player with one or more choices for them to select from, the Choice Node is what you want. For example, let's say you want to present the player with one or more choices of different reactions to something another character just said (Disco Elysium, Oxenfree, Divinity, etc.). Choice Nodes were designed to make this easy. > [!NOTE] > Choice Nodes aren't limited to just dialogue choices. > > You get to define in your game engine how your choices are presented to your players and how the player interacts with them. --- Let's create both a Dialog and Choice Node now. Once again, simply right-click the workspace and click Dialog Node, then repeat for a Choice Node. Now, let's link them together into a chain. Do you see the yellow circles on the left/right of the Nodes? These are the input and output pins for links. Left-click the Start Node's output pin and drag the link to the Dialog Node's input pin, then release the left mouse button. This will link the Start Node to your Dialog Node. Now connect your Dialog Node to your Choice Node, and your Choice Node to your End Node. Ta da! You've successfully created a narrative chain! There are a few things we need to do though before the narrative chain is valid. Our Start Node needs a name and the Dialog and Choice Nodes need some text. Let's solve that now. ## Editing Nodes Let's learn how to edit the content and attributes of our Nodes. With the exception of the Connector and Comment Nodes, all Nodes can be edited by clicking the "Edit" button in the top-right of the Node. ![[04 - Edit Node Button.webp]] Let's start by adding some text to our Dialog Node. Simply click the "Edit" button on that Node. When you do, the Node Editor will open up. ![[05 - Dialog Node Editor.webp]] > [!tip] > For a full overview of how the Node Editor works and how to edit all Node types, be sure to go here: [[Node Editor]]. Let's fill in the Dialog Source and Dialog fields with whatever we feel like. When you're satisfied with your edits, simply click the "Done" button in the top-right of the Node Editor to save your changes and close the editor. Now let's add some text to our Choice Node, as well as a second choice option. Click the "Edit" button in the top-right of the Choice Node to open it in the Node Editor. ![[06 - Choice Node Editor.webp]] First, let's add a second choice by clicking the "Add Choice" that's directly underneath our existing choice. All we need to do is fill in both choices with text and click Done to save our changes and close the Node Editor. You can put whatever you want into each choice field. For the walkthrough, I'll write A in the first and B in the second. Now that our Choice Node has two choices, you'll see that it has two outputs, one for each choice. The first choice is still connected to our End Node, so we just need to make sure our second choice gets connected to something. Let's just connect the second choice to the End Node as well. That last thing we need to do for our narrative chain to be valid is to give our Start Node a unique name. Let's open our Start Node in the Node Editor. ![[07 - Start Node Editor.webp]] Every Start Node must have a unique name. This name is what you'll use to tell your game engine where to start this narrative chain. For example, if this narrative chain were for a first-time meeting between the player and a character, you could use a name like "First Time Meeting Evelyn". Or if your narrative chain were for dialog between you and a guard standing at the gates to a city, you could use a name like "Royal City Gate Guard". Give your Start Node whatever name you want and click the "Done" button. Congratulations! You now have a valid narrative chain. Next, let's discover other essential Node types and how they help you craft the best narrative possible! ## Variable, Conditional, and Teleport Node Types Now that you know the basics of designing narrative and choices within NarrativeFlow, let's talk about how create branches/routes within your narrative based on specific conditions. NarrativeFlow makes dynamic narrative easy with the Choice, Variable, and Conditional Node types (there's also the Probability Node type which you'll learn about in [part 2](Part%202%20-%20Beyond%20Basics%20-%20Quicker,%20Easier,%20Organized%20Narrative%20Design.md)!). You've already learned what the Choice Node type does, so next, let's talk about how to track choices (or anything else) with Variables. ### Variables Modal To track/store state (i.e. the current value, status, configuration, or situation of something), we need a container for that value. That container is known as a variable. A variable stores values for us which can be retrieved, referenced, or changed at any time however we want. For example, you may have a variable for the player's reputation with a city, characters' opinions of the player, a speech skill or charisma, etc. Or perhaps you want to track what decisions the player has made throughout their playthrough and have your narrative react to that. If this is starting to sound like programming, there are some similarities in NarrativeFlow, for sure, yet it's nowhere near as complex or confusing, so don't worry. In NarrativeFlow, we create Variables (containers that store values) in the Variables Modal. Let's open the Variables Modal now by clicking the "Variables" button in the Menu Bar across the top of NarrativeFlow. ![[08 - The Variables Modal.webp]] Here's the Variables Modal. We haven't defined any variables yet, so there's not much going on here right now. In NarrativeFlow, variables are organized into groups. Since many larger games/dynamic narratives have hundreds of variables, we organize them in groups for clarity and ease. Let's create your first group by clicking the "New Variable Group" button in the top-left of the modal. There's already a blank variable definition created for us when we created the new group. Let's define our first variable! Remember how we gave our Choice Node two choices? Let's set up a variable to track which choice the player made: A or B. First, we need to give our variable definition a label. This is the text/label that you'll click on when you want to insert this variable into a field. Don't worry, I'll explain what that means later on. Since we're going to track whether the player selected the A or B choice, let's fill in the label field with `Did Player Choose A or B?` Now, we need to give our variable definition an identifier (it's name). Let's give it the identifier `[DidPlayerChooseAorB]` The identifier is the exact text that represents your variable. When this text is inserted into a field, NarrativeFlow (and therefore your game engine) will see that text as a variable and will replace it with the value that it contains at that time. Because of this, it's usually best to wrap variable identifiers in some kind of bracket like this: `[DidPlayerChooseAorB]` Once again, if none of that made sense, don't worry. I'll show you how it all works after we finish defining our variable. Next, we need to give our variable a default value. This can safely be left blank if you want. For our example, let's give it a default value of `Neither`. ![[09 - Variable Definitions.webp]] Awesome! You've created and defined your first variable! With that, simply click the "Done" button in the top-right of the Variables Modal to close it. Now let's use that variable in a Variable Node to track which choice the player selects. ### Variable Nodes First, create a Variable Node (remember, simply right-click the workspace and select "Create Variable Node" in the context menu). We're going to use this first Variable Node to track if the player chooses the first choice, so let's link the output for the first choice to the input of the Variable Node. Then, open the Variable Node in the Node Editor by clicking the Edit button in the top-right of the Variable Node. ![[10 - Variable Node Editor.webp]] Variable Nodes contain one assignment by default, but we can add however many you need. For our example, we only need the existing assignment. Assignments have three parts: The assignment type, the variable, and the value. The assignment type determines how the value currently contained within the variable will be affected. For example, if we use the assignment type of `+`, we'll add what's in the value field to the value contained within the variable. In our example, we want to track that the player selected the first choice, choice A. So let's add the variable we just created in the Variables Modal to the variable field. NarrativeFlow makes this pretty easy for you, so you don't have to manually type out variable names everywhere. First, left-click in the variable field. Then, click on the "Insert Variable" button in the top-left of the Node Editor. When you click the "Insert Variable" button, you'll see a popup that lists all the variables you've defined in the Variables Modal (in our case just the one) organized by their group. Now, simply click on the label (remember how we gave our variable definition a label? This is where it's used) of the variable you want to insert, and it will be instantly inserted into the variable field in the Node Editor exactly where your cursor was! All we need to do now is make sure the Assignment Type is `=` and to put `A` into our value field. Then, click "Done" in the top-right of the Node Editor. Next, make sure the first choice's output of our Choice Node links to the input of the Variable Node we just created. Then, connect the output of the Variable Node to the End Node. We now have our first Variable Node ready to go! Now use all you've learned to create the next Variable Node to track if the player selects the second choice. The only two differences between what we just did and the next Variable Node is that you'll put `B` in the value field and you'll also link the second choice's output to the second Variable Node. Congratulations, you now know the basics of tracking state, values, choices, and more! Next, let's discover how to use variables to dynamically change how and where your narrative flows with Conditional Nodes. ### Conditional Nodes Conditional Nodes allow you to compare variables against values or even other variables and dynamically change the route your narrative chain takes based on those comparisons. Let's continue with the example we used for Variable Nodes. Elsewhere in our narrative, we'll take a different route based on if the player selected the first or the second choice of our Choice Node. First, we need "somewhere else" in the narrative to create branches in. You can, of course, check the variable anywhere, including within the same Experience. Yet for the sake of learning and experimenting, let's create a new experience to represent a different part of our narrative and conditionally branch our narrative chain based on our variable. > [!tip] > Remember how to create and open an Experience? If not, don't worry. > > Here's a quick refresher: Make sure the "Experiences" tab is selected in the Left Panel and click the "New Experience" button near the top of the tab. > > Give your new Experience a name and click "Create". > > Then, simply double-click your new Experience that was created in the "Experience Tree" in the Left Panel to open it in the main workspace. Now that we have a new Experience, we need to make sure that it has at least one Start and End Node, and to give our Start Node a unique name. So go ahead and do that now. Now we're ready to create our Conditional Node and edit it. Go ahead and create a Conditional Node and then open it in the Node Editor. ![[11 - Conditional Node Editor.webp]] Conditional Nodes are organized into routes, with each route containing any number of comparisons to check if that route should be taken by the narrative flow. Let's fill out the fields first, and then I'll explain what each element means. We want to check what the current value is of our `[DidPlayerChooseAorB]` variable, so insert that variable into the variable field (the first one to the right of "Is"). Next, put "A" into the value field (the second field). > [!tip] > For a more detained explanation of how to configure Conditional Nodes and how they work, be sure to check out the [Reference Guide on Conditional Nodes](Node%20Editor.md#Conditional%20Node) Now let's talk about what each element does and how to use it. First, we have a header explaining that this is the first route. Currently, we only have one route. Under the header of each route is a list of all the comparisons that will be checked to see if that route can be taken. In our case, we only have one comparison in our first route. That comparison currently has a Comparison Type of `= Equal to`, which checks if the variable in the variable field, `[DidPlayerChooseAorB]`, currently has a value equal to the value we put in the value field: `A`. I.e. "Is \[DidPlayerChooseAorB] equal to `A`?" When your game engine gets to this Conditional Node, if the above comparison equates to true (i.e. if the variable is currently equal to `A`), then that route is considered valid and will be taken by your narrative's flow. So now we have one route, but we need two: one for if the player selected "A", another for if the player selected "B". Let's click the "Add Route" button to create a second route in our Conditional Node. ![[12 - Conditional Node Editor Two Routes.webp]] Next, simply fill in the comparison of the second route with our variable and `B` in the value field. We're all done configuring our Conditional Node, so click "Done" to close the Node Editor. You can see that our Conditional Node now has three outputs: the first and second routes, and the default route. What is the default route for? Let's talk about that now. Every Conditional Node has a default route. It cannot be removed and must be linked to something. This helps you prevent and catch errors during runtime and react to them gracefully if there was a runtime error. For example, let's say our narrative/game engine got to this Conditional Node before the player had the opportunity to select a choice. Without a default route, our narrative wouldn't have anywhere to go, causing a catastrophic runtime error, and a bad narrative experience for the player. So always make sure to link your default route to a relevant Node. In our case, let's pretend that our narrative intentionally lets us encounter our Conditional Node here before the player has encountered the Choice Node, and that we want the narrative chain to flow in a different branch if that happens. This means, for our example, we'll just simply hook our two routes and the default route to a unique End Node each. So create two more End Nodes and hook all three Conditional Node outputs to their own End Node. If you're confident that you would always have a valid route (i.e. you're confident the default route isn't needed), you could simply just link the default route up to the same destination as one of the main routes. There's nothing wrong with doing that and is completely valid in many cases. Now that we have our Conditional Node ready, let's learn how to seamlessly transition the narrative chain from one Experience into another. ### Teleport Nodes While you have the freedom to organize your narrative into separate Experiences, your narrative chain isn't limited to just the Experience it starts in. With Teleport Nodes, you can "teleport" or "jump" your narrative chain seamlessly between Experiences however and wherever you want. Using our two Experiences as an example, let's connect our narrative chain from our first Experience (the one with the Dialog, Choice, and Variable Nodes) to our second (the one with the Conditional Node). Since we already have a Start Node with a unique name in our second Experience, connecting the two is extremely easy. With the first Experience open (double-click it in the Experience tab in the Left Panel), create a Teleport Node. ![[13 - Teleport Node.webp]] Open the Teleport Node in the Node Editor and you'll see just two attributes to configure. ![[14 - Teleport Node Editor.webp]] The first, "Destination Experience", is which Experience we want to teleport to. Click the drop-down and select our second Experience. The second, "Destination Start Node", is the exact Start Node that the narrative chain will teleport to within the selected Destination Experience. Click the drop-down and select the Start Node we created in our second Experience. Click "Done" to close the Node Editor. Then, connect the output of the Variable Nodes to the Teleport Node we just configured. The End Node can simply be removed now. And you're done! Your game engine will seamlessly "teleport" to the selected Start Node in the second Experience when it encounters this Teleport Node. > [!NOTE] > To learn more about all the Node types in NarrativeFlow, including more than we've talked about in this walkthrough, be sure to read the Reference Guide page about Nodes here: [[Nodes]]. > [!tip] > The Left Panel can be collapsed/expanded at any time by clicking the left-most button in the workspace toolbar, giving you more space to design your narrative and reducing visual distractions. ## How To Use Variables As Dynamic Content We already explored how to use variables in Variable and Conditional Nodes to track and react to state in your narrative. In NarrativeFlow, Variables are so much more powerful than just this though. For example, let's say your game allows the player to choose their own name (think RPGs, Stardew Valley, etc.), and you want to reference the specific name they chose throughout your dialog. In other words, you want other characters to use their name. How do you accomplish this? Without Variables, this would be impossible. Thankfully, accomplishing this in NarrativeFlow is incredibly easy. In addition, NarrativeFlow will automatically parse your variables that are used as dynamic content in real-time and display a representation to you of what your players will see. Using the example above, let's take a look at how to do this in NarrativeFlow! ### Variables In Dialog and Choice Nodes First, we need to create our variable to hold the name the player chooses for their character. Open the Variables Modal and add a new variable definition (you can do this in the same group or in a new one. It's totally up to you how you want to organize things). For the label, let's use `Player's Name`, for the variable identifier, let's use `[PlayersName]`, and for the default value, choose whatever name/value you would like. I'll use `Traveler`. Close the Variables Modal and open your Dialog Node in the Node Editor. Let's say for your dialog field you have the following: "Hello, Player! How are you doing today?" We want to replace "Player" with the variable we just created. So erase "Player" and insert your variable. Remember, you can use the "Insert Variable" button/menu to easily insert variables like this instead of typing them. So now, our dialog field will look like this: `Hello, [PlayersName]! How are you doing today?` When your game engine encounters this dialog, the "\[PlayersName]" variable will be automatically replaced with whatever it's current value is. You may have already noticed that below the dialog field, in the section labeled "Presented Text", the dialog we wrote is displayed, but our variable was replaced with the variable's default value. So here we can see a representation of how the player could see your dialog when its displayed by your game engine: "Hello, Traveler! How are you doing today?" The Presented Text section makes it easy to see dialog without the distractions of variable identifiers and also detect errors in punctuation and variable placement. (Seriously, sometimes it's really easy to forget to place commas after a variable's brackets and other simple errors.) ![[17 - Using Variables As Dynamic Content.webp]] You can also place variables into the Dialog Source field, and your game engine will simply use the current value of the variable at runtime. So if you want your dialog boxes, subtitles, etc. to display the name the player chose, you can simply put `[PlayersName]` in the Dialog Source field. Now let's explore how variables can be used in Variable and Conditional Nodes as values for assignments and comparisons. ### How To Use Variables As Values In Variable/Conditional Nodes Open one of our Variable Nodes in the Node Editor and add a new assignment. In the variable field, you can use whatever you like. This is just an example, so put whatever you want and pretend it's a variable we've defined. For example, I'll use `[PlayersNameDuplicate]`. Then, in the value field, insert our `[PlayersName]` variable. In this case, when your game engine encounters this assignment, the current value of `[PlayersName]` will be parsed (which equals "Traveler" by default in this example) and *that* is what will be assigned to the variable `[PlayersNameDuplicate]`, instead of the text "\[PlayersName]". Next, let's look at how this functionality works for Conditional Nodes. Close the Node Editor and open our Conditional Node instead. Let's just modify our current comparison for the sake of example. Simply erase whatever is in the value field and insert our variable in it's place. So now our comparison looks something like this: Is `[DidPlayerChooseAorB]` = `[PlayersName]` When your game engine encounters this comparison, the value of `[PlayersName]` will be parsed and the current value of that variable is what will be used for the comparison: Is `[DidPlayerChooseAorB]` = `Traveler` ### Using Quick Access To Speed Up Your Workflow While designing your narrative, you'll probably find that there are words, terms, phrases, and snippets of text that you use over and over again. For example, the names of characters, regions, items, etc. NarrativeFlow helps reduce or even eliminate the fatigue and redundancy of this through a feature called Quick Access. Quick Access not only saves your fingers and brain trying to figure out how to type that complex name or term for the 3019th time, but using a feature like this can also help reduce typos and other textual errors. Do you remember how when we defined a variable we could easily insert that variable into fields with just a few clicks, rather than manually typing the variable's identifier over and over again? Quick Access works in pretty much the same way: Simply define a Quick Access item and insert it easily with the Quick Access menu. Let's discover how to do this. First, click the "Quick Access" button in the Menu Bar to open the Quick Access modal. This is where we define our Quick Access items. Just like with variables, Quick Access items are organized into groups. Click the "New Item Group" button in the top-left of the modal. ![[15 - Quick Access Modal.webp]] There are only two fields we need to fill out for Quick Access items. In addition, each item has a Presented Text section to give you a representation of how your player could see the text in case your item contains variables or text styles. For our example, let's define our item as the name of a character: `William Shakespeare`. While I'm certain you're quite capable of typing "William Shakespeare" over and over again, simply clicking twice sounds much quicker and less typo-prone, doesn't it? In our case, we can simply place "William Shakespeare" in both the label and value field and click the "Done" button in the top-right of the Quick Access modal. Let's create a new Dialog Node and open it in the Node Editor. While we can insert a Quick Access item in any field, let's use it to insert a character's name into the Dialog Source field. Simply click in that field, then click on the Quick Access button in the top-left of the Node Editor, then click the "William Shakespeare" item we defined earlier. Ta da! You just saved time and your keyboard's lifespan. Any time you have some text that you find yourself typing repeatedly, consider adding it as a Quick Access item and make your workflow smoother and faster. ### Resolving Problems And Errors Now let's talk about problems, errors, and warnings in NarrativeFlow and how to resolve them. Here, I'm going to talk a bit about how the Problems tab works, how to navigate and interact with it, and we'll walk through how to solve an error that showed up as a result of us creating a new Dialog Node in the last section but never linking it to anything. First, if we're not there already, let's switch to the "Problems" tab in the Left Panel. ![[16 - Problems Tab.webp]] Hopefully, if everything in this walkthrough guide was clear enough (genuinely sorry if it wasn't!), there will only be two errors listed in the Problems tab right now: - This Node has no connections to it - This Node isn't connected to anything For an Experience to be considered "Valid" (ready to be used in your game), all Nodes' inputs must have at least one Node linking to it. Additionally, all Nodes' outputs must link to another Node. An input can have any number of Nodes linking to it. Outputs can only link to one Node. Because you've gotten this far in the walkthrough, I'm pretty sure you've already figured out what you need to do to fix both of these errors: Simply link your Dialog Node somewhere into your chain, with at least one Node linking to it, and it linking to somewhere else. For our example, it doesn't really matter where you insert it into your chain, just that we understand the concept. But let's say that we don't know *which* Node has the problem. Perhaps you're deep into designing narrative somewhere else in your project, and see that there's an error you hadn't seen earlier. How do you know where the Node in question is? Thankfully, there's a quick way to navigate right to it. Simply click the "Go To Node" button (the right-facing arrow next to a problem) and you'll be immediately taken to the associated Node, even if it's in another Experience. Go ahead and try that button now and see how our Dialog Node is now centered in the workspace's view. Now, all we need to do is link our Node into our narrative, and we're done! For a full list of all errors and warnings and how to solve each, check out [[Problems And Errors - Reference And Resolutions]] in the Reference Guide. ## Basics Learned! - Your Next Step You've just finished the first part of mastering an incredible visual narrative design tool, and I can't wait for the next step in our journey! With what you just learned, you now have enough knowledge to design most narratives you could think of within NarrativeFlow. Yet there are still many features of NarrativeFlow that will make designing your narrative easier and simpler and allow you to design otherwise very complex functionality, especially if your narrative is non-linear or dynamic. When you're ready, let's get started with [[Part 2 - Beyond Basics - Quicker, Easier, Organized Narrative Design]]!