Aprenda a usar 7 funções cruciais para desenvolver jogos na Unity

Você está criando seu primeiro jogo na Unity (ou o segundo, ou terceiro…) e quer aprender sobre ou reconferir algumas das funções mais usadas em uma das engines de criação de jogos mais consolidadas no mundo?

A Unity é uma ferramenta poderosa popularmente usada por estúdios indies (independentes de investimentos terceiros) onde jogadores resolvem se tornar “donos de sua própria história”, desenvolvendo o seu próprio projeto.

O número de estúdios indie de desenvolvedores de jogos têm crescido a cada ano e as ferramentas têm se tornado cada vez mais poderosas. Aqui, veremos 7 ferramentas básicas, porém indispensáveis, se você está aprendendo a criar o seu próprio jogo ou já está desenvolvendo há um tempo. Também há explicações de como usar tais ferramentas.

1. NavMesh – Como Criar Navegação de IA (AI Navigation 2.0)

NavMesh é uma ferramenta da Unity que mapeia áreas navegáveis dentro do cenário do jogo, permitindo que inteligências artificiais encontrem automaticamente o melhor caminho entre dois pontos, como do ponto A ao B.

Ela é ideal para criar sistemas de movimentação de NPCs (personagens não controláveis), como inimigos em jogos de RPG, patrulhas, tráfego de veículos e muito mais.

Na Unity 6, o sistema de navegação foi aprimorado com o pacote AI Navigation 2.0, permitindo maior flexibilidade e controle sobre a movimentação de agentes no ambiente do jogo.

Como usar?

🧩 Instalação do pacote necessário

Antes de começar, você precisa instalar o pacote responsável por ativar o sistema de navegação na Unity:

• Vá em Window > Package Manager.
• No canto superior esquerdo, troque o filtro para Unity Registry.
• Procure por AI Navigation.
• Clique em Install.

Esse pacote traz todas as ferramentas necessárias para gerar e usar mapas de navegação (NavMesh) no seu projeto.

🏗️ Preparar os objetos do cenário

Agora você precisa dizer para a Unity quais partes do cenário fazem parte do “chão” por onde a IA poderá andar.

• Selecione um ou mais objetos (como piso, ruas, plataformas).
• No Inspector, marque a opção Navigation Static.
  Isso informa à Unity que o objeto não se moverá e deve ser considerado no cálculo da navegação.
• Importante: só objetos marcados como Navigation Static entram no cálculo do NavMesh.

📐 Abrir a janela de navegação e gerar o mapa

• Vá em Window > AI > Navigation.
• Na janela que abrir, vá até a aba Bake.
• Nela, você encontrará as principais configurações do agente que vai andar pelo mapa:
  • Agent Radius: quão largo é o personagem (evita que ele passe em locais estreitos demais).
  • Agent Height: altura total do personagem (evita passar por lugares baixos).
  • Max Slope: inclinação máxima que o personagem pode subir.
  • Step Height: altura dos degraus que ele pode subir automaticamente.
• Quando tudo estiver configurado, clique em Bake.
• A Unity vai gerar um NavMesh, e as áreas por onde o personagem pode andar aparecerão coloridas em azul na cena.

🚶‍♂️ Preparar o personagem controlado pela IA

Agora você precisa preparar o NPC, inimigo ou personagem controlado por IA que vai andar pelo NavMesh:

• Selecione o personagem na Hierarquia.
• No Inspector, clique em Add Component.
• Adicione o componente chamado NavMeshAgent.

Esse componente é o cérebro de navegação do personagem. Ele vai fazer com que ele “saiba” como andar pelas áreas do NavMesh, evitando obstáculos.

💻 Mover o personagem por script

Para fazer o personagem se mover para um ponto específico, você usa o método SetDestination() do NavMeshAgent. Exemplo de script simples:

using UnityEngine;
using UnityEngine.AI;

