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

Your first class

Make a 2D scene with a square character, create a Movement component in Round Trip, add a Move control and an Update method that walk it with the arrow keys, then add a Jump button that hops it, all as visual scripts.

Follow these steps to create a simple class that moves a player character in 2D. You will put a square in a scene, create a Movement component in Round Trip, and build it as visual scripts: the arrow keys or W, A, S and D walk the square around, and Space makes it hop. The pictures and clips were recorded on Windows; on macOS use Cmd where they show Ctrl.

Every word in this table is something you will see on screen. Skim it now and come back when a step uses a word you have forgotten.

Words used in this tutorial

WordWhat it looks likeWhat it means
ClassThe class chip at the top left of the Graph view, reading Movement.A named bundle of settings and actions, saved as one C# file. Here the class is Movement, and Round Trip draws every part of it.
MethodThe Lifecycle list on the left of the Graph view, listing three methods.One named list of actions, such as Update or OnMove. Unity runs a method at a set moment, and the Lifecycle list on the left shows the ones Unity calls for you.
VariableThe Variables list on the left of the Graph view, with the private variables direction and speed.A named value the class remembers, such as speed or direction. The Variables list on the left holds them.
NodeThe teal Translate node, a box with pins down its left edge.A box on the canvas. Each node is one action or one fact: start here, set this, call that.
PinThe three input pins on the left edge of the Translate node: a white Exec arrow and two dots.A dot on a node's edge. A pin on the left takes something in, and a pin on the right hands something out. Wires connect pins.
Exec wireA white wire running from the Exec arrow of the OnMove node, on the left, to the Exec arrow of the move node, on the right.A white wire that sets the order things happen in. It runs from an Exec arrow to the next node's Exec arrow.
Data wireThe direction pill with a pink wire running to the first input of the Multiply node.A colored wire that carries a value from one pin to another, here the direction into a multiplication.
PillThe small rounded green speed pill.A small rounded node that only reads a value, such as a variable. It has no Exec arrow, because it does not do anything.
SET cardThe navy move node: move on the left of its header, SET on the right, and the line local Vector2 under the name.A navy node that stores a value in a variable. Its name is on the left of the header and SET on the right.
CompileThe gold Compile button in the toolbar.The gold button that writes your canvas into the C# file. Nothing in the script changes until you press it.

The finished result: four directions and a hop

Select a screenshot to enlarge it.

Unity in Play mode. The Game view shows the white square right of center, and the Inspector shows Player with Position X near 3.
Right Hold D or the right arrow and the square slides right. The Position in the Inspector changes as it moves.
Unity in Play mode with the square moved up from its last position.
Up Hold W or the up arrow and it moves up.
Unity in Play mode with the square moved left.
Left Hold A or the left arrow and it moves left.
Unity in Play mode with the square moved down.
Down Hold S or the down arrow and it moves down. Two keys at once move it diagonally.
Unity in Play mode after Space was pressed twice: the square is two units higher than before.
Hop Each press of Space hops the square up one unit.
  • A Unity 6 project made from a URP template. In Unity Hub, choose New project and pick Universal 2D (or Universal 3D if you prefer). Avoid templates marked (Built-in / Deprecated): Unity no longer develops that renderer. Both Universal templates already contain the Input System package and a file of ready-made controls, InputSystem_Actions, including the Move and Jump this tutorial uses. You do not set up any keys yourself.
  • The 2D Sprite package, if you chose Universal 3D. The square you add in step 5 comes from Unity’s 2D Sprite package. Universal 2D projects already have it. In a Universal 3D project, the 2D Object menu shows only Pixel Perfect Camera (URP) until you add it:
    1. Choose Window > Package Management > Package Manager (Window > Package Manager in Unity 6.0).
    2. Select Unity Registry on the left and type 2D Sprite in the search box.
    3. Select 2D Sprite and click Install. When Unity finishes importing, 2D Object > Sprites appears in the Hierarchy’s right-click menu.
  • Round Trip installed, with a script folder chosen. Install Round Trip and follow the Setup Wizard. This tutorial keeps its script in Assets/Scripts, so create that folder and choose it as a source folder in the wizard.
  • A clean Console, if Unity reports In App Purchasing as deprecated. The Universal templates include Unity’s In App Purchasing package, and Unity 6.5 reports it in the Console as deprecated (a yellow warning, also shown in the status bar at the bottom of the editor). This tutorial does not use it, so remove it and the Console starts empty:
    1. Choose Window > Package Management > Package Manager. Project > All Packages lists every package in the project; In App Purchasing carries a red mark and a Deprecated tag.
    2. Select In App Purchasing, open Manage and choose Remove.
    3. Unity asks Are you sure you want to remove this package? Click Remove. Unity reloads, and the warning is gone.

