📝 Lesson 2.1: Input and Movement

Moving a Transform

Every GameObject has a Transform (Lesson 1.1) holding its position, rotation, and scale. To move an object, you change that position over time — inside Update, which runs every frame (Lesson 1.2).

Positions and directions in Unity are Vector3 values (x, y, z). There are two common ways to move:

// 1) Translate: move relative to current position by a delta.
transform.Translate(0f, 0f, 1f);        // slide 1 unit along local Z (forward)

// 2) Assign position directly: set an absolute world position.
transform.position = new Vector3(0f, 0f, 5f);

For this lesson we'll build a top-down mover on the X/Z plane (Y is up), so left/right is X and forward/back is Z. But first, the single most important rule of movement.

Why Time.deltaTime?

Update runs once per frame, but frames don't come at a fixed rate — a fast PC might render 200 fps, a slow one 40 fps. If you move a fixed amount per frame, your object moves faster on faster hardware. That's a bug.

void Update()
{
    transform.Translate(0f, 0f, 0.1f);   // ❌ 0.1 units PER FRAME — speed depends on fps
}

The fix: multiply by Time.deltaTime, the number of seconds since the last frame. Now your value means "units per second," identical on every machine.

public float speed = 5f;   // units per SECOND

void Update()
{
    transform.Translate(0f, 0f, speed * Time.deltaTime);   // ✅ frame-rate independent
}

⚠️ Important: This is the counterpart to Lesson 1.2's physics rule. In Update use Time.deltaTime; in FixedUpdate the step is constant (and Time.deltaTime conveniently returns that fixed step there too).

Reading Input (Legacy Manager)

Unity has two input systems. The older Input Manager (the static Input class) needs no setup and is perfect for learning the concepts. We'll start here, then show the modern system.

The two default axes — "Horizontal" (A/D + Left/Right) and "Vertical" (W/S + Up/Down) — return −1 to 1, which is exactly what movement wants:

public class PlayerMover : MonoBehaviour
{
    public float speed = 5f;

    void Update()
    {
        float x = Input.GetAxis("Horizontal");   // A/D or Left/Right → -1..1
        float z = Input.GetAxis("Vertical");     // W/S or Up/Down    → -1..1

        Vector3 move = new Vector3(x, 0f, z);    // top-down: Y stays 0
        transform.Translate(move * speed * Time.deltaTime, Space.World);
    }
}

Building a Movement Vector

The code above has a subtle classic bug: press up and right together and the vector is (1, 0, 1), whose length is about 1.41 — so diagonal movement is ~41% faster than straight. The fix is to normalize the vector (scale it to length 1) before applying speed.

public class PlayerMover : MonoBehaviour
{
    [SerializeField] private float speed = 5f;   // Inspector-tunable (Lesson 1.3)

    void Update()
    {
        float x = Input.GetAxisRaw("Horizontal");
        float z = Input.GetAxisRaw("Vertical");

        Vector3 direction = new Vector3(x, 0f, z);

        // Only normalize when there's actual input (avoids dividing a zero vector).
        if (direction.sqrMagnitude > 1f)
            direction.Normalize();

        transform.Translate(direction * speed * Time.deltaTime, Space.World);
    }
}

💡 Space.World vs Space.Self: Translate defaults to Space.Self (relative to the object's own rotation). For a top-down mover that shouldn't drift when the object turns, pass Space.World so "right" always means world-right.

The Modern Input System

The legacy manager is simple but limited: rebinding keys, supporting gamepads, and handling multiple players are all awkward. Unity's newer Input System package solves this by separating abstract actions ("Move", "Jump") from the physical controls bound to them — so the same code works for keyboard, gamepad, or touch.

The most beginner-friendly path is the PlayerInput component. Add it to your object, assign an Input Actions asset with a "Move" action (type Value, control type Vector2), set its Behavior to Invoke Unity Events or Send Messages, and Unity calls a matching method on your script:

using UnityEngine;
using UnityEngine.InputSystem;   // the new Input System namespace

public class PlayerMoverNew : MonoBehaviour
{
    [SerializeField] private float speed = 5f;
    private Vector2 moveInput;    // stored input, applied every frame

    // Called by the PlayerInput component for the "Move" action (Send Messages mode).
    // The method name is On + the action name.
    public void OnMove(InputValue value)
    {
        moveInput = value.Get<Vector2>();   // e.g. (1, 0) for right, (0, 1) for up
    }

    void Update()
    {
        // Map the 2D input onto the X/Z ground plane.
        Vector3 direction = new Vector3(moveInput.x, 0f, moveInput.y);
        transform.Translate(direction * speed * Time.deltaTime, Space.World);
    }
}

Notice the shape is the same as before — read input, build a direction, move with deltaTime — but now the reading is event-driven and device-agnostic. The Input System already returns a clamped 2D vector, so a diagonal is length 1 without manual normalizing.

Transform vs Physics Movement

Everything above moves the object by writing its Transform directly. That's simple and precise — but it teleports the object, ignoring physics. If your object has a Rigidbody and should collide with walls or be pushed, moving the Transform can shove it straight through colliders.

💡 Preview: Lesson 2.2 covers Rigidbody movement and collisions properly. For now, know the rule: if it needs physics, don't move its Transform — move its Rigidbody in FixedUpdate. Our top-down cube has no Rigidbody, so Transform movement is exactly right.

Exercise & Quiz

using UnityEngine;

public class PlayerMover : MonoBehaviour
{
    [SerializeField] private float speed = 5f;

    void Update()
    {
        // TODO: read Horizontal & Vertical, build a direction on X/Z,
        // normalize it, then Translate by speed * Time.deltaTime in world space.
    }
}

using UnityEngine;

public class PlayerMover : MonoBehaviour
{
    [SerializeField] private float speed = 5f;
    [SerializeField] private float runMultiplier = 2f;

    void Update()
    {
        float x = Input.GetAxisRaw("Horizontal");
        float z = Input.GetAxisRaw("Vertical");

        Vector3 direction = new Vector3(x, 0f, z);
        if (direction.sqrMagnitude > 1f)
            direction.Normalize();

        float currentSpeed = Input.GetKey(KeyCode.LeftShift)
            ? speed * runMultiplier
            : speed;

        transform.Translate(direction * currentSpeed * Time.deltaTime, Space.World);
    }
}

Summary

📚 Additional Resources

• Scripting Reference — Input.GetAxis
• Scripting Reference — Transform.Translate
• Manual — Input System package
• Scripting Reference — Vector3.Normalize

🚀 What's Next?

Our cube slides around, but it walks through walls. In Lesson 2.2, Physics and Collisions, we add a Rigidbody and colliders so objects bump, stack, and trigger events — and you'll see exactly why physics movement lives in FixedUpdate.