public class MoverIA : MonoBehaviour
{
    [Header("Configurações")]
    public LayerMask layerAlvo; // Camada dos objetos que podem ser selecionados
    public float raioDetecao = 100f; // Distância máxima do raycast
    private NavMeshAgent agente;
    private Transform alvoAtual;
    private Camera cam;

    void Start()
    {
        agente = GetComponent<NavMeshAgent>();
        cam = Camera.main;
    }

    void Update()
    {
        // Movimento contínuo para o alvo atual
        if (alvoAtual != null)
        {
            agente.SetDestination(alvoAtual.position);
        }

        // Detecção de clique
        if (Input.GetMouseButtonDown(0))
        {
            DefinirNovoAlvoPorClique();
        }
    }

    private void DefinirNovoAlvoPorClique()
    {
        Ray raio = cam.ScreenPointToRay(Input.mousePosition);
        RaycastHit hit;

        if (Physics.Raycast(raio, out hit, raioDetecao, layerAlvo))
        {
            // Define o novo alvo
            alvoAtual = hit.transform;
            Debug.Log("Novo alvo definido: " + alvoAtual.name);
        }
    }
}

Como usar esse script:

1. Crie um novo script chamado “MoverIA” e cole esse código.
2. Anexe esse script ao personagem com o NavMeshAgent.
3. Crie um objeto vazio ou marcador onde o personagem deve ir (por exemplo, “PontoDeDestino”).
4. No Inspector, arraste esse objeto para o campo alvo do script.

O personagem agora vai se mover automaticamente até o destino definido, evitando paredes e obstáculos.

2. Rigidbody – Como Criar Física no Seu Jogo

O Rigidbody permite aplicar física aos objetos, trazendo mais camadas de realismo. Com ele, você pode aplicar força a algum movimento, detectar colisões com precisão e permitir que objetos reajam à gravidade.

O Rigidbody é um dos componentes mais importantes da Unity. Ele permite que um objeto obedeça às leis da física, como gravidade, colisão e força. Com isso, um objeto pode cair, ser empurrado, bater em outro e se mover de maneira natural, sem que você precise animar tudo manualmente.

Imagine uma bola que cai quando você a solta. Ou uma caixa que é empurrada quando um personagem encosta. Quem cuida disso na Unity é o Rigidbody.

🛠️ Como adicionar Rigidbody a um objeto

1. Selecione o objeto na Hierarquia (por exemplo, uma esfera ou caixa).
2. Vá no Inspector (painel à direita).
3. Clique em Add Component.
4. Digite Rigidbody e selecione o componente da lista.

Depois disso, a Unity automaticamente aplica física a esse objeto: ele começa a cair, bater em outros objetos e ser influenciado por forças.

⚙️ Entendendo as propriedades

Ao adicionar o Rigidbody, você verá algumas opções importantes:

• Mass (massa): define o peso do objeto. Objetos mais pesados são mais difíceis de empurrar.
• Drag (arrasto): define a resistência ao movimento. Como o atrito com o ar.
• Angular Drag: resistência ao giro do objeto.
• Use Gravity: se estiver marcado, o objeto será puxado para baixo (gravidade ativada).
• Is Kinematic: se ativado, a física será ignorada — você controla o movimento manualmente via script.

💥 Como mover o objeto com força (empurrão)

Para aplicar uma força (como um chute ou empurrão), você pode fazer isso por script:

csharpCopiarEditarRigidbody rb = GetComponent<Rigidbody>();
rb.AddForce(Vector3.forward * 10f);

Esse código empurra o objeto para frente, com uma força de intensidade 10. Você pode usar outras direções como Vector3.up (para cima), Vector3.left, Vector3.back, etc.

🆕 Importante: linearVelocity na Unity 6

Se você quiser definir ou checar a velocidade de um objeto manualmente, antes usávamos:

csharpCopiarEditarrb.velocity = new Vector3(5, 0, 0);

Agora, na Unity 6, o correto é usar:

csharpCopiarEditarrb.linearVelocity = new Vector3(5, 0, 0);

A Unity mudou de velocity para linearVelocity para deixar o nome mais técnico e coerente com os outros sistemas físicos do motor.

🎯 Exemplo completo de uso:

csharpCopiarEditarusing UnityEngine;

public class Bola : MonoBehaviour
{
    Rigidbody rb;

    void Start()
    {
        rb = GetComponent<Rigidbody>();

        // Empurrar a bola para frente ao iniciar
        rb.AddForce(Vector3.forward * 200f);
    }

    void Update()
    {
        // Pressione a barra de espaço para empurrar para cima
        if (Input.GetKeyDown(KeyCode.Space))
        {
            rb.AddForce(Vector3.up * 300f);
        }
    }
}

Esse script pode ser usado em uma bola. Ao iniciar o jogo, ela será empurrada para frente. Quando o jogador apertar espaço, a bola é lançada para cima.

3. Animator e Animações – Como Animar Personagens na Unity

O sistema de animações da Unity permite dar vida ao seu personagem: fazer ele andar, correr, pular, atacar, morrer… Tudo de forma controlada e fluida, sem precisar programar cada movimento manualmente.

Esse sistema funciona com estados de animação e transições entre eles. Você cria uma “lógica de comportamento” que diz quando e como cada animação deve acontecer.

A Unity usa um sistema chamado Mecanim, que organiza as animações em uma “máquina de estados” (Animator Controller). Cada estado representa uma animação, como:

• “Idle” (parado)
• “Walk” (andando)
• “Jump” (pulando)
• “Attack” (atacando)

Você pode ligar e desligar essas animações automaticamente, com base nas ações do personagem ou eventos do jogo.

🎬 Criação ou importação das animações

Você pode:

• Criar animações diretamente na Unity (para objetos simples).
• Ou importar animações prontas (em .anim, .fbx, .blend, etc.).

Cada animação define o que deve acontecer com o objeto (como ele se move ou muda de posição ao longo do tempo).

🧠 Criar o Animator Controller

Esse é o “cérebro” que gerencia qual animação deve estar ativa.

Como fazer:

1. Clique com o botão direito no painel Project.
2. Vá em Create > Animator Controller.
3. Dê um nome (por exemplo, PlayerAnimator).
4. Selecione o seu personagem e, no Inspector, arraste esse Animator Controller para o campo Controller dentro do componente Animator.

🔁 Adicionar e configurar os estados de animação

1. Dê dois cliques no Animator Controller criado.
2. A janela Animator será aberta.
3. Arraste as animações para a área do gráfico — elas vão virar “blocos” chamados states.
4. Clique com o botão direito em um deles e selecione Set as Default State (normalmente, o “Idle”).
5. Crie transições (setas) entre os estados clicando com o botão direito > Make Transition.

🧩 Adicionar parâmetros (para controlar as animações)

No painel Animator, vá na aba Parameters e clique em:

• + Bool (ex: isWalking)
• + Trigger (ex: jump)
• + Float (ex: speed)

Esses parâmetros funcionam como “interruptores” que o script pode ligar/desligar para trocar de animação.

💻 Controlar as animações via código

Exemplo simples:

csharpCopiarEditarAnimator animator;

void Start() {
    animator = GetComponent<Animator>();
}

void Update() {
    float movimento = Input.GetAxis("Horizontal");

    // Ativa a animação de andar se o jogador estiver se movendo
    animator.SetBool("isWalking", movimento != 0);
}

Com isso, toda vez que o jogador apertar a tecla de movimentação, a animação de andar deverá ser ativada. Quando soltar, o personagem voltará ao estado parado.

Com esse sistema, você pode montar uma lógica completa de comportamento animado para qualquer personagem. E o melhor: sem precisar mudar manualmente a animação a cada segundo. A Unity faz isso pra você, com base nos parâmetros que você define e controla no código.

4. Input System – Como configurar o Controle do Jogador

