⌨️ Lesson 3.3: Reading Input in Code

Three Ways to Read Input

All three routes read the same .inputactions asset — they differ in how much you wire in the Inspector vs. in code:

1. PlayerInput component — drop a component on your player, point it at the asset, and it dispatches each action to your methods. Least code, great for a single player. This is our recommendation.
2. Generated C# class — Unity generates a strongly-typed wrapper class from the asset. You new it up and subscribe to its events. Great for full control and no components.
3. Direct InputAction references — expose InputAction fields (or an InputActionReference), enable them, and read/subscribe manually. Most flexible, most boilerplate.

The PlayerInput Component

Select your player GameObject and click Add Component ▸ Player Input (from the Input System package). It has a few key fields:

• Actions — drag your PlayerControls asset here.
• Default Map — which map is active on start (choose Player).
• Behavior — how it calls your code. This is the choice that matters.

The Behavior dropdown offers four styles:

• Invoke Unity Events — exposes an event per action in the Inspector; you drag your method onto it. Explicit and easy to see. We use this.
• Send Messages — calls methods named OnMove, OnJump by convention on the same GameObject.
• Broadcast Messages — like Send Messages but also to children.
• Invoke C# Events — exposes C# events you subscribe to in code.

Here's the component set to Invoke Unity Events, with the Move and Jump events wired to a PlayerController script:

Wiring the Inspector

With Behavior set to Invoke Unity Events, expand the Events foldout, then the Player group. You'll see one "(Callback)" event per action. To wire one:

1. Click + under, say, Move (Callback).
2. Drag the GameObject holding your PlayerController script into the object slot.
3. In the function dropdown choose PlayerController ▸ OnMove (a dynamic method that takes a CallbackContext).
4. Repeat for Jump (Callback) → OnJump.

Callbacks & CallbackContext

Each handler receives an InputAction.CallbackContext — a little struct describing what just happened. The two things you'll use most:

• context.ReadValue<T>() — the current value, e.g. ReadValue<Vector2>() for Move.
• context.phase — where the action is in its lifecycle: started, performed, or canceled. For a Button, performed is the press and canceled is the release. Convenience flags context.performed and context.canceled read cleanly in an if.

Figure 2: Input flows from device to action to PlayerInput to your callback, which reads the value and phase.

💡 Store, don't act (for movement). A Move callback can fire several times a frame or not at all. Don't move the transform inside the callback. Instead store the latest Vector2 in a field and apply it in Update or FixedUpdate, where you control timing with Time.deltaTime.

Moving a Character

Here's a complete controller that reads Move and Jump via PlayerInput callbacks. Notice the pattern: the callbacks just capture input; Update and OnJump do the work.

using UnityEngine;
using UnityEngine.InputSystem;   // gives us InputAction.CallbackContext

[RequireComponent(typeof(CharacterController))]
public class PlayerController : MonoBehaviour
{
    [SerializeField] float moveSpeed = 5f;
    [SerializeField] float jumpSpeed = 6f;
    [SerializeField] float gravity   = -20f;

    CharacterController controller;
    Vector2 moveInput;      // captured in OnMove, applied in Update
    float verticalVelocity;

    void Awake()
    {
        controller = GetComponent<CharacterController>();
    }

    // Wired to the Move (Callback) event on PlayerInput
    public void OnMove(InputAction.CallbackContext context)
    {
        moveInput = context.ReadValue<Vector2>();   // (-1..1, -1..1)
    }

    // Wired to the Jump (Callback) event on PlayerInput
    public void OnJump(InputAction.CallbackContext context)
    {
        // performed == the button went down this frame
        if (context.performed && controller.isGrounded)
            verticalVelocity = jumpSpeed;
    }

    void Update()
    {
        // map the 2D input onto the ground plane (x, z)
        Vector3 horizontal = new Vector3(moveInput.x, 0f, moveInput.y);

        if (controller.isGrounded && verticalVelocity < 0f)
            verticalVelocity = -1f;                 // keep grounded
        verticalVelocity += gravity * Time.deltaTime;

        Vector3 velocity = horizontal * moveSpeed;
        velocity.y = verticalVelocity;

        controller.Move(velocity * Time.deltaTime);
    }
}

Attach this to a GameObject with a CharacterController, add a PlayerInput component pointing at PlayerControls, and wire OnMove/OnJump as in Figure 1. Press Play: WASD (or a gamepad stick) moves the capsule, Space (or the gamepad button, once you add it next lesson) jumps.

The Other Two Approaches

PlayerInput is our default, but you should recognise the alternatives when you meet them in other projects.

Generated C# class

Select the .inputactions asset, tick Generate C# Class in the Inspector, and Apply. Unity writes a class (e.g. PlayerControls) you use directly — no component needed:

using UnityEngine;
using UnityEngine.InputSystem;

public class PlayerControllerGenerated : MonoBehaviour
{
    PlayerControls controls;      // the generated class
    Vector2 moveInput;

    void Awake()
    {
        controls = new PlayerControls();
        controls.Player.Move.performed += ctx => moveInput = ctx.ReadValue<Vector2>();
        controls.Player.Move.canceled  += ctx => moveInput = Vector2.zero;
        controls.Player.Jump.performed += ctx => Jump();
    }

    void OnEnable()  => controls.Player.Enable();
    void OnDisable() => controls.Player.Disable();

    void Jump() { /* ... */ }
}

Great when you want strongly-typed access and no component, but you're responsible for enabling/disabling maps yourself.

Direct InputAction references

Expose an InputActionReference (or a serialized InputAction) and drive it manually:

using UnityEngine;
using UnityEngine.InputSystem;

public class PlayerControllerDirect : MonoBehaviour
{
    [SerializeField] InputActionReference moveAction;   // drag Move here

    void OnEnable()  => moveAction.action.Enable();
    void OnDisable() => moveAction.action.Disable();

    void Update()
    {
        Vector2 move = moveAction.action.ReadValue<Vector2>();
        // ...apply move...
    }
}

Most flexible and closest to the metal, but the most boilerplate — you enable, read, and clean up everything by hand.

Hands-on Challenge

Summary

🚀 What's Next?

Your character moves on keyboard and gamepad already. In Lesson 3.4: Gamepad, Keyboard & Rebinding (the module mini-project) we add multiple bindings and Control Schemes, then build a settings menu that lets players remap Jump at runtime with PerformInteractiveRebinding().