Desenvolvimento de Jogos com Unity:
do zero absoluto ao mercado de trabalho

Objetivo: entender a indústria, escolher seu caminho de carreira e deixar o ambiente de desenvolvimento pronto.

0.1 · Por que Unity? O mercado de jogos

A indústria de jogos movimenta mais dinheiro que cinema e música somados. A Unity é o motor (game engine) mais usado do mundo em número de jogos publicados: domina o mercado mobile (a maioria dos jogos para celular usa Unity), tem presença forte em PC, consoles, VR/AR e até em áreas fora de jogos, como simulação industrial, arquitetura e automotivo — o que amplia suas oportunidades de emprego.

Para quem busca empregabilidade, Unity oferece três vantagens práticas:

• Volume de vagas: por ser a engine mais adotada por estúdios pequenos e médios (a maior parte das vagas no Brasil), é a porta de entrada mais comum na indústria.
• C# como linguagem: C# também é usada em sistemas corporativos (.NET), o que te dá um "plano B" profissional fora dos games.
• Multiplataforma: o mesmo conhecimento serve para mobile, PC, console, WebGL e VR.

0.2 · Carreiras possíveis com Unity

Como iniciante, não se preocupe em escolher agora. O caminho padrão de entrada é Gameplay/Generalista Júnior — e é para isso que esta apostila prepara. A especialização vem com a experiência.

0.3 · Instalando seu ambiente

1. Unity Hub: baixe em unity.com/download. O Hub gerencia versões da engine e seus projetos.
2. Versão LTS: no Hub, instale sempre a versão LTS (Long Term Support) mais recente — é a que os estúdios usam em produção. Evite versões "Tech/Beta" para aprender.
3. Módulos na instalação: marque Android Build Support (e iOS se tiver Mac), além do Windows/Mac Build Support.
4. Editor de código: instale o Visual Studio Community (Windows) ou VS Code com a extensão C# Dev Kit. O Hub geralmente oferece o Visual Studio junto.
5. Licença: a licença Personal é gratuita para indivíduos e empresas com receita abaixo do limite anual da Unity — mais que suficiente para aprender e publicar seus primeiros jogos.

Criando seu primeiro projeto

1. No Unity Hub: New Project → escolha o template 2D (Built-in ou URP) para acompanhar o Módulo 3, ou 3D (URP) para o Módulo 4.
2. Dê um nome sem espaços/acentos (ex.: MeuPrimeiroJogo) e escolha uma pasta fora de OneDrive/Dropbox (sincronizadores corrompem projetos).
3. Clique em Create e aguarde — a primeira abertura demora alguns minutos.

Objetivo: sair do zero absoluto e dominar os fundamentos de C# que todo programador Unity usa diariamente. Este é o módulo mais importante da apostila — não pule etapas.

Programar é dar instruções precisas ao computador. Um jogo é um programa que roda dezenas de vezes por segundo, lendo o que o jogador faz e atualizando o mundo. Antes de mexer na Unity, você precisa falar a língua dela: C# (lê-se "cê-sharp").

1.1 · Variáveis: a memória do jogo

Uma variável é uma caixinha com nome que guarda um valor: a vida do jogador, a pontuação, a velocidade. Em C#, toda variável tem um tipo, que define o que ela pode guardar:

// Os 5 tipos que você usará 95% do tempo em jogos:
int vida = 100;              // número inteiro (sem vírgula)
float velocidade = 5.5f;     // número com casas decimais (note o "f" no final!)
bool estaVivo = true;        // verdadeiro ou falso
string nomeJogador = "Aria"; // texto, sempre entre aspas
char tecla = 'A';            // um único caractere

// Você pode alterar o valor depois:
vida = vida - 25;            // tomou dano: agora vale 75
vida -= 25;                  // mesma coisa, forma abreviada: agora 50

Operadores matemáticos e de comparação

1.2 · Condicionais e loops: o jogo toma decisões

if / else — "se isso, faça aquilo"

if (vida <= 0)
{
    Debug.Log("Game Over!");
}
else if (vida < 30)
{
    Debug.Log("Cuidado, vida baixa!");
}
else
{
    Debug.Log("Tudo sob controle.");
}

switch — vários caminhos a partir de um valor

switch (tipoDeItem)
{
    case "pocao":  vida += 50;  break;
    case "moeda":  ouro += 10;  break;
    case "chave":  temChave = true; break;
    default:       Debug.Log("Item desconhecido"); break;
}

Loops — repetir sem copiar e colar

// for: quando você sabe QUANTAS vezes repetir
for (int i = 0; i < 5; i++)
{
    Debug.Log("Spawnando inimigo número " + i);
}

// while: repete ENQUANTO a condição for verdadeira
while (municao > 0)
{
    Atirar();
    municao--;
}

// foreach: percorre cada item de uma coleção (veremos coleções em 1.5)
foreach (string item in inventario)
{
    Debug.Log("Você carrega: " + item);
}

1.3 · Métodos: blocos de ação reutilizáveis

Um método (ou função) é um bloco de código com nome, que você pode chamar quantas vezes quiser. É a base da organização de qualquer jogo:

// Método simples: não recebe nada, não devolve nada (void)
void ReiniciarFase()
{
    vida = 100;
    pontos = 0;
    Debug.Log("Fase reiniciada!");
}

// Método com PARÂMETROS: recebe informações para trabalhar
void ReceberDano(int quantidade)
{
    vida -= quantidade;
}

