New Input System overview in Unity - Step-by-Step Execution

Concept Flow - New Input System overview

Start

↓

Create Input Actions

↓

Generate C# Class

↓

Enable Input Actions

↓

Listen for Input Events

↓

Respond to Input

↓

Disable Input Actions

↓

End

This flow shows how the new input system in Unity works from creating input actions to responding to input events.

Execution Sample

Unity

var controls = new PlayerControls();
controls.Enable();
controls.Player.Jump.performed += ctx => Jump();
void Jump() {
  Debug.Log("Jump!");
}

This code creates input controls, enables them, listens for a jump action, and runs a jump method when triggered.

Execution Table

Step	Action	Evaluation	Result
1	Create PlayerControls instance	var controls = new PlayerControls()	controls object created with input actions
2	Enable input actions	controls.Enable()	Input system starts listening for inputs
3	Subscribe to Jump action	controls.Player.Jump.performed += ctx => Jump()	Jump method linked to Jump input event
4	Player presses jump button	Jump input detected	Jump() method called
5	Jump() runs	Debug.Log("Jump!")	Console prints 'Jump!'
6	Disable input actions	controls.Disable()	Input system stops listening for inputs

💡 Input actions disabled or game ends, stopping input listening

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	After Step 4	Final
controls	null	PlayerControls instance	Enabled	Jump event subscribed	Jump event triggered	Disabled

Key Moments - 3 Insights

Why do we need to call controls.Enable()?

controls.Enable() starts the input system listening for input events. Without it, input actions won't detect any input, as shown in step 2 of the execution_table.

What happens if we don't unsubscribe from input events?

If you don't unsubscribe, the event handler stays active and can cause unexpected behavior or memory leaks. The example shows subscribing but disabling input stops listening (step 6).

How does the Jump() method get called?

Jump() is called when the Jump input action is performed, as linked in step 3 and triggered in step 4 of the execution_table.

Visual Quiz - 3 Questions

Look at the execution_table, what is the state of 'controls' after step 2?

A Jump event is subscribed

B Input actions are disabled

C Input system is listening for inputs

D Jump method has been called

💡 Hint

Check the 'Result' column in step 2 of the execution_table

At which step does the Jump() method get called?

A Step 4

B Step 3

C Step 6

D Step 5

💡 Hint

Look at the 'Action' and 'Result' columns for when Jump() runs

If controls.Disable() is never called, what happens?

A Input system stops listening automatically

B Input system keeps listening for inputs

C Jump() method never runs

D PlayerControls instance is destroyed

💡 Hint

Refer to the 'exit_note' and step 6 in the execution_table

Concept Snapshot

New Input System in Unity:
- Create Input Actions asset
- Generate C# class from asset
- Instantiate and Enable controls
- Subscribe to input events
- Respond in event handlers
- Disable controls when done

Full Transcript

The Unity New Input System works by creating input actions and generating a C# class to manage them. You instantiate this class and enable it to start listening for inputs. Then, you subscribe to specific input events like Jump. When the player presses the jump button, the Jump method runs. Finally, you disable the input actions when no longer needed to stop listening. This flow ensures clean and responsive input handling.

Practice

1. What is the main purpose of the New Input System in Unity?

easy

A. To create 3D models for games

B. To handle multiple input devices easily and flexibly

C. To manage game physics and collisions

D. To optimize game graphics performance

Solution

1. Step 1: Understand the role of input systems

   The New Input System is designed to manage inputs from devices like keyboard, mouse, gamepads, etc.

2. Step 2: Compare with other options

   Options B, C, and D relate to graphics, physics, or modeling, not input handling.

3. Final Answer:

   To handle multiple input devices easily and flexibly -> Option B

4. Quick Check:

   New Input System = device input management [OK]

Hint: Focus on input device management purpose [OK]

Common Mistakes:

• Confusing input system with graphics or physics
• Thinking it only handles keyboard input
• Assuming it creates game assets

2. Which of the following is the correct way to enable an input action in the New Input System?

easy

A. inputAction.Run();

B. inputAction.Start();

C. inputAction.Activate();

D. inputAction.Enable();

Solution

1. Step 1: Recall method names in New Input System

   The method to activate an input action is called Enable(), not Start(), Activate(), or Run().

2. Step 2: Confirm syntax correctness

   inputAction.Enable(); is the correct syntax to enable the action.

3. Final Answer:

   inputAction.Enable(); -> Option D

4. Quick Check:

   Enable() activates input actions [OK]

Hint: Remember Enable() activates input actions [OK]

Common Mistakes:

• Using Start() instead of Enable()
• Confusing method names with Activate() or Run()
• Forgetting parentheses after method name

3. Given this code snippet using the New Input System:

var moveAction = playerInput.actions["Move"];
moveAction.Enable();
var value = moveAction.ReadValue<Vector2>();
Debug.Log(value);

What does value represent?

medium

A. The current 2D vector input from the Move action

B. A boolean indicating if Move is pressed

C. The name of the Move action as a string

D. An integer representing Move action's ID

Solution

1. Step 1: Understand ReadValue<Vector2>()

   This method reads the current input value as a Vector2, typically for movement directions.

2. Step 2: Analyze the variable 'value'

   Since moveAction is enabled and ReadValue<Vector2>() is called, value holds the 2D input vector from the Move action.

3. Final Answer:

   The current 2D vector input from the Move action -> Option A

4. Quick Check:

   ReadValue<Vector2>() returns Vector2 input [OK]

Hint: ReadValue<Vector2>() returns 2D input vector [OK]

Common Mistakes:

• Thinking it returns a boolean
• Confusing value with action name or ID
• Not enabling the action before reading

4. What is wrong with this code snippet using the New Input System?

var jumpAction = playerInput.actions["Jump"];
jumpAction.ReadValue<float>();
jumpAction.Enable();

medium

A. The action is read before it is enabled

B. ReadValue<float>() is not a valid method

C. The action name "Jump" is invalid

D. Enable() should be called twice

Solution

1. Step 1: Check the order of method calls

   The code reads the input value before enabling the action, which means no input is active yet.

2. Step 2: Understand correct usage

   Enable() must be called before reading values to get valid input data.

3. Final Answer:

   The action is read before it is enabled -> Option A

4. Quick Check:

   Enable() must come before ReadValue() [OK]

Hint: Always enable input action before reading values [OK]

Common Mistakes:

• Reading input before enabling action
• Assuming ReadValue<float>() is invalid
• Thinking action names must be changed

5. You want to temporarily stop all player input during a cutscene using the New Input System. Which approach is best?

hard

A. Delete the input action asset during the cutscene

B. Set all input action callbacks to null

C. Call playerInput.actions.Disable() to disable all input actions

D. Ignore input values but keep actions enabled

Solution

1. Step 1: Understand disabling input actions

   Calling Disable() on the actions disables all input reading cleanly and temporarily.

2. Step 2: Evaluate other options

   Deleting assets is destructive, setting callbacks to null is error-prone, ignoring inputs wastes resources.

3. Final Answer:

   Call playerInput.actions.Disable() to disable all input actions -> Option C

4. Quick Check:

   Disable() cleanly stops input during cutscenes [OK]

Hint: Use Disable() to pause all inputs safely [OK]

Common Mistakes:

• Deleting input assets instead of disabling
• Nullifying callbacks causing errors
• Ignoring inputs wastes CPU