Remove In App Purchasing

Select a screenshot to enlarge it.

The Package Manager window with Project, All Packages selected. In App Purchasing 4.15.1 is selected in the list with a red error mark, and its details show a Deprecated tag and the message: Unity IAP 4 is unsupported as of June 8, 2026. IAP 5 is the supported version going forward.
Select it In App Purchasing is marked deprecated, which is the warning you see in the Console.
The same window with the Manage menu open under the package details. It lists Customize, Open Manifest, Open Manifest Externally and Remove.
Manage > Remove Remove is the last entry in the Manage menu.
A small dialog titled Removing package asking: Are you sure you want to remove this package? Remove is the first of its three buttons.
Confirm Click Remove. Unity reloads when it finishes.

A brand-new practice project is the safest place to try this. The steps create a script and a scene and add components to Player. The Universal template already has Move and Jump in InputSystem_Actions, Unity’s project-wide actions file. Round Trip copies that file once to Assets/PlayerControls.inputactions for the Player Input and reuses the actions in the copy; the template’s own file is not changed.

Steps and boxes look different on purpose. A numbered step is something you do. A box marked with an i and For information explains what you just did, so you can read it or skip it.

A scene is one place in your game: a menu, a level, a test room. Round Trip does not change how scenes work; this is the same scene you would make for any Unity project.

Make and open a 2D scene

  1. Create a scene

    In the Project window, select the Assets/Scenes folder, then choose Assets > Create > Scene > Scene from the menu bar. Right-clicking the folder opens the same Create menu.

    Clip: the Scenes folder is selected in the Project window. The pointer opens the Assets menu in the editor's menu bar, then Create, then Scene, then clicks Scene. Each menu item the pointer is choosing is highlighted in turn: Assets, Create, Scene, and Scene again in the last list. A new scene asset appears in Scenes with its name, New Scene, ready to type.
    The New Scene dialog lists the scene templates in the project: Lit 2D (URP), Basic (URP), Indoors (URP), Outdoors (URP), Empty, Basic 2D (Built-in / Deprecated) and Basic 3D (Built-in / Deprecated). Lit 2D (URP) is selected, and its details say it contains an orthographic camera and a Global Light 2D.
  2. Name it Movement

    Type Movement as the scene name and press Enter.

    The Project window shows the new scene asset named Movement, selected, in Assets/Scenes beside SampleScene. The Hierarchy still shows the Untitled scene that was open before.
  3. Open it

    Double-click the new scene to open it. Its name appears at the top of the Hierarchy, above a Main Camera.

    The Movement scene is open. The Hierarchy shows Movement at the top with Main Camera under it, and the Scene view shows the white camera rectangle on a grid.
  4. View it in 2D

    Make sure the 2D button in the Scene view toolbar is on.

    The Scene view with the 2D button in its toolbar highlighted and switched on: a flat view of a grid with the white rectangle the camera sees.

You need something to move. Unity has simple built-in shapes, so you do not need any art.

