Unity 3D Tutorial: Seu Primeiro Jogo 3D na Unity

Este unity 3d tutorial monta um jogo 3D completo só com formas primitivas: uma bola que rola pelo tabuleiro com física, itens para coletar, contador na tela, câmera que segue o jogador e uma mensagem de vitória quando o último item some. Tudo em C# do Unity 6, com o Input System e o Rigidbody.

Por que primitivas e não um personagem bonito da Asset Store? Porque o primeiro jogo 3D tem que ensinar o que todo projeto 3D vai cobrar de você: eixos, escala em metros, física e luz. Com um modelo importado, metade dos problemas vira "o modelo veio gigante", "o personagem está deitado" ou "está tudo escuro", e você não sabe se o erro é seu ou do arquivo. Com cubos e esferas, cada problema tem uma causa só.

O que dá para fazer no primeiro jogo 3D

O escopo certo é pequeno: uma cena, um objeto controlado pelo jogador, uma regra de vitória. O jogo deste post tem exatamente isso, e cabe numa tarde.

O que você aprende no caminho:

• Eixos da Unity: Y aponta para cima, X para a direita e Z para frente (para dentro da tela, na vista padrão). Movimento no chão acontece em X e Z, não em X e Y como no 2D.
• Escala: a física trata 1 unidade como 1 metro. O cubo padrão tem 1 m de lado; a esfera padrão, 1 m de diâmetro.
• Física com força: a bola não se teleporta, ela é empurrada e ganha inércia.
• Trigger: área que detecta contato sem bater.
• Câmera: seguir o jogador sem girar junto com a bola.
• Luz: por que a cena fica escura e como ajustar.

Se for escolher engine para algo maior em 3D depois, o comparativo de melhor engine para jogos 3D ajuda.

Criar o projeto Universal 3D

No Unity Hub, Projects > New project, versão Unity 6.3 LTS, template Universal 3D. É um projeto vazio com a URP configurada para 3D. Nomeie BolaColetora e crie.

A cena de exemplo já vem com uma Main Camera e uma Directional Light. Deixe as duas.

Cena com primitivas: chão, paredes e itens

Chão: na Hierarchy, 3D Object > Plane. Posição (0, 0, 0), escala (2, 1, 2). O Plane padrão mede 10 x 10 m; com escala 2, o tabuleiro fica com 20 x 20 m.

Paredes: crie um 3D Object > Cube para cada lado:

Repare no Y em 0,5: o cubo tem 1 m de altura e o pivô fica no centro, então subir meio metro apoia a parede no chão. Esse raciocínio de "pivô no centro" vale para todo objeto primitivo.

Bola: 3D Object > Sphere, nome Bola, posição (0, 0.5, 0).

Itens: um Cube com escala (0.5, 0.5, 0.5), posição (3, 0.5, 3), nome Item. Rotacione (45, 45, 45) para ficar com cara de coletável. No Box Collider, marque Is Trigger. Crie a tag Item em Tag > Add Tag e aplique.

Cores: no Project, Create > Material. O material padrão da URP usa o shader Universal Render Pipeline/Lit. Mude a Base Map para uma cor e arraste o material sobre o objeto. Faça um para a bola, um para os itens e um para as paredes.

Mover a bola com Rigidbody e AddForce

Na Bola, Add Component > Rigidbody. Deixe Mass em 1 e coloque Linear Damping em 0.5, para a bola ir perdendo velocidade aos poucos quando você solta o controle. Na Unity 6 esse campo se chama Linear Damping; em tutoriais antigos aparece como drag.

Crie o script. Arquivo Bola.cs:

using UnityEngine;
using UnityEngine.InputSystem;

public class Bola : MonoBehaviour
{
    [SerializeField] private Rigidbody rb;
    [SerializeField] private float forca = 10f;

    private InputAction acaoMover;
    private Vector2 entrada;

    private void Awake()
    {
        acaoMover = InputSystem.actions.FindAction("Move");
    }

    private void Update()
    {
        entrada = acaoMover.ReadValue<Vector2>();
    }

    private void FixedUpdate()
    {
        Vector3 direcao = new Vector3(entrada.x, 0f, entrada.y);
        rb.AddForce(direcao * forca, ForceMode.Force);
    }
}

O ponto mais importante do código é a linha do Vector3. A ação Move devolve um Vector2 (x para os lados, y para frente e trás no teclado). No 3D, "frente" é o eixo Z, então o y da entrada vira o z do mundo. Esquecer isso é o erro número um de quem vem do 2D: a bola tenta voar em vez de rolar.

Sobre o ForceMode, a Unity tem quatro modos:

• Force: força contínua, considera a massa. Bom para empurrar a cada passo de física, como aqui.
• Acceleration: aceleração contínua, ignora a massa.
• Impulse: empurrão instantâneo, considera a massa. Bom para pulo e explosão.
• VelocityChange: muda a velocidade na hora, ignora a massa.

Se a física e os vetores ainda estão abstratos, o post de matemática para jogos com vetores explica direção, magnitude e normalização com exemplos de jogo. E a comparação detalhada entre empurrar com força e definir velocidade direto está em Rigidbody, AddForce e velocity na Unity.

Anexe o script, arraste o Rigidbody para o campo Rb e aperte Play. A bola rola com WASD ou setas.

Coletar itens com trigger e contar pontos

Crie um Canvas com texto: Hierarchy, menu UI (Canvas), texto do TextMeshPro (aceite Import TMP Essentials). Nomeie TextoItens e ancore no canto. Crie um segundo texto, TextoVitoria, centralizado, escrito "Você venceu!".

Crie um objeto vazio Gerenciador. Arquivo ContadorDeItens.cs:

