Third Person Controller na Unity: Starter Assets e Código

Para ter um unity third person controller funcionando você tem dois caminhos: importar o pacote gratuito de character controllers da própria Unity, que vem com personagem, animações e câmera prontos, ou escrever o seu com CharacterController e uma câmera orbital do Cinemachine 3. Este post mostra os dois, com o passo a passo de cada um no Unity 6.3 LTS, e termina com um critério honesto de quando cada um vale a pena.

Spoiler do critério: pacote pronto para validar ideia rápido, código próprio quando o movimento é o coração do jogo. Mas o pacote também é uma ótima aula de leitura de código, e a seção sobre o script dele mostra o que olhar.

Unity third person controller: dois caminhos

Caminho 1, o pacote da Unity. Os antigos "Starter Assets" da Unity, hoje listados na Asset Store como First Person + Third Person | Character Controllers. Em 19/10/2026 a página mostra a versão 2.0.1, de 18/09/2026, gratuita, com compatibilidade marcada para o Unity 6000.3 no URP. Built-in e HDRP aparecem como não compatíveis nas versões recentes do editor, então o projeto precisa ser URP.

Caminho 2, o seu código. Um CharacterController com movimento relativo à câmera e rotação suave, mais uma CinemachineCamera com Orbital Follow. No Unity 6.3 LTS, o manual lista o Cinemachine 3.1.7 como a versão do pacote para esse editor. São dois scripts curtos e configuração no Inspector.

A diferença prática: no primeiro você tem um personagem bonito andando em dez minutos e um script de várias centenas de linhas que não escreveu. No segundo você leva uma tarde e entende cada linha.

Instalar o pacote Third Person

1. Crie o projeto com o template Universal 3D (URP).
2. Na Asset Store, adicione o pacote First Person + Third Person Character Controllers à sua conta (é gratuito).
3. No editor, Window > Package Management > Package Manager, aba My Assets, encontre o pacote, Download e Import.
4. O pacote depende do Input System e do Cinemachine. Se o editor perguntar sobre instalar dependências ou ativar o novo backend de input, aceite. Em projetos novos do Unity 6 o Input System já está ativo.
5. Abra a cena de exemplo do pacote (nas versões 1.x ela se chamava Playground, dentro de StarterAssets/ThirdPersonController/Scenes). Dê Play.

Depois de importar, abra Window > Package Management > Package Manager > In Project e confira a versão do Cinemachine que ficou instalada. Isso importa para a seção de câmera: os nomes de componentes do Cinemachine 2 e do 3 são diferentes, e misturar tutorial de uma versão com pacote da outra é a causa número um de "o componente não aparece".

Trocar o personagem pelo seu modelo

O personagem do pacote é humanoide, e as animações também. Isso permite trocar a malha por qualquer modelo humanoide sem refazer animação:

1. Selecione o seu modelo (FBX) no Project. Aba Rig, Animation Type Humanoid, Avatar Definition Create From This Model, Apply. Se o botão Configure mostrar ossos em vermelho, o mapeamento precisa de ajuste manual.
2. Na cena, abra o prefab do jogador do pacote (nas versões 1.x, PlayerArmature).
3. Arraste o seu modelo para dentro dele, como filho, na posição (0, 0, 0).
4. Desative ou apague a malha e o esqueleto originais (nas versões 1.x, os filhos Geometry e Skeleton).
5. No componente Animator do objeto raiz, troque o campo Avatar pelo Avatar do seu modelo.
6. Ajuste o CharacterController (Height, Radius, Center) para a cápsula envolver o seu personagem. Se ele for bem mais alto ou mais baixo, mova também o alvo da câmera (nas versões 1.x, PlayerCameraRoot) para a altura do ombro.

Modelo que não é humanoide (um robô de quatro patas, uma criatura) não aproveita as animações; nesse caso o caminho 2 costuma ser mais simples.

Entender o script do Starter Assets

Ler o script do pacote é uma aula de controller em terceira pessoa. Nas versões 1.x, ele se divide em:

• StarterAssetsInputs: recebe o input e guarda em campos simples (move, look, jump, sprint). O controller nunca fala com o Input System diretamente; isso permite trocar o input por touch na tela, que é o que a UI mobile do pacote faz.
• ThirdPersonController: no Update chama, em ordem, gravidade e pulo, checagem de chão e movimento; no LateUpdate, a rotação da câmera. Vale procurar estes pontos:
  • Ground check com Physics.CheckSphere numa esfera levemente abaixo dos pés, independente do isGrounded.
  • Velocidade alvo com aceleração, usando Mathf.Lerp para suavizar a troca entre andar e correr.
  • Rotação suave com Mathf.SmoothDampAngle na direção do movimento relativa à câmera.
  • Look sem deltaTime para mouse: o código multiplica o input de olhar por Time.deltaTime só quando o dispositivo atual não é mouse, porque o delta do mouse já é por frame.
  • Timeouts de pulo e queda para evitar pulo repetido e animação de queda em degraus.

Se a versão 2 que você baixar tiver reorganizado os arquivos, procure esses mesmos conceitos: eles são a base de qualquer controller desse tipo.

Ler código pronto ensina, mas não ensina a decidir. Quando o seu jogo pede escalada, combate com trava de mira, troca de câmera numa cutscene e um save que guarda a posição do jogador, adaptar um script grande escrito para outra finalidade vira briga. Saber montar esses sistemas do zero e fazê-los conversar dentro de um jogo inteiro é o que o curso de Unity trabalha em projeto, e é onde quem estuda sozinho mais costuma travar.

