Working with CharacterController

Make a player walk, jump and bump into walls, with full control over how the movement feels.

CharacterController or Rigidbody?

Pick one. Don't put a CharacterController, a Rigidbody and a NavMeshAgent on the same object; they'll fight over who moves it.

Set up

1. Make a floor, a few boxes, a small step and a ramp.
2. Create an empty Player at (0, 1, 0) and add a CharacterController (Height 2, Radius 0.5). Put your model underneath as a child.
3. Make sure the Input System package is installed (see here).
4. Add the script below to Player and drag your camera into View.

The movement script

using UnityEngine;
using UnityEngine.InputSystem;

[RequireComponent(typeof(CharacterController))]
public class PlayerMovement : MonoBehaviour
{
    [SerializeField] private Transform view;          // the camera
    [SerializeField] private float speed = 5f;         // metres per second
    [SerializeField] private float jumpHeight = 1.5f;  // metres
    [SerializeField] private float gravity = -20f;     // negative = pulls down

    private CharacterController controller;
    private float verticalSpeed;                       // how fast we're rising/falling

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

    void Update()
    {
        var keyboard = Keyboard.current;
        if (keyboard == null) return;

        // 1. Read WASD as a 2D input
        Vector2 input = Vector2.zero;
        if (keyboard.wKey.isPressed) input.y += 1;
        if (keyboard.sKey.isPressed) input.y -= 1;
        if (keyboard.dKey.isPressed) input.x += 1;
        if (keyboard.aKey.isPressed) input.x -= 1;
        input = Vector2.ClampMagnitude(input, 1f);    // diagonals aren't faster

        // 2. Turn it into a direction relative to the camera, flat on the ground
        Vector3 forward = view.forward; forward.y = 0; forward.Normalize();
        Vector3 right   = view.right;   right.y = 0;   right.Normalize();
        Vector3 move = (forward * input.y + right * input.x) * speed;

        // 3. Gravity and jumping
        if (controller.isGrounded && verticalSpeed < 0)
            verticalSpeed = -2f;                       // keep pressed onto the floor
        if (controller.isGrounded && keyboard.spaceKey.wasPressedThisFrame)
            verticalSpeed = Mathf.Sqrt(jumpHeight * -2f * gravity);
        verticalSpeed += gravity * Time.deltaTime;
        move.y = verticalSpeed;

        // 4. Move once per frame. The controller handles walls and floors.
        controller.Move(move * Time.deltaTime);
    }
}

To support gamepads and rebinding, swap step 1 for an InputAction. The rest stays the same.

Why it works

• Time.deltaTime turns "metres per second" into "metres this frame", so speed is the same at 30 FPS and 144 FPS.
• verticalSpeed is remembered between frames. Gravity makes it more negative every frame, so you fall faster and faster, like real falling.
• The jump formula Sqrt(height * -2 * gravity) is the launch speed needed to reach exactly jumpHeight.
• -2f when grounded keeps pushing gently down so isGrounded stays true while walking down ramps.

Move vs SimpleMove

Inspector settings

Going further

• Coyote time: remember when you were last on the ground and allow a jump for ~0.1 s after walking off a ledge. It makes jumping feel much fairer.
• Pushing boxes: OnControllerColliderHit(ControllerColliderHit hit) runs when you bump into something. If hit.rigidbody isn't null, push it with AddForce.
• Moving platforms: the controller doesn't ride along automatically. Add the platform's movement for this frame to your own Move.

Common Mistakes

• Setting transform.position directly. That skips collision and you walk through walls. Use Move.
• Calling Move twice per frame (once for walking, once for gravity). isGrounded only reflects the last call, so combine them into one.
• Forgetting Time.deltaTime with Move, or adding it to SimpleMove.
• Using .normalized on stick input. Slow walking then becomes impossible. Use ClampMagnitude.

See also

• Using the Input System
• Update & FixedUpdate
• Simple State Machines

This page is a simplified, AI-assisted interpretation. For the complete and authoritative reference, see the official documentation.