Skip to content
Bit Quirky Round Trip
Visual Scripting

Search documentation

All topics and APIs

Close returns focus to Search.

What are you looking for?

Try a common topic or a C# feature.

Browse the reference instead

Esc closes · Tab reaches results · Enter opens the focused link

v1.0.0
Menu

Nodes, pins, and wires

Place a node, wire its pins, and read execution and typed data in a Round Trip visual script without guessing from color alone.

A node is one thing that happens. Its pins are where things go in and come out. Its wires show what feeds what.

Every visual script is drawn with two kinds of wire. White exec wires set the order: they run from one node to the next, and the game does each node in turn along the white path. Colored data wires carry a value, such as a number, a yes-or-no, or an object, from the pin that produces it to the pin that uses it. The wire takes the color of the value’s type, so a red wire always carries a bool and a purple one carries an object.

A node that sits on the white path does something: it calls a method, changes a value, or chooses a path. A node with no white pins only works out a value, such as a comparison, and hands it to whichever node its colored wire reaches.

If you have used Unreal Engine Blueprint, this is the same convention. If you have not, think of a flowchart and a spreadsheet. A white wire is a flowchart arrow: it says then. A colored wire is a spreadsheet reference: it says use this value. Each method’s diagram is those two drawings laid over each other.

White wires say when. The method starts at the entry node’s Exec pin and follows white wires from node to node, left to right, doing each node once as it reaches it. In the script a white wire is the gap between one statement and the next. Where the white path stops, the method ends: a BRANCH whose false pin has no wire simply does nothing on false, and a magenta EXIT node is an early return.

Colored wires say what. A colored wire carries one value from the pin that produces it, on the right of a node or pill, to the pin that uses it, on the left of another. In the script it is an argument, an operand, or the value being assigned. A pill or a value node, colored like the value it produces, has no white pins because it never runs on its own: it works out its value when the node on the white path that uses it runs.

Read two examples of execution and data

Select a screenshot to enlarge it.

AnnounceCoin sends a white exec wire to a dark teal Log call card, while a pink name pill sends a separate wire to its message pin.
Figure 1. Separate when from what AnnounceCoin is the smallest example: the white wire says when the Log card runs; the pink wire supplies what it logs. The pill is read when the call uses it.
OnCoinCountChanged has red EQUALS and OR data nodes feeding a yellow BRANCH, whose white outputs lead to different call paths.
Figure 2. Trace a decision the same way This is a different method, OnCoinCountChanged, not an edit of AnnounceCoin. Follow white exec into BRANCH, then trace its red condition wire back to the comparisons. The true and false outputs select the next statement.

The two kinds follow different rules, and the canvas enforces them as you drag:

White exec wire Colored data wire
Says when: do this next what: use this value
In the script the next statement an argument, an operand, or an assigned value
Direction an output on the right into an input on the left the same
Out of one pin one wire; dropping a second wire on the same output replaces the first as many wires as you like, one per place the value is used
Into one pin any number; several paths can meet at one node one wire; dropping a second wire on the same input replaces the first, and replaces a typed value
Connects to only other white pins only a pin that accepts the type; the pins that cannot take the wire dim while you drag

A replaced wire is one undo away: press Cmd/Ctrl+Z and the earlier wire comes back. To run two nodes after one node, chain them, wiring the first node’s exec output into the second and the second’s into the third.

Most nodes you add belong on the white path, right after a node that is already there. So the quickest way to add one is to start from the pin it follows. Press on a white Exec output, drag onto empty canvas, and let go. A menu opens where you let go. It lists only the nodes that run: statements such as Log under LOGGING and branch, the loops and the switches under FLOW CONTROL, and method calls, found the same way as in the right-click menu. Type part of a name, such as IsTrue, to search the class and every other method in the project. Variable reads, static reads and calls that only return a value, such as Mathf.Clamp, are left out, because a value never runs on its own. Pick a node and it lands at the drop point, already wired to the pin you dragged from.

The new node and its wire are one edit: a single Cmd/Ctrl+Z removes both, so a wrong pick costs one undo. A statement placed from the right-click menu lands unwired instead. It reaches the script only once a white wire joins it to the path, so dragging from the pin it should follow saves that step.