using TMPro;
using UnityEngine;

public class ContadorDeItens : MonoBehaviour
{
    [SerializeField] private TMP_Text textoItens;
    [SerializeField] private GameObject textoVitoria;

    private int total;
    private int coletados;

    private void Start()
    {
        total = GameObject.FindGameObjectsWithTag("Item").Length;
        textoVitoria.SetActive(false);
        AtualizarTexto();
    }

    public void Coletar()
    {
        coletados++;
        AtualizarTexto();

        if (coletados >= total)
        {
            textoVitoria.SetActive(true);
        }
    }

    private void AtualizarTexto()
    {
        textoItens.text = coletados + " / " + total;
    }
}

Na Bola, acrescente o campo do contador e o método de trigger. O Bola.cs completo fica:

using UnityEngine;
using UnityEngine.InputSystem;

public class Bola : MonoBehaviour
{
    [SerializeField] private Rigidbody rb;
    [SerializeField] private ContadorDeItens contador;
    [SerializeField] private float forca = 10f;

    private InputAction acaoMover;
    private Vector2 entrada;

    private void Awake()
    {
        acaoMover = InputSystem.actions.FindAction("Move");
    }

    private void Update()
    {
        entrada = acaoMover.ReadValue<Vector2>();
    }

    private void FixedUpdate()
    {
        Vector3 direcao = new Vector3(entrada.x, 0f, entrada.y);
        rb.AddForce(direcao * forca, ForceMode.Force);
    }

    private void OnTriggerEnter(Collider outro)
    {
        if (!outro.CompareTag("Item"))
        {
            return;
        }

        contador.Coletar();
        Destroy(outro.gameObject);
    }
}

Para os itens girarem, arquivo Girar.cs:

using UnityEngine;

public class Girar : MonoBehaviour
{
    [SerializeField] private Vector3 grausPorSegundo = new Vector3(0f, 90f, 0f);

    private void Update()
    {
        transform.Rotate(grausPorSegundo * Time.deltaTime, Space.World);
    }
}

Anexe Girar ao Item, arraste o Item para uma pasta Prefabs e espalhe umas oito cópias pelo tabuleiro. O contador conta sozinho quantos itens com a tag existem no início.

Até aqui, um script por responsabilidade: a bola se move e coleta, o contador cuida da regra, o item só gira. Essa separação parece exagero num jogo de 4 scripts, mas é ela que impede um jogo maior de virar um arquivo de mil linhas. Organizar sistemas assim, com câmera, animação, inimigos, fases e menus conversando sem quebrar, é o que transforma um protótipo em jogo, e é onde quem estuda sozinho mais trava.

Câmera que segue e luz básica

Se a câmera for filha da bola, ela gira junto e o jogador fica tonto. O certo é a câmera copiar só a posição. Arquivo CameraSegue.cs:

using UnityEngine;

public class CameraSegue : MonoBehaviour
{
    [SerializeField] private Transform alvo;

    private Vector3 deslocamento;

    private void Start()
    {
        deslocamento = transform.position - alvo.position;
    }

    private void LateUpdate()
    {
        transform.position = alvo.position + deslocamento;
    }
}

Posicione a Main Camera em (0, 10, -10) com rotação (45, 0, 0), anexe o script e arraste a Bola para Alvo. O LateUpdate roda depois de todos os Update, então a câmera sempre usa a posição final da bola naquele frame.

Luz: selecione a Directional Light. A posição dela não importa, só a rotação, porque ela simula o sol. Gire em X para mudar a altura do sol: perto de 50° dá sombras curtas e cena clara; perto de 10° dá sombras longas de fim de tarde. Em Intensity, valores entre 1 e 2 funcionam bem nesse tipo de cena. Se a cena estiver escura demais, confira Window > Rendering > Lighting, aba Environment: a luz ambiente vem do skybox por padrão.

Erros comuns neste unity 3d tutorial

A bola sobe ou desce em vez de andar: você usou new Vector3(entrada.x, entrada.y, 0f). O y da entrada vai no z.

A bola não se move: faltou arrastar o Rigidbody no campo Rb, ou a força está baixa para a massa. Com massa 1, força 10 é um bom começo.

A bola desliza para sempre: Linear Damping em zero. Suba para 0,5 ou 1.

Itens empurram a bola: o collider do item está sem Is Trigger.

O contador começa em "0 / 0": os itens estão sem a tag Item, ou com grafia diferente.

Câmera tremendo: a câmera está atualizando no Update. Use LateUpdate. Se ainda tremer, ative Interpolate no Rigidbody da bola.

Objetos afundando no chão: o Y do objeto está abaixo de metade da altura dele. Lembre do pivô no centro.

Tudo cinza: o material novo está sem cor ou o objeto continua com o material padrão. Arraste o material para o objeto na Scene, não para o Project.

Próximo passo: modelos, animação e Cinemachine

Com a cena de primitivas funcionando, você pode trocar peça por peça sem perder o controle:

1. Modelos: importe um .fbx ou .glb e confira a escala comparando com o cubo de 1 m.
2. ProBuilder: pacote oficial para modelar fases dentro da Unity, ótimo para blocar cenários antes de ter arte final.
3. Personagem com animação: um modelo com Animator e um CharacterController, que é outro jeito de mover, sem força física.
4. Cinemachine: o pacote de câmeras da Unity. Na versão 3, o componente principal é o CinemachineCamera, e ele faz seguir, olhar e suavizar sem script.
5. Fases: duas cenas e uma transição entre elas quando todos os itens forem coletados.

Faça um de cada vez, testando no Play a cada passo. A regra que vale para o primeiro jogo vale para todos os outros.