Hello and welcome to the articy:draft X Basics tutorial series. In this lesson, we will take a look at all the different object types we can use to create our story flow.
Flow elements – container nodes
In articy:draft we call all objects that can be placed in the Flow: nodes.
Flow Fragments and Dialogues are first and foremost structural elements, like for a chapter or a plot-point.
At the top you find the node name (1) and next to it an icon (2). By default it shows the node type icon, but if you assign a specific template to the node, for example a “Quest” or “Combat Encounter” and this template has a unique icon, it will be displayed (3) instead of the generic type icon, as an easy way of differentiation. Please see the dedicated template lesson to learn more about articy’s powerful template feature.
If there is inner content, a container symbol will be shown on the top right (1). You can set a preview image (2), for easy recognition when looking at the Flow view. With the reference strip (3) you can attach other objects to this node. This could be additional information like a document or an asset, you would like to have readily available, or you could add the characters taking part in this scene, again to have a good overview when quickly looking for a certain information in the Flow as a whole. Below preview image and reference strip you have a text field (4), where you could write down a summary of the scene for example.
With the splitter (1) you can change the ratio between text and image areas or even remove one of them entirely from view (2).
Both Flow Fragment and Dialog can contain all node types as inner content, this is why you will hear me also refer to them as container nodes. Historically they were distinct in what specific node types they could handle, but by now they are mutually interchangeable. You are free to structure your project however you like.
One approach for example could be to put everything that will be a typical dialogue into dialogue nodes, and handle gameplay related content and general descriptions with flow fragments. It helps to keep the overview, and it makes it easier if you export your content for use in a game engine, as you are able to treat the nodes differently inside the engine, depending on the expected type of content.
Flow elements – Dialogue Fragment
The next node type is the Dialogue Fragment. A Dialogue Fragment represents a single line of dialogue or other form of text in the flow, tied to a specific speaker. If we start typing a speaker name (1), articy checks with existing entities and presents matching options to auto-complete. In addition to name, the avatar (2) and color of the entity will also be automatically added to the Dialogue Fragment. Next to the speaker image we have the field for menu text (3). This is usually used for dialogue menus, where you don’t want to show the entire line already when making a selection as a player. Below that is room for stage directions (4), which can be useful for voice-over work, motion capture, or the like, followed by the text field (5) for the actual dialogue line.
It is not possible to submerge further into a Dialogue Fragment, this node type cannot have inner content. You can assign a template to a Dialogue Fragment to add custom properties.
Flow elements – Hubs / Jumps
Next are Hubs (1) and Jumps (2). These node types don’t necessarily have to be used together, but more often than not appear in tandem. A hub is a very simple flow element. It has a display name and a description, which is however only visible in the property sheet and can be accessed with “F8”. In addition to this, you can assign a template to a hub to attach custom properties to it.
A Jump node features a target selection, allowing the conversation state to be moved to any arbitrary point within the flow network regardless of the destination point’s container or position. Set the target by using the right-click context menu on the target area, or by dragging a target from the Navigator.
Via the property sheet you get access to a description field, and of course you can assign a template to a Jump as well. In combination these two elements allow for the easy setup of hub based conversations.
Last but not least a few additional notes regarding these node types: Jumps and Hubs can be used not only in dialogues but everywhere in the flow. A jump and its target do not have to reside inside the same hierarchical level of the flow. You can jump to every other element throughout the entire flow. Also your jump target does not need to be a Hub, you can jump to Flow Fragments, Dialogues, or Dialogue Fragments as well.
Flow elements – Pins
Before we get to the next nodes, we have to talk about an element I passed by until now, and that are pins (1). Pins are used to create connections between nodes (2) and may contain scripting logic (3).
Nodes usually have one dedicated input (1) and one dedicated output pin (2), with some exceptions, like the Jump, which only has an input pin (3). Also, it is possible to add additional pins to the container nodes Flow Fragment and Dialogue (4). This can make sense if leaving a node could have multiple paths, and those paths need their own specific instructions. As the flow direction is from left to right, input pins are always on the left side and output pins are always on the right side of nodes.
Why this little excursion into pins? Because it will be relevant for the next two node types – conditions and instructions.
Flow elements – Conditions / Instructions
Conditions and Instructions can be used in three different places within articy:draft. In Pins, in the dedicated node types, and in template script properties.
A condition (1) checks if a specific state is either true or false, an instruction (2) changes the value of a global variable or property. If located in pins, a condition can only be used in an input pin and an instruction only in an output pin.
Let’s look at a couple of examples: In this dialogue between Mina and Dracula, depending on which branch we follow, Dracula either learns the identity of Mina or not. If we want to use this fact at a later stage, we somehow need to store it.
This we can do with a so called Global Variable. Global variables can be of different types, here we use a Boolean, a variable that can either be true or false, ideal for this exact scenario: Does Dracula know Mina’s name? Yes or no, true or false. If you wonder about variables or the correct way to write an instruction, please check out the Scripting lesson, it would go beyond the scope of this lesson to go into detail about that here.
In the above example an instruction node was used, however we can also put this instruction into the output pin of the Dialogue Fragment instead, by double clicking the pin to open its Edit window. The pin gets marked in orange if it contains content, this way you can quickly see where in the flow pins are used for additional information or story logic.
When continuing the game story at some point we arrive at a dialogue where we want to pick up the naming thing again. Here we want to check if Mina revealed her name to Dracula or not, and the result determines the path the conversation will take. This we do with a condition. A condition node has two output-pins: The green output-pin is chosen if the evaluation of the condition returns true – the red pin if it returns false, ideal to handle if/else scenarios.
Like before with the instruction, we can also put the condition into a pin instead of using the specific node. A condition is placed in the input pin of a node. Only in this case we would need to make sure that there is an unambiguous path the flow can take, so we need to put conditions into the input pins of both nodes, representing the yes / no options. More on that and examples on how to write conditions, so you are able to check for all kinds of things, in the Scripting lesson.
Both condition and instruction nodes come with scripting fields, so that the expressions are visible at a glance.
Via the property sheet that can be opened with “F8” you also get access to a description field (1), and templates can be assigned to these node types as well (2).
These are all the node types that can be used to create an interactive story flow. Although there is one more element – the annotation.
Flow element – Annotation
Annotations are not part of the flow structure itself. They are also missing pins, so they cannot be connected to other elements. Annotations can be used to leave remarks, provide additional information, or even to highlight something by means of color.
Useful links:
Don’t have articy:draft X yet? Get the free version now!
Get articy:draft X FREE
*No Payment information required
Follow us on Twitter, Facebook and LinkedIn to keep yourself up to date and informed. To exchange ideas and interact with other articy:draft users, join our communities on reddit and discord.