// Método com RETORNO: devolve um resultado para quem chamou
int CalcularDano(int forca, float multiplicador)
{
    return (int)(forca * multiplicador);
}

// Usando:
ReceberDano(25);
int dano = CalcularDano(10, 1.5f);  // dano = 15

Regra de ouro profissional: um método deve fazer uma coisa só e ter um nome que descreve essa coisa (verbo + substantivo: AbrirPorta(), CalcularDano()). Recrutadores olham isso em testes técnicos.

1.4 · Orientação a Objetos: como jogos são organizados

Jogos são feitos de "coisas": jogador, inimigos, itens, portas. A Programação Orientada a Objetos (POO) organiza o código em classes (moldes) que geram objetos (instâncias). Na Unity, todo script é uma classe — por isso POO é inegociável para o mercado.

// CLASSE: o molde de um inimigo
public class Inimigo
{
    // Campos (dados do objeto)
    public string nome;
    public int vida;
    private int dano = 10;   // private: só a própria classe acessa

    // Construtor: roda quando o objeto é criado
    public Inimigo(string nome, int vidaInicial)
    {
        this.nome = nome;
        vida = vidaInicial;
    }

    // Comportamentos (métodos)
    public void Atacar()
    {
        Debug.Log(nome + " ataca causando " + dano + " de dano!");
    }
}

// Criando OBJETOS a partir do molde:
Inimigo goblin = new Inimigo("Goblin", 30);
Inimigo chefe  = new Inimigo("Rei Goblin", 300);
goblin.Atacar();

Os 4 pilares da POO (cai em TODA entrevista)

// Herança + polimorfismo na prática:
public class Inimigo
{
    public virtual void Atacar()   // virtual: filhos PODEM sobrescrever
    {
        Debug.Log("Ataque corpo a corpo");
    }
}

public class Arqueiro : Inimigo   // ":" significa "herda de"
{
    public override void Atacar() // override: sobrescreve o comportamento
    {
        Debug.Log("Atira uma flecha de longe!");
    }
}

// Interface: um CONTRATO. Quem implementa, promete ter esses métodos.
public interface IDanificavel
{
    void ReceberDano(int quantidade);
}
// Agora jogador, inimigo, barril explosivo... todos podem ser IDanificavel,
// e a bala não precisa saber QUEM acertou — só que dá para causar dano.

1.5 · Coleções, propriedades e recursos que a Unity usa muito

Arrays e Listas

// Array: tamanho FIXO
string[] fases = { "Floresta", "Caverna", "Castelo" };
Debug.Log(fases[0]);           // "Floresta" — índices começam em 0!

// List: tamanho DINÂMICO (precisa de "using System.Collections.Generic;")
List<string> inventario = new List<string>();
inventario.Add("Espada");
inventario.Add("Poção");
inventario.Remove("Poção");
Debug.Log(inventario.Count);   // 1

// Dictionary: pares chave → valor (busca rapidíssima)
Dictionary<string, int> precos = new Dictionary<string, int>();
precos["pocao"] = 50;
Debug.Log(precos["pocao"]);    // 50

Propriedades, enum e mais

// Propriedade: campo com controle de acesso embutido
public int Vida { get; private set; }  // todos leem, só a classe altera

// enum: conjunto fixo de opções nomeadas — perfeito para estados
public enum EstadoInimigo { Patrulhando, Perseguindo, Atacando, Morto }
EstadoInimigo estado = EstadoInimigo.Patrulhando;

// Interpolação de string (jeito moderno de montar textos):
Debug.Log($"Jogador {nomeJogador} tem {vida} de vida");

Objetivo: dominar o editor, entender a filosofia de GameObjects + Componentes e escrever seus primeiros scripts que controlam o jogo.

2.1 · Conhecendo o Editor

A tela da Unity é dividida em janelas (você pode reorganizá-las). As 6 essenciais:

Navegação na Scene (decore isto)

• Q W E R T — ferramentas: mão (pan), mover, rotacionar, escalar, rect.
• F — foca no objeto selecionado; botão direito + WASD — voo em modo FPS (3D).
• Ctrl+P — Play/Stop; Ctrl+D — duplicar; Ctrl+Z — desfazer.

2.2 · GameObjects e Componentes: a filosofia da Unity

Este é o conceito mais importante da engine: tudo na cena é um GameObject, e um GameObject sozinho é apenas um "recipiente vazio". Quem dá comportamento a ele são os Componentes:

• Um Transform (posição, rotação, escala) — todo GameObject tem um, obrigatoriamente.
• Um SpriteRenderer ou MeshRenderer o torna visível.
• Um Rigidbody o faz obedecer à física (gravidade, forças).
• Um Collider lhe dá "corpo sólido" para colisões.
• Um script seu (C#) lhe dá comportamento customizado.

Jogador = GameObject + Sprite + Rigidbody + Collider + script PlayerController. Essa montagem por peças chama-se composição — a resposta prática ao "prefira composição a herança" do Módulo 1.

O Transform e vetores

A posição de um objeto é um Vector3 (x, y, z) — ou Vector2 em jogos 2D. Vetores são a matemática nº 1 dos jogos:

transform.position = new Vector3(0, 5, 0);       // teleporta o objeto
transform.Translate(Vector3.right * 2);           // move 2 unidades p/ direita
transform.Rotate(0, 90, 0);                       // gira 90° no eixo Y

// Atalhos úteis: Vector3.up = (0,1,0), .right = (1,0,0), .forward = (0,0,1)
// Distância entre dois pontos (ex.: inimigo → jogador):
float dist = Vector3.Distance(transform.position, jogador.position);

// Direção de A até B (normalizada = comprimento 1, só a direção):
Vector3 direcao = (jogador.position - transform.position).normalized;

2.3 · Scripts e o ciclo de vida (MonoBehaviour)

Para criar um script: clique direito na janela Project → Create → C# Script, nomeie (ex.: PlayerController) e arraste-o sobre um GameObject. Todo script de componente herda de MonoBehaviour e ganha "métodos mágicos" que a Unity chama automaticamente:

using UnityEngine;

public class PlayerController : MonoBehaviour
{
    void Awake()  { }  // 1º de todos — o objeto acabou de nascer. Use p/ pegar referências.
    void Start()  { }  // Antes do 1º frame — inicializações que dependem de outros objetos.
    void Update() { }  // TODO FRAME (30–200x por segundo!) — input, lógica de jogo.
    void FixedUpdate() { } // Em intervalos fixos — TODA física vai aqui.
    void LateUpdate()  { } // Depois de todos os Updates — ideal p/ câmera seguir o player.
    void OnDestroy()   { } // O objeto foi destruído — limpeza.
}

Time.deltaTime: o conceito que separa amador de profissional

Update() roda mais vezes por segundo em PCs rápidos. Se você mover "1 unidade por frame", o jogo fica mais rápido em máquinas melhores! A solução é multiplicar pelo tempo decorrido desde o último frame:

void Update()
{
    // ERRADO: velocidade depende do FPS
    // transform.Translate(Vector3.right * 5);

    // CERTO: 5 unidades POR SEGUNDO, em qualquer máquina
    transform.Translate(Vector3.right * 5f * Time.deltaTime);
}

Variáveis no Inspector e referências

public class Exemplo : MonoBehaviour
{
    public float velocidade = 5f;        // public: aparece no Inspector p/ ajustar sem código
    [SerializeField] private int vida = 100; // jeito PRO: privado, mas visível no Inspector

    public Transform alvo;               // arraste outro objeto aqui no Inspector
    private Rigidbody2D rb;              // referência a outro componente

    void Awake()
    {
        rb = GetComponent<Rigidbody2D>(); // pega o componente NO MESMO objeto
    }
}

2.4 · Prefabs, Input e seu primeiro comportamento completo

Prefabs: objetos reutilizáveis

Um Prefab é um GameObject salvo como arquivo: arraste o objeto da Hierarchy para a pasta Project e pronto. Agora você pode instanciá-lo quantas vezes quiser (balas, inimigos, moedas), e editar o prefab atualiza todas as cópias.

public GameObject balaPrefab;   // arraste o prefab no Inspector
public Transform pontoDeTiro;

void Atirar()
{
    // Instantiate cria uma cópia na cena: (o quê, onde, com qual rotação)
    Instantiate(balaPrefab, pontoDeTiro.position, pontoDeTiro.rotation);
}

// E para remover objetos da cena:
Destroy(gameObject);        // destrói o próprio objeto
Destroy(gameObject, 3f);    // destrói daqui a 3 segundos (ótimo p/ balas)

Lendo input do jogador

// Input Manager clássico (simples, ótimo p/ aprender e protótipos):
float h = Input.GetAxis("Horizontal");  // -1 a 1 (A/D, setas, analógico)
float v = Input.GetAxis("Vertical");

if (Input.GetKeyDown(KeyCode.Space)) { Pular(); }   // no frame em que apertou
if (Input.GetKey(KeyCode.LeftShift)) { Correr(); }  // enquanto segura
if (Input.GetMouseButtonDown(0))     { Atirar(); }  // clique esquerdo

Objetivo: dominar o pipeline 2D — sprites, física, animação e tilemaps — e construir seu primeiro jogo completo de plataforma.

3.1 · Sprites e física 2D

Em 2D, as imagens do jogo são sprites. Importe um PNG para a pasta Assets e, no Inspector, confira Texture Type: Sprite (2D and UI). Para pixel art: Filter Mode: Point (no filter) e Compression: None — senão sua arte fica borrada.

• SpriteRenderer: componente que desenha o sprite. Sorting Layer e Order in Layer controlam o que aparece na frente do quê.
• Pixels Per Unit (PPU): quantos pixels do sprite equivalem a 1 unidade do mundo. Padronize (ex.: 16 ou 100) em todos os sprites do projeto.

Física 2D: Rigidbody2D + Colliders

// Movimento de plataforma com física (vai no FixedUpdate!):
public class PlayerMovement2D : MonoBehaviour
{
    [SerializeField] float velocidade = 8f;
    [SerializeField] float forcaPulo = 12f;
    private Rigidbody2D rb;
    private float inputH;
    private bool noChao;

    void Awake() => rb = GetComponent<Rigidbody2D>();

    void Update()
    {
        inputH = Input.GetAxisRaw("Horizontal");   // input: no Update
        if (Input.GetKeyDown(KeyCode.Space) && noChao)
            rb.linearVelocity = new Vector2(rb.linearVelocity.x, forcaPulo);
        // (em versões antigas da Unity, use rb.velocity)
    }

    void FixedUpdate()                              // física: no FixedUpdate
    {
        rb.linearVelocity = new Vector2(inputH * velocidade, rb.linearVelocity.y);
    }

    // Detecção de chão simples via colisão:
    void OnCollisionEnter2D(Collision2D col)
    {
        if (col.gameObject.CompareTag("Chao")) noChao = true;
    }
    void OnCollisionExit2D(Collision2D col)
    {
        if (col.gameObject.CompareTag("Chao")) noChao = false;
    }
}

Colisões vs Triggers — os 6 métodos que você vai usar a vida toda

// COLISÃO física (objetos sólidos se tocam):
void OnCollisionEnter2D(Collision2D col) { }  // começou a tocar
void OnCollisionStay2D(Collision2D col)  { }  // continua tocando
void OnCollisionExit2D(Collision2D col)  { }  // parou de tocar

// TRIGGER (sensor atravessável):
void OnTriggerEnter2D(Collider2D other)
{
    if (other.CompareTag("Moeda"))
    {
        pontos += 10;
        Destroy(other.gameObject);
    }
}

3.2 · Animação 2D e Tilemaps

O sistema Animator

1. Animation Clips: selecione o objeto, abra Window → Animation → Animation, crie um clip (ex.: "Idle", "Run") e arraste os frames do sprite sheet.
2. Animator Controller: a "máquina de estados" que decide qual animação toca. Estados (Idle, Run, Jump) conectados por transições controladas por parâmetros (float, bool, trigger).
3. No código: você só altera parâmetros; o Animator cuida do resto.

private Animator anim;
void Awake() => anim = GetComponent<Animator>();

void Update()
{
    anim.SetFloat("Velocidade", Mathf.Abs(inputH)); // Idle ↔ Run
    anim.SetBool("NoChao", noChao);                 // Jump ↔ chão
    if (atacou) anim.SetTrigger("Atacar");          // dispara uma vez

    // Virar o sprite para a direção do movimento:
    if (inputH != 0) transform.localScale = new Vector3(Mathf.Sign(inputH), 1, 1);
}

Tilemaps: construindo fases como LEGO

O sistema de Tilemap permite pintar fases com blocos (tiles): crie via GameObject → 2D Object → Tilemap → Rectangular, abra a Tile Palette (Window → 2D), arraste seus sprites de cenário e pinte a fase como num editor de imagem. Adicione um TilemapCollider2D + CompositeCollider2D para o chão inteiro virar sólido de uma vez (marque Used by Composite). É assim que se constroem jogos de plataforma profissionais com rapidez.

3.3 · Projeto guiado

// Inimigo de patrulha — código base:
public class InimigoPatrulha : MonoBehaviour
{
    [SerializeField] Transform pontoA, pontoB;
    [SerializeField] float velocidade = 3f;
    Transform alvoAtual;

    void Start() => alvoAtual = pontoB;

    void Update()
    {
        transform.position = Vector2.MoveTowards(
            transform.position, alvoAtual.position, velocidade * Time.deltaTime);

        if (Vector2.Distance(transform.position, alvoAtual.position) < 0.1f)
            alvoAtual = (alvoAtual == pontoA) ? pontoB : pontoA;
    }
}

Objetivo: transferir tudo o que você sabe para o mundo 3D — iluminação, materiais, física, controle de personagem, câmera e inteligência artificial de inimigos.

4.1 · A cena 3D: modelos, materiais e luz

A boa notícia: 90% do que você aprendeu vale igual — GameObjects, componentes, ciclo de vida, prefabs. Muda o eixo Z (profundidade) e os componentes visuais:

• Mesh (malha): a geometria 3D do objeto. Unity traz primitivas (Cube, Sphere, Capsule, Plane) — ótimas para prototipar ("greybox") antes de ter arte final. Modelos externos vêm em .fbx (Blender, Maya) ou da Asset Store.
• Material: define a aparência da superfície — cor (Albedo), brilho metálico (Metallic), rugosidade (Smoothness), relevo (Normal Map). Crie via Create → Material e arraste no objeto.
• Render Pipeline: use URP (Universal Render Pipeline) nos seus projetos — é o padrão moderno da indústria para mobile e PC, com bom equilíbrio entre visual e performance. (HDRP é para gráficos AAA de ponta; Built-in é o legado.)

Iluminação essencial

Conceito de mercado — luz baked vs realtime: luzes em tempo real são caras. Em cenários estáticos, marca-se os objetos como Static e "assa-se" (bake) a iluminação em texturas (lightmaps) — visual rico quase de graça em performance. Saber disso diferencia candidatos em vagas mobile/VR.

4.2 · Física 3D e controle de personagem

Os mesmos conceitos do 2D, sem o sufixo: Rigidbody, BoxCollider, OnCollisionEnter(Collision col), OnTriggerEnter(Collider other). Para personagens, a Unity oferece um atalho poderoso: o componente CharacterController — colisão em cápsula com controle total de movimento, sem tombar como um Rigidbody:

public class PlayerController3D : MonoBehaviour
{
    [SerializeField] float velocidade = 6f;
    [SerializeField] float gravidade = -20f;
    [SerializeField] float forcaPulo = 8f;
    CharacterController controller;
    Vector3 velocidadeVertical;

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

    void Update()
    {
        // Movimento no plano, relativo à direção do personagem:
        float h = Input.GetAxis("Horizontal");
        float v = Input.GetAxis("Vertical");
        Vector3 mover = transform.right * h + transform.forward * v;
        controller.Move(mover * velocidade * Time.deltaTime);

        // Gravidade manual (CharacterController não tem física própria):
        if (controller.isGrounded && velocidadeVertical.y < 0)
            velocidadeVertical.y = -2f;
        if (Input.GetKeyDown(KeyCode.Space) && controller.isGrounded)
            velocidadeVertical.y = forcaPulo;

        velocidadeVertical.y += gravidade * Time.deltaTime;
        controller.Move(velocidadeVertical * Time.deltaTime);
    }
}

Raycast: o "laser invisível" (indispensável)

Um Raycast dispara uma linha invisível e informa o que ela atingiu. É a base de tiros hitscan, detecção de chão, interação ("o que estou olhando?") e visão de inimigos:

void Atirar()
{
    // Do centro da câmera, para frente, até 100 unidades:
    Ray ray = new Ray(cameraJogador.position, cameraJogador.forward);

    if (Physics.Raycast(ray, out RaycastHit hit, 100f))
    {
        Debug.Log("Acertou: " + hit.collider.name);

        // Lembra da interface do Módulo 1? Ela brilha aqui:
        if (hit.collider.TryGetComponent(out IDanificavel alvo))
            alvo.ReceberDano(25);
    }
}

4.3 · Câmera e IA de inimigos (NavMesh)

Câmeras

• 1ª pessoa: câmera filha do personagem; rotação horizontal no corpo, vertical na câmera (com Mathf.Clamp para não "quebrar o pescoço").
• 3ª pessoa: use o pacote Cinemachine — câmeras profissionais (seguir, orbitar, colidir com paredes, tremer) sem escrever código. É padrão de indústria: aprenda e coloque no currículo.

IA com NavMesh: inimigos que perseguem e desviam de obstáculos

1. Instale o pacote AI Navigation (Package Manager).
2. Adicione um componente NavMeshSurface ao chão e clique Bake: a Unity calcula a "área caminhável".
3. No inimigo, adicione um NavMeshAgent e mande-o a um destino:

using UnityEngine.AI;

public class InimigoIA : MonoBehaviour
{
    [SerializeField] Transform jogador;
    [SerializeField] float raioVisao = 10f, raioAtaque = 2f;
    NavMeshAgent agente;
    enum Estado { Patrulhando, Perseguindo, Atacando }
    Estado estado = Estado.Patrulhando;

    void Awake() => agente = GetComponent<NavMeshAgent>();

    void Update()
    {
        float dist = Vector3.Distance(transform.position, jogador.position);

        // Máquina de estados simples — padrão citado em TODA entrevista:
        switch (estado)
        {
            case Estado.Patrulhando:
                if (dist < raioVisao) estado = Estado.Perseguindo;
                break;
            case Estado.Perseguindo:
                agente.SetDestination(jogador.position);
                if (dist < raioAtaque) estado = Estado.Atacando;
                else if (dist > raioVisao * 1.5f) estado = Estado.Patrulhando;
                break;
            case Estado.Atacando:
                agente.ResetPath();
                // atacar aqui...
                if (dist > raioAtaque) estado = Estado.Perseguindo;
                break;
        }
    }
}

4.4 · Projeto guiado

Objetivo: dominar os sistemas transversais que todo jogo comercial tem — UI, áudio, dados, salvamento, corrotinas e gerenciamento de cenas.

5.1 · Interface de usuário (UI)

A UI da Unity (sistema uGUI) vive dentro de um Canvas. Elementos essenciais: Image, Button, Slider, Panel e — sempre — TextMeshPro (TMP) para textos (nunca use o Text legado: TMP tem qualidade e recursos muito superiores e é o padrão da indústria).

• Canvas Scaler: configure como Scale With Screen Size (ex.: 1920×1080) para a UI se adaptar a qualquer tela — obrigatório em mobile.
• Anchors (âncoras): prendem cada elemento a um canto/borda da tela. UI responsiva = âncoras bem configuradas. Pratique: barra de vida no canto superior esquerdo deve ancorar no canto superior esquerdo.

using UnityEngine;
using UnityEngine.UI;
using TMPro;

public class HUDController : MonoBehaviour
{
    [SerializeField] TextMeshProUGUI textoPontos;
    [SerializeField] Slider barraVida;

    public void AtualizarPontos(int pontos) => textoPontos.text = $"Pontos: {pontos}";
    public void AtualizarVida(float atual, float maxima) => barraVida.value = atual / maxima;

    // Conecte este método ao OnClick() do botão, no Inspector:
    public void BotaoJogar() => UnityEngine.SceneManagement.SceneManager.LoadScene("Fase1");
}

5.2 · Áudio

• AudioSource: componente que toca o som (o "alto-falante"). AudioListener: os "ouvidos" — fica na câmera, e só pode haver um por cena.
• Música: AudioSource com Loop marcado. Efeitos: PlayOneShot, que permite sobrepor sons.
• Audio Mixer: agrupe canais (Música, SFX) e controle volumes por slider de opções — padrão de jogo comercial.

[SerializeField] AudioSource fonte;
[SerializeField] AudioClip somMoeda, somPulo;

void ColetarMoeda()
{
    fonte.PlayOneShot(somMoeda);
    // Variação de pitch deixa profissional (evita som repetitivo):
    fonte.pitch = Random.Range(0.95f, 1.05f);
}

5.3 · ScriptableObjects: dados como assets

ScriptableObject é uma classe que vira arquivo de dados no projeto — sem precisar existir na cena. É a ferramenta favorita dos estúdios para itens, armas, inimigos, diálogos e configurações, porque separa dados de lógica e permite que game designers criem conteúdo sem tocar em código:

[CreateAssetMenu(fileName = "NovaArma", menuName = "Jogo/Arma")]
public class ArmaData : ScriptableObject
{
    public string nome;
    public int dano;
    public float cadencia;
    public Sprite icone;
    public AudioClip somDisparo;
}

// No script da arma equipada:
public class Arma : MonoBehaviour
{
    [SerializeField] ArmaData dados;   // arraste o asset "Pistola", "Shotgun"...
    void Atirar() => Debug.Log($"{dados.nome} causou {dados.dano} de dano");
}

5.4 · Corrotinas, salvamento e cenas

Corrotinas: código que espera sem travar o jogo

using System.Collections;

void Start() => StartCoroutine(SpawnarOndas());

IEnumerator SpawnarOndas()
{
    while (true)
    {
        SpawnarInimigo();
        yield return new WaitForSeconds(2f); // pausa AQUI e continua depois
    }
}
// Usos típicos: cooldowns, fade de tela, sequências de eventos, timers.

Salvando o jogo

// Simples (opções, recordes): PlayerPrefs
PlayerPrefs.SetInt("Recorde", 1500);
int recorde = PlayerPrefs.GetInt("Recorde", 0); // 0 = valor padrão

// Profissional (save completo): serializar para JSON
[System.Serializable]
public class SaveData
{
    public int vida;
    public int pontos;
    public float[] posicao;
}

void Salvar(SaveData dados)
{
    string json = JsonUtility.ToJson(dados);
    System.IO.File.WriteAllText(
        Application.persistentDataPath + "/save.json", json);
}

Gerenciando cenas

using UnityEngine.SceneManagement;

SceneManager.LoadScene("Fase2");              // troca de cena
SceneManager.LoadScene("HUD", LoadSceneMode.Additive); // carrega POR CIMA (UI persistente)
DontDestroyOnLoad(gameObject);                // objeto sobrevive à troca (ex.: GameManager)

Objetivo: escrever código que passa em testes técnicos e code reviews. Este módulo é o que separa "faz joguinhos" de "empregável como programador".

6.1 · Código limpo e SOLID em jogos

• Nomes que explicam: tempoDesdeUltimoTiro, não t2. Métodos como verbos, classes como substantivos, em inglês se mirar mercado internacional.
• Métodos curtos: se um Update() tem 80 linhas, quebre em LerInput(), Mover(), AtualizarAnimacao().
• Sem números mágicos: if (vida < 30) → [SerializeField] int limiteVidaBaixa = 30;

SOLID resumido para entrevistas (memorize o S e o D, os mais cobrados):

6.2 · Padrões de projeto que caem em entrevista

Singleton — instância única e global (use com moderação!)

public class GameManager : MonoBehaviour
{
    public static GameManager Instance { get; private set; }
    public int Pontos { get; private set; }

    void Awake()
    {
        if (Instance != null && Instance != this) { Destroy(gameObject); return; }
        Instance = this;
        DontDestroyOnLoad(gameObject);
    }

    public void AdicionarPontos(int valor) => Pontos += valor;
}
// De qualquer lugar: GameManager.Instance.AdicionarPontos(10);
// Em entrevista, diga: "uso para 1–2 managers centrais, ciente de que
// abusar cria acoplamento e dificulta testes" — resposta madura.

Observer — eventos: "avise-me quando acontecer"

using System;

public class PlayerHealth : MonoBehaviour
{
    public static event Action<int> AoMudarVida;   // o "canal de aviso"
    public static event Action AoMorrer;

    int vida = 100;
    public void ReceberDano(int dano)
    {
        vida -= dano;
        AoMudarVida?.Invoke(vida);                  // avisa quem estiver ouvindo
        if (vida <= 0) AoMorrer?.Invoke();
    }
}

// A UI OUVE o evento — o Player nem sabe que a UI existe (desacoplamento!):
public class BarraDeVidaUI : MonoBehaviour
{
    void OnEnable()  => PlayerHealth.AoMudarVida += Atualizar;
    void OnDisable() => PlayerHealth.AoMudarVida -= Atualizar; // SEMPRE desinscreva!
    void Atualizar(int vida) { /* atualiza a barra */ }
}

Object Pool — reciclar em vez de criar/destruir

Instantiate/Destroy em alta frequência (balas, partículas) gera lixo de memória e engasgos (GC spikes). O padrão Object Pool cria N objetos uma vez e os reutiliza, ativando/desativando. A Unity tem implementação pronta: UnityEngine.Pool.ObjectPool<T>. Saber explicar "por que pooling?" é pergunta padrão em vagas mobile.

State (máquina de estados)

Você já usou no inimigo do Módulo 4 com enum + switch. A versão avançada usa uma classe por estado (padrão State formal) — cite as duas abordagens e quando cada uma compensa (enum para 3–4 estados; classes quando os estados têm muita lógica própria).

6.3 · Git para projetos Unity (requisito de vaga)

Nenhum estúdio contrata quem não versiona código. O fluxo mínimo:

1. Instale o Git e crie conta no GitHub. Um repositório por projeto.
2. .gitignore de Unity: essencial! Ignore Library/, Temp/, Obj/, Build/, Logs/ (o GitHub oferece o template "Unity" ao criar o repo). Sem isso, o repositório fica gigante e quebrado.
3. Configurações do projeto: em Edit → Project Settings → Editor: Version Control = Visible Meta Files; Asset Serialization = Force Text. Isso torna o projeto "versionável".
4. Commits pequenos e frequentes com mensagens descritivas: feat: adiciona pulo duplo, fix: corrige colisão da moeda (padrão "Conventional Commits" — bonito no portfólio).
5. Branches: main sempre estável; funcionalidades em branches (feature/sistema-de-save) e merge ao terminar.

Objetivo: os diferenciais técnicos — otimização, shaders, multiplayer e DOTS — que elevam seu perfil de júnior para "júnior forte" ou pleno.

7.1 · Otimização e Profiler

Regra de ouro: nunca otimize no chute — meça primeiro. A ferramenta é o Profiler (Window → Analysis → Profiler): grave o jogo rodando e veja exatamente onde o tempo de cada frame é gasto (CPU, GPU, memória, física).

Os vilões clássicos de performance (e as soluções)

7.2 · Shaders e VFX (noções que abrem portas)

• Shader Graph: criação visual de shaders (materiais animados, dissolve, água, outline de seleção) sem escrever HLSL. Faça 2–3 efeitos e grave para o portfólio — efeitos visuais chamam atenção de recrutador como nada mais.
• Particle System: explosões, fumaça, poeira de passos, brilho de coleta. Todo jogo comercial usa; domine emissão, forma, cor sobre vida e colisão de partículas.
• Post-processing (URP Volume): bloom, vinheta, correção de cor — o "filtro" que faz o jogo parecer profissional em 10 minutos.

7.3 · Multiplayer, DOTS e além

Multiplayer (Netcode for GameObjects)

Conceitos que você deve saber explicar, mesmo sem dominar: arquitetura cliente-servidor vs peer-to-peer; autoridade do servidor (nunca confie no cliente — anti-cheat básico); sincronização de variáveis (NetworkVariable) e chamadas remotas (RPCs); latência e client-side prediction. Um projeto simples de 2 jogadores com Netcode for GameObjects + Relay já é diferencial enorme em currículo júnior.

DOTS/ECS e Jobs (saber o que é)

DOTS (Data-Oriented Technology Stack) é a abordagem da Unity para performance extrema: em vez de objetos com componentes "gordos", dados puros processados em massa (ECS — Entity Component System), em paralelo (Job System) e com código compilado otimizado (Burst). Usado em jogos com milhares de entidades (RTS, simulações). Para júnior, basta saber explicar o conceito e quando faz sentido — dominar DOTS é assunto de vaga pleno/sênior.

Ferramentas modernas que valem citação no currículo

• Addressables: gestão profissional de assets — carregar/descarregar conteúdo por demanda, essencial para jogos grandes e atualizações de conteúdo em mobile.
• Unity Cloud Build / CI: builds automatizadas a cada commit.
• Testes: Unity Test Framework (testes de unidade em C#) — raro em júnior, logo, memorável.

Objetivo: transformar projeto em produto — builds para Android/iOS e PC/Web, otimização mobile e noções de monetização (o vocabulário das vagas de estúdio mobile).

8.1 · Gerando builds

Android (o mais acessível para começar)

1. Instale o módulo Android Build Support (com SDK/NDK/JDK) pelo Unity Hub.
2. File → Build Settings → Android → Switch Platform.
3. Em Player Settings: nome do pacote (com.seuestudio.seujogo), versão mínima do Android, orientação da tela e ícone.
4. Build gera um .apk (instalação direta para testes) ou .aab (formato exigido pela Google Play).
5. Ative o Developer Mode + depuração USB no celular e use Build and Run para testar direto no aparelho.

iOS exige um Mac com Xcode e conta Apple Developer. WebGL gera uma versão que roda no navegador — o formato perfeito para portfólio no itch.io (recrutador joga sem instalar nada!). PC é um clique.

Controles touch e otimização mobile

• Input touch: use o Input System com On-Screen Stick/Button (joystick virtual) ou Touchscreen/Input.GetTouch.
• Alvos de performance mobile: 60 FPS estáveis em aparelho mediano; texturas comprimidas (ASTC); luzes realtime mínimas (prefira baked); partículas e transparências com parcimônia (overdraw é o assassino nº 1 em mobile); resolução dinâmica se preciso.
• Bateria e térmica: use Application.targetFrameRate = 60; (ou 30 em jogos calmos) — sem limite, o celular esquenta e o jogo é desinstalado.

8.2 · Monetização e lojas (vocabulário de vaga mobile)

Analytics e LiveOps: estúdios mobile vivem de métricas — retenção D1/D7/D30, sessão média, funil de fases. Conhecer Unity Analytics ou Firebase e o conceito de remote config (ajustar o jogo sem atualizar o app) é diferencial real em vagas de mobile.

Objetivo: converter conhecimento em contratação — portfólio, currículo, entrevistas, certificações e um plano de estudos realista.

9.1 · O portfólio que contrata

Para vagas júnior, o portfólio pesa mais que diploma. A fórmula que funciona:

• 2 a 4 jogos completos e polidos valem mais que 10 protótipos abandonados. "Completo" = menu, gameplay, fim, sons, sem bugs graves. Os projetos dos Módulos 3 e 4 desta apostila são exatamente isso.
• Jogável no navegador: publique builds WebGL no itch.io (gratuito). Recrutador não instala nada — se ele pode jogar em 10 segundos, você já venceu metade dos concorrentes.
• Vídeo de 30–60s por projeto (YouTube): mostre o melhor momento nos primeiros 5 segundos.
• GitHub organizado: README com GIF do gameplay, descrição do que VOCÊ programou, e código limpo (Módulo 6) — será lido no processo seletivo.
• Página única de portfólio (itch.io profile, Notion ou site simples) reunindo tudo: jogos, vídeos, GitHub, LinkedIn, e-mail.
• Game jams: participe (Ludum Dare, Global Game Jam, GMTK Jam, jams brasileiras no itch.io). Provam trabalho em equipe sob prazo — e viram história boa para contar em entrevista.

9.2 · Entrevistas técnicas: o que cai e como responder

Processos típicos de estúdio: triagem de currículo → conversa com RH → teste técnico (um mini-jogo em alguns dias, ou perguntas ao vivo) → entrevista técnica → cultural. As perguntas clássicas (todas cobertas nesta apostila):

No teste técnico prático, avaliam mais o COMO que o QUÊ

• Leia o enunciado duas vezes e entregue exatamente o pedido antes de adicionar extras.
• Código organizado (nomes claros, responsabilidades separadas) > feature a mais.
• Commits ao longo do teste (mostram seu processo de raciocínio).
• README curto: como rodar, decisões que tomou, o que faria com mais tempo — isso encanta avaliadores.

Perguntas comportamentais (prepare 3 histórias)

"Fale de um bug difícil que resolveu", "um projeto que não deu certo", "como lida com feedback". Use o formato Situação → Ação → Resultado, com histórias reais dos seus projetos de portfólio. Fazer os projetos desta apostila te dá essas histórias.

9.3 · Certificações, formação e faixas de mercado

• Unity Certified Associate: Game Developer — a certificação oficial de entrada. Não substitui portfólio, mas ajuda a passar filtros de RH e estrutura seus estudos. Há também a trilha Professional (para quem já trabalha na área).
• Unity Learn (learn.unity.com) — plataforma oficial gratuita com trilhas ("Pathways": Unity Essentials, Junior Programmer) que geram badges verificáveis para o LinkedIn e preparam para a certificação.
• Faculdade é obrigatória? Não para a maioria dos estúdios — portfólio e teste técnico decidem. Cursos de Jogos Digitais/Ciência da Computação ajudam em networking, fundamentos e vagas internacionais que exigem diploma para visto.
• Inglês: o multiplicador de salário nº 1. Vagas remotas internacionais pagam em dólar/euro e contratam brasileiros com frequência. Documentação, tutoriais e comunidades top são em inglês — comece a consumir conteúdo em inglês já.

Expectativas salariais (ordens de grandeza, Brasil)

Valores variam muito por região, porte do estúdio e momento do mercado — pesquise faixas atuais no Glassdoor e em levantamentos da comunidade (ex.: pesquisas salariais da Abragames/IGDA). Como referência de estrutura: estágio/júnior em estúdios nacionais costuma ficar na faixa de 2 a 5 mil reais; pleno, de 6 a 12 mil; sênior, acima disso; e vagas remotas internacionais multiplicam esses valores. Estúdios de "serious games" (educação, treinamento corporativo, simulação) e empresas fora de games que usam Unity (arquitetura, indústria, XR) são portas de entrada frequentemente menos concorridas que estúdios de entretenimento.

Onde procurar vagas e comunidade

• LinkedIn (siga estúdios BR e gringos; recrutadores de games são ativos lá), Hitmarker e Work With Indies (vagas internacionais de games), páginas de carreira dos estúdios.
• Comunidades BR: servidores de Discord de desenvolvimento de jogos, grupos da IGDA local, eventos como BIG Festival/gamescom latam e SBGames — networking gera a maioria das primeiras oportunidades.

9.4 · Roadmap de estudos (plano de 6–9 meses)

Referência rápida: atalhos, vocabulário da indústria e onde continuar aprendendo.

A.1 · Atalhos essenciais do Editor

A.2 · Glossário da indústria

A.3 · Recursos para continuar

• Documentação oficial (docs.unity3d.com) — Manual + Scripting API. Aprender a LER documentação é habilidade profissional; consulte-a antes de procurar tutorial.
• Unity Learn (learn.unity.com) — trilhas oficiais gratuitas com certificado de conclusão.
• Canais no YouTube: Brackeys (clássico atemporal de fundamentos), Code Monkey, Tarodev, Freya Holmér (matemática de jogos), Sebastian Lague (projetos avançados inspiradores); em português, procure canais ativos da comunidade brasileira de gamedev.
• Asset Store e OpenGameArt/Kenney.nl — arte e sons gratuitos para seus protótipos (Kenney é o favorito de todo iniciante).
• Livros: "Game Programming Patterns" (Robert Nystrom — gratuito online, a bíblia dos padrões em jogos), "Clean Code" (Robert Martin), "The Art of Game Design" (Jesse Schell, para design).
• Prática de C# para entrevistas: exercícios de lógica em plataformas como Codewars/LeetCode (nível fácil) mantêm o músculo afiado.

Palavra final: todo desenvolvedor profissional de jogos já esteve exatamente onde você está agora — sem saber o que era uma variável. A diferença entre quem entrou na indústria e quem desistiu não foi talento: foi terminar projetos pequenos, um depois do outro, e mostrá-los ao mundo. Comece hoje pelo Módulo 0. Bom desenvolvimento! 🎮