A square called Player

  1. Add a square

    Choose GameObject > 2D Object > Sprites > Square from the menu bar, or right-click an empty part of the Hierarchy and choose the same items. A white square appears in the middle of the scene.

    2D Object shows only Pixel Perfect Camera (URP)? Your project does not have the 2D Sprite package yet, which happens in projects made from the Universal 3D template. Install it as described in Before you start, then come back to this step.

    Clip: the pointer opens the GameObject menu in the editor's menu bar, then 2D Object, then Sprites, then clicks Square. Each menu item the pointer is choosing is highlighted in turn: GameObject, 2D Object, Sprites and Square. A Square object appears in the Hierarchy under Main Camera, selected.
  2. Name it Player and reset its position

    With the square selected, press F2 (Enter on macOS), type Player, and press Enter. The name changes in the Hierarchy and at the top of the Inspector.

    Then reset its position. In the Inspector, click the ⋮ button at the right of the Transform header (or right-click the header) and choose Reset. Position now reads 0, 0, 0, so Player starts in the middle of what the camera sees.

    The square renamed to Player in the Hierarchy and at the top of the Inspector. The Inspector shows its Sprite Renderer with the built-in Square sprite and the Sprite-Lit-Default material.

Everything a GameObject does comes from its components, and every component is a class: a named bundle of settings and actions saved in one C# file. You will make a new one.

Create a MonoBehaviour called Movement

  1. Open Graph view

    Choose Tools > Round Trip > Graph view. The Round Trip graphs window opens.

    Clip: the pointer opens the Tools menu in the editor's menu bar, then Round Trip, and clicks Graph view. Each menu item the pointer is choosing is highlighted in turn: Tools, Round Trip and Graph view.
  2. Press +

    Press the + next to the class chip in the top-left corner. The Create new class form opens.

    Round Trip graphs with the Create new class form open and the plus beside the class chip highlighted. The form has NAME, LOCATION with Scripts and the namespace box, and the PARENT CLASS cards class, enum, static, MonoBehaviour and ScriptableObject.
  3. Name it Movement

    Type Movement under NAME. Leave LOCATION on your Scripts folder.

    The Create new class form with Movement typed under NAME (highlighted). The line under LOCATION reads Scripts/Movement.cs and the namespace box is empty.
  4. Choose MonoBehaviour

    Under PARENT CLASS, pick MonoBehaviour, because Movement belongs on the Player.

    The Create new class form with the MonoBehaviour card highlighted and selected under PARENT CLASS.
  5. Create

    Press Create. Round Trip writes Assets/Scripts/Movement.cs straight away and opens it. The class chip now reads Movement.

    Graph view with Movement on the class chip, an empty Lifecycle section, Variables listing the inherited properties, and the class details on the right.

A setting that shows in the Inspector lets the designer change how fast the square moves without touching the visual script.

A speed the designer can tune

  1. Add a variable

    Press the + on Variables. A new row appears with its name ready to type. Type speed and press Enter.

    The Variables list has a new private row named speed marked New, with the plus beside Variables highlighted, and the right-hand panel shows the variable speed, kind variable, with its Shown in the Inspector switch off and a Remove variable link.
  2. Show it in the Inspector

    In the right-hand panel, turn on Shown in the Inspector. The switch can take a moment to change the first time, so press it once and wait.

    The speed variable's Shown in the Inspector switch is highlighted and on, and the panel now reads Saved with the object, designers tune it without touching code.
  3. Make it a float of 5

    Under Declaration, click Type. In the type list that opens, type float in the search box and choose float (a number that can have a decimal point). Then scroll down the panel to the Default card and type 5 into its VALUE row. That is 5 units per second.

    The right-hand panel with the Type row under Declaration highlighted; it still reads int.
    The speed variable typed float, with the VALUE row on its Default card highlighted and holding 5, and the Previewing your changes banner above it.
  4. Compile

    Press the gold Compile button at the top left, beside the class chip. Wait for Unity to finish compiling. Compile turns gray again.

    The toolbar's gold Compile button highlighted, with the Previewing your changes banner and its own Compile button in the right-hand panel.
    After Compile, Variables lists speed as float equal to 5f with the serialized mark, and the Compile button is gray again.