To add a node after the new one, drag again from its exec output; each drop extends the white path by one node. You can also drag backwards, from a node’s white exec input: the node you pick lands wired into that input, so it runs just before.

Dragging from a colored output pin instead opens a menu of that value’s members, with get and set buttons on variables, while clicking a method’s row calls it; see Method calls.

This is the vocabulary every other page uses. Read it before you build your first behavior, such as an enemy that only attacks while it can see the player, or a door that opens once the player holds a key. Come back to it when a diagram gets dense and you want to separate what runs from what feeds it.

The parts of a Round Trip diagramAn AddCoins call card for another class. Its first body row holds the white exec pins: a triangle marked exec on the left edge for the input and one on the right for the output. Below them, a purple target pin is wired from the _scoreCounter pill, and a green count pin holds the literal 1 in a box just outside the card, to the left of its pin. A white exec wire runs from the output through a wire knot into a second card, SetLabel, whose text pin is hollow with an empty box beside it. Seven callouts appear in order: exec pin, data pin, wire, pill, literal, hollow pin, and wire knot. The final frame shows every label._scoreCounterScoreCounterAddCoinsexecexectargetcount1SetLabelexecexectextexec pindata pinwirepillliteralhollow pinwire knotThe parts of a Round Trip diagramAn AddCoins call card for another class. Its first body row holds the white exec pins: a triangle marked exec on the left edge for the input and one on the right for the output. Below them, a purple target pin is wired from the _scoreCounter pill, and a green count pin holds the literal 1 in a box just outside the card, to the left of its pin. A white exec wire runs from the output through a wire knot into a second card, SetLabel, whose text pin is hollow with an empty box beside it. Seven callouts appear in order: exec pin, data pin, wire, pill, literal, hollow pin, and wire knot. The final frame shows every label._scoreCounterScoreCounterAddCoinsexecexectargetcount1SetLabelexecexectextexec pindata pinwirepillliteralhollow pinwire knot
A node carries white exec pins at the top and colored data pins below them; pills and literals supply the values.

Build a branch that logs on each path

  1. Add a method

    In the left rail, click + on the Methods header and press Enter.

    The Methods list with NewMethod selected and a magenta NewMethod entry node alone on the canvas, with the + button on the Methods header highlighted and an arrow pointing at it.
  2. Drop a branch from the exec pin

    Press on the entry node’s white Exec pin, drag onto empty canvas to its right, and let go. In the menu that opens at the drop point, under FLOW CONTROL, click branch.

    Clip: the pointer presses on the NewMethod entry node’s white Exec pin, highlighted with an arrow, and drags a white wire onto empty canvas. On release a menu opens there and the branch row is highlighted; the pointer clicks it, and a yellow BRANCH node lands at the drop point, wired from the Exec pin, with a hollow condition pin.
    Close-up of the white wire leaving the Exec output on the right of NewMethod and entering the Exec input on the left of BRANCH.
  3. Feed the condition

    Right-click empty canvas below and to the left of the branch. In the VARIABLES section of the menu, click get on a bool row, such as enabled. Drag from the dot on the right end of the red enabled pill to the Condition pin.

    Clip: the pointer right-clicks empty canvas below and left of the BRANCH node and a menu opens with a VARIABLES section. It clicks get on the bool row enabled, which is highlighted, and a red enabled pill lands where it right-clicked. It then drags from the dot on the pill’s right end, highlighted, to the branch’s hollow Condition pin, also highlighted; a red wire joins them and the pin fills in.
  4. Drop a Log on true

    Press on the branch’s white true pin, drag onto empty canvas to its right, and let go. In the menu, under LOGGING, click Log.

    Clip: the pointer presses on the branch’s white true pin, highlighted with an arrow, and drags a white wire onto empty canvas to its right. On release a menu opens there and the Log row under LOGGING is highlighted; the pointer clicks it, and a dark teal Log call card tagged Debug lands at the drop point, wired from true, with a hollow message pin.
  5. Type the message

    Click the box beside message and type "Ready", with the double quotes, then press Enter.

    The Log card’s message box holds "Ready" in pink and its message pin is filled pink, with the box and the message pin highlighted.
  6. Give false its own Log

    Do the same from the branch’s white false pin: drag onto empty canvas, pick Log, and type "Not ready" beside its message pin. Now both paths do something.

    A second Log card, wired from the branch’s false pin, with "Not ready" typed on its message pin. The false pin and the new message box are highlighted.
  7. Place a value node, then undo it

    Right-click empty canvas and, under OPERATORS, click Equals. Look at the node, then press Cmd/Ctrl+Z to remove it again.

    A red EQUALS node below the second Log, with unwired left and right inputs, a result output and no white pins. The EQUALS node is highlighted.
  8. Compile

    Press Compile in the toolbar.

    After Compile the canvas reloads from the script: NewMethod into BRANCH, with the enabled pill on condition, a Log with "Ready" on true and a Log with "Not ready" on false.