O Input System é o sistema da Unity para lidar com os comandos do jogador — como pressionar botões, usar o teclado, mouse, controle (joystick) ou até toques em telas móveis.

Esse sistema atual é muito mais flexível e poderoso que o sistema antigo (que era chamado de Input Manager), permitindo configurar os controles de maneira visual, clara e compatível com múltiplos dispositivos sem precisar reescrever o código para cada tipo de entrada.

📦 Instalação do pacote

Antes de tudo, você precisa ativar o Input System no seu projeto:

1. Vá em Window > Package Manager.
2. Mude o filtro para Unity Registry.
3. Busque por Input System.
4. Clique em Install.
5. Ao final, a Unity pode pedir para reiniciar o projeto (aceite).

🎮 Criação do Input Actions Asset

O Input Actions Asset é onde você define todos os comandos que o jogador poderá usar (como “andar”, “pular”, “atacar”).

1. Clique com o botão direito no Project.
2. Vá em Create > Input Actions.
3. Dê um nome ao seu novo asset (ex: PlayerControls.inputactions).
4. Clique duas vezes nele para abrir o editor visual.

No editor:

• Clique no + para adicionar action maps (conjuntos de ações, como Player, UI).
• Dentro de um action map, clique em + para criar ações como "Move", "Jump", "Attack".
• Em cada ação, defina os bindings (teclas ou botões).
  Exemplo: em "Move", adicione um binding do tipo 2D Vector e use WASD ou Set Composite > Up/Down/Left/Right.

💻 Usando no script

Depois de configurar o Input System, é hora de usar os comandos no código. Exemplo simples de movimentação:

csharpCopiarEditarusing UnityEngine;
using UnityEngine.InputSystem;

public class PlayerController : MonoBehaviour
{
    public InputAction moveAction;

    void OnEnable()
    {
        moveAction.Enable(); // Ativa a escuta do input
    }

    void OnDisable()
    {
        moveAction.Disable(); // Desativa para evitar erros quando o objeto não está na cena
    }

    void Update()
    {
        Vector2 movement = moveAction.ReadValue<Vector2>();
        Debug.Log("Movimento: " + movement);
        // Aqui você aplicaria o movimento ao personagem
    }
}