The keys reach your script through Unity’s Input System. Round Trip connects four parts of it in one step.

Add Move

  1. Pick New player control

    Press the + on Lifecycle. In the filter box, type input, then click New player control…. The Add a player control to Movement window opens.

    The Graph view with an empty Lifecycle list and the plus beside Lifecycle highlighted.
    The Add lifecycle method list filtered by input, with an INPUT section holding one row, New player control, and its detail line Pick keys and buttons; Round Trip writes the method they call. The row is highlighted.
    The Add a player control to Movement window with an empty name box and a section for each question: what the player does, the keys to use, the player object.
  2. Name it Move

    Type Move in Name the control. Under the box, Round Trip shows the method it will write: OnMove(InputValue value).

    The control window with Move typed. A blue note says Move is already a control in InputSystem_Actions and Round Trip will use it as it is; the player object is Player; ROUND TRIP WILL lists copying InputSystem_Actions to Assets/PlayerControls.inputactions so the Player Input has its own file, using the Move control already in PlayerControls, adding Movement to Player, adding a Player Input set to Send Messages, saving the scene Movement and writing OnMove(InputValue value).
  3. Add control

    Press Add control (or Enter).

    Close-up of ROUND TRIP WILL with its six lines: copy InputSystem_Actions to Assets/PlayerControls.inputactions so the Player Input has its own file, use the Move control already in PlayerControls, add Movement to Player, add a Player Input component to Player set to Send Messages, save the scene Movement, and write OnMove(InputValue value) in Movement and open it on the canvas. The Add control button is below.

Round Trip closes the window, writes OnMove into Movement.cs, and opens it on the canvas.

What Round Trip added

  1. Select Player

    Select Player in the Hierarchy. Movement (Script) is on it with Speed set to 5, and a Player Input sits under it.

    Unity with Player highlighted in the Hierarchy and selected. The Inspector shows Movement (Script) with Speed 5 and, under it, Player Input with Actions set to PlayerControls. The Project window lists PlayerControls beside the Scripts and Settings folders, and the Console is empty.
  2. Open the Scripts folder

    In the Project window, open the Scripts folder by clicking the arrow beside it. Movement is the C# file Round Trip wrote.

    The Project window with the Scripts folder and the Movement file inside it highlighted: Movement is the C# file Round Trip wrote.
  3. Go back to Graph view and click OnMove

    If you switched to the main Unity window or to a code editor, choose Tools > Round Trip > Graph view to come back. Then click OnMove in the Lifecycle list.

    Graph view showing OnMove with its row in the Lifecycle list highlighted: the magenta OnMove node with three pins (Exec, Self, value), a Get<Vector2> pill fed by value, and a navy move SET node with the line local Vector2 under its name that the pill feeds.
  4. Double-click a node to see its C#

    Double-click the move node. Your code editor opens Movement.cs at that node’s line.

    Clip: the pointer double-clicks the title of the navy move node in the Graph view.
    A code editor showing Movement.cs scrolled to the line Vector2 move = value.Get<Vector2>(); with the cursor on it.

OnMove runs only when the direction changes: when you press a key, let go, or press another. It does not run every frame while you hold a key. So OnMove keeps the direction in a variable, and the next section moves the square by it every frame.