Value or family Color Meaning
exec rgba(255,255,255,0.70) execution pins and wires
int #4EA054 whole numbers
float #6CB47A decimal numbers (float, double, decimal)
bool #B34D4D yes-or-no values
string #E34A99 text
char #6B8B9A single characters
object #8E5CFF references to objects
struct #B07AB0 value types and Unity structs such as Vector3
void #808011 no value flows
wildcard #9A9A9A type not decided yet
Entry / Exit #800080 where the method starts and stops
Flow / Conditions #FFB400 branches, loops, switches
Pure #095F19 a value node with more than one result, or none of a known type; every other node without exec pins takes its result’s color from the rows above
Impure #0C0C42 statements and SET nodes
Call this class #15B5A6 call to a method on this class or a base class
Call other class #0B6E72 call into another class in your project, or a Unity or .NET method
Call external #566573 a call that resolves to no method in the project or anything it references
Assignment #FF9F43 declaring or changing a value
Await #00A8FF waiting
Try/catch #CD6133 catching errors
Using #2E86C1 resource scope
Placeholder #787878 something the canvas cannot show

Color is never the only signal. Titles, badges, pin labels, filled versus hollow dots, and node shape carry the same distinctions.

If you also work in C#, this is how a BRANCH node with a bool on Condition and a call on each of true and false appears in the script. This one is drafted on EnemyStateMachine in the Platformer sample:

A statement placed by dragging from an exec pin writes the same line a hand-drawn wire would. This is ExecDropDemo after Compile, reloaded from the script: one Log dropped from the entry node with "dropped" typed on its message pin.

When it goes wrong

SymptomCheckFix
A value node appears to run out of order.Look for white pins on the node. Value nodes and pills have none.Follow its colored output wire to the node on the white path that uses the value.
A wire will not connect.Check that you dragged from a right-side output to a left-side input, and that the colors match, or that both pins are white.Drag from the other end, or feed the pin from a source of the matching color.
A wire I drew earlier vanished when I drew another.Both wires left the same white output, or both arrived at the same colored input. Each of those holds one wire, so the new one replaced the old.Press Cmd/Ctrl+Z to bring the first wire back. To run two nodes in turn, chain them along the white path; to feed one input from two values, combine them in a value node first.
A node I added is missing from the script after Compile.Look for a white wire into its exec pin. A node placed from the right-click menu lands unwired, and a node off the white path is never written.Drag a white wire to it from the node it should follow. Next time, drag from that exec pin onto empty canvas and pick the node there: it lands already wired.
A red message under a node reads Node not completely wired: 'condition' has no value source.Read the pin it names in quotes. That pin has no wire, no typed value and no default, so the call cannot be written.Drag a wire into that pin or type a value beside it, and the message goes away. Until then it stays, even when the canvas redraws: after you split or recombine a pill, undo or redo, or leave the method and come back.
A wire color seems wrong for a custom type.Decide whether the type is a reference to an object or a value type.Read object purple for references and the lighter struct purple for known value types.
A gray placeholder node interrupts the white path.Hover it: its tooltip names the part the canvas cannot show.Read the limitation and edit that part in the script. The method refuses Compile while the placeholder remains.
  • Pills and literals: feed pins from pills and typed values, and split a shared pill’s wire into its own pill.
  • Branch: choose between two paths with true and false.
  • Node colors: every type and family color on one page.
Full-size image