Fazer o seu com CharacterController

O controller próprio tem um script de movimento e uma câmera do Cinemachine. Crie ThirdPersonMover.cs no objeto Player, que também tem um CharacterController:

using UnityEngine;
using UnityEngine.InputSystem;

[RequireComponent(typeof(CharacterController))]
public class ThirdPersonMover : MonoBehaviour
{
    [SerializeField] private float walkSpeed = 4f;
    [SerializeField] private float runSpeed = 7f;
    [SerializeField] private float turnSpeed = 720f;
    [SerializeField] private float gravity = -20f;
    [SerializeField] private CharacterController controller;
    [SerializeField] private Transform cameraTransform;

    private InputAction moveAction;
    private InputAction sprintAction;
    private float verticalVelocity;

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

        if (cameraTransform == null && Camera.main != null)
        {
            cameraTransform = Camera.main.transform;
        }

        moveAction = InputSystem.actions.FindAction("Move");
        sprintAction = InputSystem.actions.FindAction("Sprint");
    }

    private void Update()
    {
        Vector2 input = Vector2.ClampMagnitude(moveAction.ReadValue<Vector2>(), 1f);

        Vector3 forward = cameraTransform.forward;
        Vector3 right = cameraTransform.right;
        forward.y = 0f;
        right.y = 0f;
        forward.Normalize();
        right.Normalize();

        Vector3 direction = forward * input.y + right * input.x;
        float speed = sprintAction != null && sprintAction.IsPressed() ? runSpeed : walkSpeed;

        if (direction.sqrMagnitude > 0.0001f)
        {
            Quaternion target = Quaternion.LookRotation(direction, Vector3.up);
            transform.rotation = Quaternion.RotateTowards(transform.rotation, target, turnSpeed * Time.deltaTime);
        }

        if (controller.isGrounded && verticalVelocity < 0f)
        {
            verticalVelocity = -2f;
        }

        verticalVelocity += gravity * Time.deltaTime;

        Vector3 velocity = direction * speed;
        velocity.y = verticalVelocity;
        controller.Move(velocity * Time.deltaTime);
    }
}

O ponto central é o movimento relativo à câmera: forward e right da câmera, achatados no plano e normalizados, combinados com o input. W anda para onde a câmera olha, não para o norte do mundo. A rotação usa RotateTowards com velocidade constante em graus por segundo. Essa é a versão enxuta; a explicação completa de cada decisão (aceleração, diagonal, Slerp contra RotateTowards) está no script de movimento 3D desta série.

Câmera orbital com Cinemachine 3

No Cinemachine 3 não existe mais um componente FreeLook separado. A câmera livre é uma CinemachineCamera com três comportamentos:

• Orbital Follow: define a posição da câmera numa órbita em volta do alvo.
• Rotation Composer: mantém a câmera mirando o alvo de qualquer posição da órbita.
• Input Axis Controller: lê o mouse ou o analógico para girar a órbita.

Passo a passo:

1. Instale o Cinemachine pelo Package Manager, se ainda não estiver no projeto.
2. Crie um objeto vazio CameraTarget filho do Player, na altura do ombro (por volta de 1,5 m).
3. GameObject > Cinemachine > FreeLook Camera. A Unity cria a CinemachineCamera com os três comportamentos e adiciona um CinemachineBrain na Main Camera.
4. No campo Tracking Target da CinemachineCamera, arraste o CameraTarget.
5. No Orbital Follow, ajuste o raio e a altura das órbitas até o enquadramento ficar bom com o personagem parado.
6. Dê Play: mouse ou analógico giram a câmera, e o ThirdPersonMover anda na direção para onde ela olha, porque ele lê o transform da Main Camera, que o Brain controla.

Colisão da câmera com parede, ombro deslocado para mira e troca entre câmeras ficam no tutorial dedicado de câmera em terceira pessoa com Cinemachine, para não repetir aqui. Se quiser ver a mesma ideia de órbita feita à mão, sem pacote, o post de câmera em terceira pessoa no Godot monta pivô e braço de câmera passo a passo.

Qual caminho escolher

• Game jam, protótipo, teste de ideia: pacote pronto. Você valida se o jogo é divertido antes de investir em movimento.
• Jogo cujo diferencial é o movimento (plataforma 3D, parkour, ação com combate): código próprio. Cada ajuste fino que o seu jogo pedir vai exigir entender o controller por dentro.
• Estudo: os dois, nessa ordem. Faça o seu, depois leia o do pacote e compare decisões.

Se você ainda está decidindo se a Unity é a engine certa para o seu projeto, o post sobre se vale a pena aprender Unity cobre esse ponto com mais calma.

Erros comuns

Pacote importado, personagem rosa. O projeto não é URP. Crie o projeto com o template Universal 3D ou converta os materiais.

CinemachineVirtualCamera não existe. Tutorial do Cinemachine 2 num projeto com Cinemachine 3. O equivalente é CinemachineCamera.

Personagem anda para o norte do mundo, não para a câmera. O script lê a câmera errada, ou lê Vector3.forward em vez de cameraTransform.forward.

Modelo novo em pose T e deslizando. O Avatar do Animator ainda é o do modelo antigo, ou o seu modelo não está como Humanoid.

Câmera treme. O Player está sendo movido no FixedUpdate ou tem um Rigidbody junto com o CharacterController.

Próximo passo

Escolha um caminho e monte uma pista de teste com rampa, escada, um vão para pular e um corredor estreito. Com a câmera orbital funcionando, o passo seguinte é a colisão da câmera com o cenário, que é o próximo problema que você vai ver no corredor estreito.