Keep the direction

  1. Add direction

    Press the + on Variables, type direction, and press Enter. In the right-hand panel, under Declaration, click Type, type Vector2 in the search box and choose Vector2 (the one in UnityEngine).

    A new private variable named direction, typed Vector2, with Shown in the Inspector off. The plus beside Variables and the Type row in the right-hand panel are highlighted.
  2. Set it

    Drag direction from Variables onto the canvas, to the right of move, and choose set direction. A navy direction SET node appears.

    Clip: direction is dragged from the highlighted Variables row onto the OnMove canvas. A menu opens with get direction and set direction above the Vector2's members; the set direction row is highlighted while the pointer clicks it, and a navy direction node marked SET appears.
  3. Wire it from move

    Connect the move SET’s white Exec arrow to the direction SET’s Exec, and the move SET’s Value output to the direction SET’s Value input.

    Clip: the move node's white Exec arrow is wired to the direction node's Exec, and its Value output to the direction node's Value input.
  4. Compile

    Press Compile. Round Trip writes direction = move; into OnMove.

    OnMove with move wired to direction by an exec wire and a value wire, and the toolbar's gold Compile button highlighted.
    OnMove after Compile, read back from the file: move feeds direction by an exec wire and a value wire, and Compile is gray.

Unity calls Update once every frame, so whatever you connect after its white Exec arrow happens every frame. Here it moves the square by the stored direction, scaled by speed and by the time since the last frame.

Build Update

  1. Add Update

    Press the + on Lifecycle and choose Update() under CORE. A magenta Update box appears on the canvas.

    Graph view with OnMove compiled and the plus beside Lifecycle highlighted.
    Graph view with Update in the Lifecycle list and a magenta Update node alone on the canvas.
  2. Click OnMove, then Update

    Click OnMove in the Lifecycle list. The method you compiled is still there, exactly as you left it. Then click Update to carry on.

    Graph view with OnMove selected again: its row in the Lifecycle list is highlighted, and the canvas shows the compiled OnMove, with move wired to direction.
  3. Get direction

    Drag direction from Variables onto the canvas and choose get direction.

    Clip: direction is dragged from the highlighted Variables row onto the Update canvas; the menu opens, the get direction row is highlighted while the pointer clicks it, and a direction pill appears.
  4. Add Multiply

    Right-click empty canvas, type Multiply, and choose the Multiply row with the ✖ icon. Wire direction into its first input.

    Clip: a right-click on empty canvas opens All actions; Multiply is typed and the Multiply row, the one with the multiply icon, is highlighted while it is clicked. A MULTIPLY node appears and direction is wired into its first input.
  5. Add speed

    Drag speed from Variables onto the canvas, choose get speed, and wire the green pill into the second input.

    Clip: speed is dragged from the highlighted Variables row, the get speed row of the menu is highlighted while it is clicked, and the green speed pill is wired into the Multiply's second input.
  6. Add Time.deltaTime

    Click Add pin under the Multiply’s inputs to give it a third input. Right-click empty canvas, type deltaTime, choose Time.deltaTime, and wire it into the third input.

    Clip: Add pin under the Multiply's inputs is highlighted and clicked, and a third input appears. A right-click on empty canvas opens All actions, deltaTime is typed, the Time.deltaTime row is highlighted while it is chosen, and its pill is wired into the third input.
  7. Get the transform

    In Variables, scroll to transform under INHERITED, drag it onto the canvas and choose get transform.

    Clip: the mouse wheel scrolls the Variables list down to transform under INHERITED; transform is dragged onto the canvas and the get transform row of the menu is clicked. The Variables list is highlighted until transform is dragged out of it, then the get transform row is highlighted.
  8. Drag from the transform pill

    Drag from the transform pill: press on the circle on its right edge, highlighted in the clip, and pull the wire onto empty canvas. Do not right-click the canvas for this one. Let go, type Translate, and click Translate(Vector3 translation).

    Clip: a wire is dragged from the highlighted circle on the right edge of the transform pill onto empty canvas; the member menu opens, Translate is typed and the Translate(Vector3 translation) row is highlighted while it is clicked. A teal Translate node appears with its Target wired from transform.
  9. Wire it up

    Wire the Multiply’s Result into translation, then connect the white Exec arrow of Update to the Exec pin of Translate. Round Trip parks the new to Vector3 pill low on the canvas, so drag it up under the transform pill, as in the clip, to keep its wires short.

    Clip: the Multiply's Result is dragged onto translation. A to Vector3 pill appears low on the canvas, is dragged up under the transform pill, and then Update's white Exec arrow is wired to Translate's Exec.