Você também pode gerar uma classe automática com os controles prontos (clicando com o botão direito no Input Actions e selecionando “Generate C# Class”), o que facilita ainda mais o uso no código.

5. Tilemap – Como Criar Mapas com Blocos em 2D

O Tilemap é uma das melhores ferramentas da Unity para criar cenários 2D com rapidez e organização. Ele permite que você desenhe mapas como se estivesse pintando com blocos (tiles), algo muito comum em jogos retrô, RPGs, plataformas e metroidvanias.

Nesse contexto, o mapa se refere basicamente ao cenário de um jogo 2D e em vez de posicionar cada elemento manualmente, o Tilemap te dá um sistema de grade, onde você pode “pintar” o cenário usando tiles prontos, como chão, parede, grama, água, etc.

➕ Criação do Tilemap

1. Vá em GameObject > 2D Object > Tilemap > Rectangular.
2. Isso criará automaticamente dois objetos na Hierarquia:
   • Um objeto chamado Grid.
   • Um objeto filho chamado Tilemap.

🔹 O Grid serve como base e organiza a posição dos tiles.
🔹 O Tilemap é onde você realmente vai desenhar os blocos do mapa.

🎨 Criação da Tile Palette (Paleta de blocos)

Para desenhar o mapa, você precisa preparar uma paleta de blocos (Tile Palette) com os sprites que deseja usar.

1. Vá em Window > 2D > Tile Palette.
2. Clique em Create New Palette e dê um nome.
3. Arraste os sprites (ex: spritesheet de chão, parede, grama) para dentro da paleta.
4. A Unity vai pedir para salvar os tiles em uma pasta do projeto. Escolha ou crie uma pasta.

Pronto! Agora os blocos estarão disponíveis para você usar como um pincel.

🖌️ Pintando o cenário no Tilemap

Com a Tile Palette aberta:

1. Selecione o tile desejado.
2. Use o Brush Tool (ícone de pincel) para pintar direto no objeto Tilemap, visível na Cena.
3. Você também pode usar a borracha, ferramenta de seleção, preenchimento, etc.

Você pode pintar quantos layers quiser (ex: chão, decoração, colisão) criando novos objetos Tilemap dentro do mesmo Grid.

🧱 Adicionando colisores (para interação)

Se você quiser que o personagem não atravesse certos blocos (ex: parede), adicione:

• Tilemap Collider 2D: detecta colisão com base nos blocos pintados.
• (Opcional) Composite Collider 2D: melhora o desempenho ao unir colisores.
• RigidBody 2D (marcado como Static): necessário para a colisão funcionar corretamente.

Para um personagem 2D colidir com uma parede, o Tilemap precisa desses componentes para “barrar” o movimento.

O Tilemap é uma criação rápida e organizada de mapas 2D, ideal para jogos com mapas grandes e repetitivos, permite múltiplas camadas (chão, obstáculos, decoração) e tem uma ótima performance.

6. ScriptableObjects – Guardando Dados de Forma Reutilizável e Organizada

Os ScriptableObjects são uma forma inteligente de guardar dados no seu projeto Unity. Eles funcionam como “arquivos de configuração” que você cria no editor, preenche com informações e reutiliza onde quiser — sem precisar reescrever ou duplicar o código.

Imagine que você tem vários itens de RPG (espada, poção, escudo), inimigos, ou feitiços. Em vez de criar um script novo para cada um, você pode criar um modelo (ScriptableObject) e, depois, preencher cada item como um arquivo separado — tudo de forma visual, no editor da Unity.

📜 Criando a classe ScriptableObject

Você cria um novo script que vai funcionar como uma “ficha de dados”. Exemplo:

csharpCopiarEditarusing UnityEngine;

[CreateAssetMenu(fileName = "NewItem", menuName = "Inventory/Item")]
public class Item : ScriptableObject
{
    public string itemName;
    public Sprite icon;
}

• itemName: o nome do item (ex: Espada de Fogo)
• icon: o ícone que será mostrado no menu ou inventário

Esse script não será anexado a um GameObject, ele é só uma estrutura de dados.

📂 Criar instâncias (arquivos prontos no editor)

Depois de criar a classe, agora você pode criar vários arquivos com dados diferentes, usando o menu da Unity:

1. No painel Project, clique com o botão direito.
2. Vá em Create > Inventory > Item.
3. Dê um nome (ex: “Espada de Fogo”).
4. Com o novo arquivo selecionado, preencha os campos itemName, icon e qualquer outro campo que você tiver definido.

Você pode criar quantos quiser: uma “Poção de Cura”, uma “Chave Dourada”, etc.

🧩 Usar os dados em outros scripts

Agora você pode usar os ScriptableObjects em qualquer lugar do jogo, sem precisar digitar tudo de novo. Exemplo de uso:

csharpCopiarEditarpublic class ItemSlot : MonoBehaviour
{
    public Item item;

    void Start()
    {
        Debug.Log("Item equipado: " + item.itemName);
    }
}

No Inspector, você verá um campo onde pode arrastar o ScriptableObject criado (como “Espada de Fogo”) e ele será automaticamente carregado no jogo.

O ScriptableObject é ideal para sistemas de inventário, inimigos, feitiços, configurações, tabelas de loot, diálogos, etc. É reutilizável, organizado se você separar dados da lógica do jogo corretamente e consome menos memória que outras ferramentas similares como GameObjects ou MonoBehaviours.

7. Raycast – Detectando o Que Está na Frente

O Raycast é como um raio invisível que parte de um ponto e vai em uma direção específica, detectando tudo o que ele tocar no caminho. É uma técnica essencial para interações no jogo, como detectar obstáculos, mirar em inimigos, abrir portas ou verificar se o jogador está olhando para algo.

Ideal para interações, tiros ou sensores. Funciona bem em jogos de tiro, puzzles ou sistemas de interação, por exemplo. Imagine-se usando para verificar se há um inimigo na linha de visão de um personagem, uma IA detectar algo no caminho dela, permitir interações como “pressione E para abrir” ou detectar onde um tiro acertou.

🔦 Raycast no espaço 3D

Este é o uso mais comum em jogos 3D. Exemplo básico:

csharpCopiarEditarRaycastHit hit;

if (Physics.Raycast(transform.position, transform.forward, out hit, 10f))
{
    Debug.Log("Acertou: " + hit.collider.name);
}

O que significa cada parte:

• transform.position: ponto de origem do raio (normalmente, o objeto que está “atirando”).
• transform.forward: direção do raio (neste caso, para frente).
• 10f: distância máxima que o raio percorre.
• hit.collider.name: nome do objeto atingido.

Isso serve, por exemplo, para ver se o jogador está olhando para um botão de porta ou para detectar um inimigo na frente.

🧭 Raycast no espaço 2D

Se o seu jogo for em 2D (como plataforma ou top-down), use Physics2D.Raycast. Exemplo:

csharpCopiarEditarRaycastHit2D hit = Physics2D.Raycast(transform.position, Vector2.right, 5f);

if (hit.collider != null)
{
    Debug.Log("Acertou: " + hit.collider.name);
}

• Vector2.right: o raio vai para a direita.
• 5f: distância máxima.
• O hit vai conter as informações sobre o objeto atingido (se houver).

🛠️ Dicas práticas com Raycast

• Interações: Use para ativar objetos ao apertar uma tecla (“E”) se estiver olhando para eles.
• Tiros e mira: Raycast é excelente para simular balas instantâneas (como em FPS).
• Visão de NPCs: Você pode usar para checar se o jogador está visível.
• Debug: Combine com LineRenderer ou use Debug.DrawRay() para visualizar o raio na cena.
• LayerMask: Use para limitar o que o raio pode atingir (por exemplo, apenas “Inimigos” ou “Interativos”).

❌ Nota sobre a Unity 6

O método antigo Physics.RaycastNonAlloc() foi descontinuado.
Agora, use Physics.Raycast() com sobrecargas que aceitam arrays, ou simplesmente use o modelo padrão com RaycastHit.

Com Raycast, você consegue fazer seu personagem ou sistema “sentir” o ambiente ao redor com precisão — sem precisar de colisões físicas visíveis.

Unity 6: Atualizações e Considerações

Agora que concluímos este tutorial de ferramentas básicas de criação de jogos na Unity aqui no Eu, Brasileiro, vamos revisar algumas atualizações (algumas já citadas) que você pode encarar entre a Unity 6 e versões anteriores:

✔️ NavMesh: Utilize o novo sistema de AI Navigation via Package Manager.
✔️ Rigidbody: Use linearVelocity em vez de velocity.
✔️ Animator: Permanece estável, com melhorias de desempenho.
✔️ Input System: Continua sendo o padrão moderno, totalmente compatível com Unity 6.
✔️ Tilemap: Nova ferramenta de Tile Set Assets facilita a pintura e organização.
✔️ ScriptableObjects: Com melhorias de integração e criação mais simples via menu.
✔️ Raycast: RaycastNonAlloc depreciado; utilize Raycast ou RaycastAll com cautela.

E se você está estudando desenvolvimento de jogos com o intuito de entrar no mercado de games, seja para criar o seu jogo do zero ou procurar trabalho em alguma empresa, não deixe de conferir a nossa página de vagas, que inclui vagas para o estúdio Frontiers Group Entertainment, o estúdio responsável por este site e outros projetos, como nosso jogo Eden’s Frontier.