Write it to C#

  1. Compile

    Press Compile. Round Trip writes Update into Movement.cs, Unity compiles it, and the canvas reloads from the saved file. Compile turns gray again because the file now matches the canvas.

    The finished Update canvas: the Update node's exec wire runs straight to Translate, direction, speed and deltaTime feed one MULTIPLY, the to Vector3 pill sits beside the transform pill on a short wire into translation, and the toolbar's gold Compile button is highlighted.
    Update after Compile, read back from the file: Update runs to Translate, direction, speed and deltaTime feed one MULTIPLY, and a to Vector3 pill, highlighted, sits beside the transform pill on the short wire from its Result to translation. Compile is gray.

You never need to open the file, but this is what Round Trip saved in Assets/Scripts/Movement.cs so far. A programmer on your team can read and change it like any other script, and Round Trip will draw their changes as a visual script.

There is no namespace line because the namespace box was empty. Round Trip fills that box from the folder’s assembly definition, then from the namespace the scripts already in the folder use, then from Project Settings > Editor > Root Namespace; in a new project with an empty Scripts folder none of these names one. Round Trip only writes C# it can draw again; Supported C# lists what that covers.

Jump is added the same way as Move.

Add Jump

  1. Pick New player control

    Press the + on Lifecycle, type input, scroll to the bottom of the list and click New player control….

    The Graph view with OnMove and Update in the Lifecycle list and the plus beside Lifecycle highlighted.
    The Add lifecycle method list filtered by input and scrolled to the bottom: INPUT · DEVICES rows, then New player control as the last row, highlighted under the pointer.
  2. Name it Jump

    Type Jump.

    The control window with Jump typed. The blue note says Jump is already a control in PlayerControls (Space, Gamepad Button South, XR Controller Secondary Button).
  3. Add control

    Press Add control.

    Close-up of ROUND TRIP WILL for Jump: use the Jump control already in PlayerControls, use the Player Input already on Player, save the scene Movement, write OnJump(InputValue value) in Movement and open it on the canvas; and the Add control button.

OnJump is already open on the canvas, and it is not empty. A Player Input sends Jump when the button goes down, so Round Trip starts the method with a check for that: a Branch that asks value.isPressed. Anything you connect to true happens once per press.

OnJump on the canvas

  1. Find OnJump

    Look at the Lifecycle list on the left: OnJump has joined Update and OnMove. Click OnJump if it is not already selected.

    Graph view for Movement: Lifecycle now lists OnJump below Update and OnMove, with the OnJump row highlighted. The canvas shows the magenta OnJump node, an isPressed pill fed by value, and the Branch.
  2. Get the transform

    Drag transform from Variables onto the canvas and choose get transform, as you did for Update.

    Clip: transform is dragged from the highlighted Variables row onto the OnJump canvas, then the get transform row of the menu is highlighted while it is clicked.
  3. Drag from the transform pill

    Drag from the circle on the transform pill’s right edge onto empty canvas, type Translate, and choose Translate(Vector3 translation).

    Clip: a wire is dragged from the highlighted circle on the right edge of the transform pill onto empty canvas, Translate is typed and the Translate(Vector3 translation) row is highlighted while it is clicked; a Translate node appears.
  4. Connect true and enter the hop

    Connect the Branch’s true arrow to Translate’s Exec. In translation, enter 0 in X, 1 in Y, and 0 in Z.

    Clip: the Branch's true arrow is wired to Translate's Exec; then the X, Y and Z boxes of translation take 0, then 1, then 0.
  5. Compile

    Press Compile.

    The finished OnJump canvas: OnJump runs to the Branch, whose true arrow runs to Translate with the transform pill as its target, and the toolbar's gold Compile button is highlighted.
    OnJump after Compile, read back from the file: OnJump runs to the Branch, whose true arrow runs to Translate with the transform pill as its target and Vector3.up as its translation.

This is the method Round Trip added to Assets/Scripts/Movement.cs, beside OnMove and Update.

Real jumping falls back down, and that needs physics: a Rigidbody 2D on Player and a push upwards instead of a Translate. Lifecycle methods covers FixedUpdate, where physics code goes. The control part of this tutorial stays the same.

Press Play

  1. Press Play

    Press Play in Unity’s main toolbar. Use the button here: Ctrl+P (Cmd+P on macOS) has a different meaning when Round Trip’s graph has keyboard focus.

    Unity in Play mode: the Play button in the main toolbar is highlighted and lit, the Game view shows the white square at the center on a blue background, and the Inspector shows Player at position 0, 0.
  2. Walk

    Click inside the Game view so it receives the keys, then hold W, A, S or D, or the arrow keys. The square moves in that direction for as long as you hold the key, and stops when you let go.

    Clip from Play mode: the square moves right, then up, then left, then down in the Game view while the matching key is held, stopping each time the key is released; the Inspector's Position follows it.
  3. Hop

    Press Space. The square hops up one unit. Press it again and it hops again.

    Clip from Play mode: Space is pressed and the square jumps up one unit; holding it does nothing more; a second press hops it up another unit.
  4. Stop

    Press Play again to stop. The square goes back to where it started, and anything you changed in the Inspector during Play goes back to how it was.

    Unity back in Edit mode after Play was pressed again: Player is at position 0, 0 again in the Inspector.

Once a Player Input is in your scene, Round Trip reads its actions file and lists every action it sends in the Lifecycle + list. Use these rows when the action already exists; use New player control… to make a new one. Pick OnAttack(), for example, and it arrives with its own press check: connect something to true, Compile, and press Enter or click the left mouse button in Play mode to call it.

Each method starts with a line that reads the control’s value, so you can wire it straight away:

  • Buttons (Jump, Attack, Interact) start with the press check, if (value.isPressed).
  • Directions (Move, Look) start with Vector2 move = value.Get<Vector2>();, a pair of numbers from -1 to 1.
  • Amounts (a trigger, a scroll wheel) start with float … = value.Get<float>();.

Move and Jump are not in the list any more, because Movement handles them.

Every action is one click away

Select a screenshot to enlarge it.

The Add lifecycle method list filtered by input after Move and Jump were added. INPUT · PLAYER lists OnLook, OnAttack, OnInteract, OnCrouch, OnPrevious, OnNext and OnSprint, then an INPUT · UI section begins with OnNavigate and OnSubmit.
INPUT · PLAYER INPUT · PLAYER lists the actions in the Player map that Movement does not handle yet, starting with OnLook. INPUT · UI lists the menu actions, and INPUT · DEVICES the messages Player Input sends when a gamepad is plugged in or unplugged.

When the name you type is not in the actions file (PlayerControls here), the window asks the two questions Move and Jump skipped.

  • What does the player do? Press a button for things that happen once (jump, fire, pause). Point a direction for things that steer in two dimensions (move, look, aim). Push an amount for things with a strength in one dimension (steer left and right, zoom, throttle).
  • Which keys and buttons? A short list of common choices, each with a keyboard and a gamepad binding: for example Escape · Gamepad Start or WASD and arrow keys · Gamepad left stick.

Round Trip adds the action to the Player map of your actions file, with those bindings, and then does everything it did for Jump. To change the keys later, or to bind more than the list offers, press Open in Input Actions editor. That opens Unity’s own editor for the file, and your method keeps working whatever keys you choose there. The first control you add to a project copies the template’s InputSystem_Actions to Assets/PlayerControls.inputactions, as Move did. If the project has no actions file at all, Round Trip creates Assets/PlayerControls.inputactions with a Player map.

A Pause control

Select a screenshot to enlarge it.

The control window with Pause typed. WHAT DOES THE PLAYER DO? offers Press a button, Point a direction and Push an amount, with Press a button selected. WHICH KEYS AND BUTTONS? shows Space bar · Gamepad A. ROUND TRIP WILL lists adding Pause to the Player map in PlayerControls (Space bar · Gamepad A), using the Player Input already on Player, saving the scene Movement and writing OnPause(InputValue value) in Movement. Open in Input Actions editor is at the bottom left.
Pause Pause is new, so the window asks what the player does and which keys. The plan adds Pause to the Player map in PlayerControls and reuses the Player Input already on Player. Choose different keys in the list, or open Unity's Input Actions editor to change them later. Cancel writes nothing.

When it goes wrong

SymptomCheckFix
Space hops the square, but the arrow keys do nothing.Open OnMove: the direction node needs both the exec arrow and the value from move.Wire them as in step 25, then press Compile.
Compile stays gray and a node shows a red message.Read the message: it names the pin that has no value or wire.Fill that box or draw the wire it asks for.
The INPUT row says it needs the Input System package.Open Window > Package Manager and look for Input System under In Project.Install Input System, accept the restart Unity offers, and open the list again.
Add control stays gray with "Save the scene first".Look at the scene name at the top of the Hierarchy: an unsaved scene has no file yet.Press Ctrl+S (Cmd+S on macOS), save the scene in Assets/Scenes, then press Add control again.
Which object is the player? is empty.Round Trip looks for an object with Movement, then one with a Player Input, then one named Player.Drag your character from the Hierarchy onto the box.
The window says the object is open in prefab editing.The Scene view shows a blue prefab bar at the top while you edit a prefab.Close the prefab with the arrow in that bar, then choose the player in the scene, or the prefab in the Project window.
The window says Movement has not compiled yet.A spinner at the bottom right of the editor means Unity is still compiling.Wait for it to finish, or fix any red errors in the Console, then try again.
Play starts but the square does not move or hop.Select Player: it needs both Movement and Player Input, and Behavior must say Send Messages.Click inside the Game view first so it receives keys. If Behavior says something else, run New player control again with the same name: Round Trip sets it back.
A method shows "is never called: no PlayerInput beside this class sends messages for…".Round Trip compares each On… method that takes an InputValue with the actions your saved Player Inputs send. The action named in the notice is not among them, often because one of the two was renamed.Rename the method to match the action, add the action with New player control, or delete the method if it is left over.
  • Round Trip finds Player Inputs in saved scenes and prefabs. One created by a script while the game runs is not seen.
  • Round Trip sets Player Input to Send Messages. One you set to Broadcast Messages is read too, but Broadcast also reaches child objects, and Round Trip only looks at the GameObject the Player Input is on. Invoke Unity Events and Invoke C# Events call a different kind of method and are not offered.
  • With Send Messages, a button calls its method when it is pressed; releasing it calls nothing. To react to a release, read the action in Update with InputSystem.actions.FindAction.
  • A Behavior changed on one prefab instance (an override) is not read; Round Trip reads the prefab’s own setting.
  • Writing PlayerControls (the copy, and every action added to it) cannot be undone with Edit > Undo. The Player Input component change can. InputSystem_Actions is never changed.
  • The key lists do not warn when a key is already used by another action. The Universal template uses Space, E, C, Shift and the left mouse button already.
  • The INPUT section appears for every MonoBehaviour class, even ones that are not on the player.
  • Check what the AI did: an assistant changed your scripts; read the change on the canvas and decide whether to keep it.
  • Lifecycle methods: Start, FixedUpdate, collisions, the INPUT sections and their notices.
  • Branch: do more with the true and false routes of the press check.
  • Method calls: pick what a call node calls, what it calls it on, and the values it passes.
  • Preview and Compile: follow a change from canvas to script.
Full-size image