Trilha de game dev

Antes de estudar mais, estude como o cérebro aprende. Reler e grifar dão sensação de progresso, mas retêm pouco; recuperar da memória, espaçar no tempo e misturar assuntos retêm muito mais.

• Assistir à primeira semana de Learning How to Learn e anotar 5 ideias
• Listar as técnicas de estudo que você usa hoje e classificar cada uma como alta ou baixa utilidade
• Fazer um teste sem consulta sobre o último capítulo que leu e anotar o que errou
• Ler o resumo do artigo de Dunlosky et al. (2013) e escrever 3 mudanças no seu método
• Planejar uma semana com sessões curtas e uma pausa de descanso entre elas

Livros técnicos são para fazer, não para ler. Regra 20/80: 20% lendo, 80% digitando, quebrando e consertando código.

• Criar NOTAS.md com uma seção por fase do roadmap
• Definir um horário fixo semanal de estudo (mínimo 10 h)
• Começar o diário de bugs: registrar o primeiro erro e como o resolveu

Em vez de reler, feche o livro e tente lembrar. Cartões revisados em intervalos crescentes (Anki) guardam o conhecimento por anos com poucos minutos por dia.

• Instalar o Anki e criar um baralho 'gamedev'
• Criar 20 cartões sobre CMake, Git ou matemática, com uma ideia por cartão
• Revisar os cartões todos os dias por 7 dias seguidos
• Reescrever 5 cartões ruins para torná-los claros e específicos
• Fazer um cartão de código: pedir para escrever uma função de memória

Notas que só copiam o livro não ajudam. Notas úteis são escritas com suas palavras, ligadas entre si e voltadas a uma pergunta ou projeto.

• Escolher onde ficam as notas (Obsidian ou pasta de docs) e criar a estrutura
• Escrever 5 notas permanentes com suas palavras
• Ligar 3 notas entre si e explicar a ligação
• Resumir um capítulo em 5 linhas sem olhar o livro
• Explicar um conceito para um iniciante imaginário (técnica de Feynman) e achar os buracos

Resolver problemas é uma habilidade com método. Entender o enunciado, montar um plano, executar e olhar para trás funciona em matemática, algoritmos e engenharia de jogos.

• Ler os 4 passos de Pólya e escrevê-los no topo de NOTAS.md
• Resolver 1 problema pequeno aplicando os 4 passos e registrar cada um
• Quebrar um problema grande do seu projeto em 5 problemas menores
• Fazer um pré-mortem do seu plano de estudo: 5 motivos pelos quais ele falharia
• Anotar 3 vieses seus (por exemplo, otimismo no prazo) e uma contramedida para cada
• Resolver 3 exercícios no Exercism em C++

Livros: A Programmer's Introduction to Mathematics (Jeremy Kun)

Você não precisa ser bom em matemática hoje. Precisa de um processo: achar a lacuna, voltar ao pré-requisito, fazer exercícios, errar e corrigir. Aqui está o que o ajuda a ficar independente das fórmulas prontas.

• Fazer um diagnóstico em Khan Academy para achar suas lacunas
• Criar o caderno de erros e registrar os primeiros 5 erros com a causa
• Revisar frações, potências e proporções até errar menos de 1 em 10
• Assistir ao primeiro episódio de Essence of Linear Algebra e desenhar o que entendeu
• Verificar uma fórmula de código (por exemplo, a distância entre dois pontos) com números pequenos
• Resolver 5 exercícios em que você cobre a solução antes de olhar
• Derivar à mão uma fórmula que você já usa e anotar cada passo

Livros: Basic Math / Pre-Algebra All-in-One For Dummies (Mark Zegarelli) · A Programmer's Introduction to Mathematics (Jeremy Kun) · Álgebra Linear (Steinbruch & Winterle)

Ser extraordinário é fruto de prática no limite da sua habilidade, com feedback, e de projetos reais. Horas repetindo o que já sabe não evoluem. Aqui você aprende a desenhar essa prática.

• Escolher uma habilidade e escrever como seria um nível iniciante e um nível extraordinário
• Desenhar 3 exercícios de dificuldade crescente para essa habilidade
• Fazer um bloco de 45 min sem celular e registrar o que atrapalhou
• Ler um trecho de código de um projeto aberto e anotar 3 coisas que aprendeu
• Fazer a revisão semanal do app e ajustar a meta da próxima semana

Compilador (clang/Xcode CLT), CMake, gerenciador de pacotes (vcpkg ou Conan) e Git. Sem isso você perde tempo com tutoriais.

• Instalar clang, CMake e Ninja e rodar `cmake --version`
• Criar o repositório Git 'gamedev-lab' com .gitignore e primeiro commit
• Escrever um CMakeLists.txt que compila um Hello World em C++20
• Trazer GLFW ou SDL3 via vcpkg ou FetchContent e abrir uma janela vazia
• Colocar um breakpoint no lldb/IDE e inspecionar uma variável

Resolver equações, manipular expressões, entender funções (linear, quadrática, exponencial, log). É a linguagem de tudo que vem depois.

• Resolver 10 equações do 1º e 2º grau à mão
• Dominar a fórmula quadrática e escrever uma função `solveQuadratic` em C++
• Revisar potências, raízes e logaritmos com 10 exercícios
• Resolver um sistema 2x2 à mão e conferir em código
• Calcular, à mão, se um raio acerta uma esfera (equação quadrática)

Livros: Álgebra I Para Leigos (Mary Jane Sterling) · Algebra and Trigonometry (Sheldon Axler) · Pré-Cálculo: Uma Preparação para o Cálculo (Sheldon Axler) · Pré-Cálculo Para Leigos (Deborah Rumsey et al.)

Seno, cosseno, tangente, radianos, círculo unitário. Aparece em rotação, ondas, câmera e iluminação.

• Converter 10 ângulos entre graus e radianos
• Desenhar o círculo unitário de memória com sin/cos de 0°, 30°, 45°, 60°, 90°
• Fazer um ponto orbitar outro usando sin/cos
• Usar atan2 para fazer um objeto olhar para o mouse
• Animar a altura de um objeto com uma onda senoidal (amplitude e frequência ajustáveis)

Livros: Trigonometry for Dummies (Mary Jane Sterling) · Pré-Cálculo: Uma Preparação para o Cálculo (Sheldon Axler) · Algebra and Trigonometry (Sheldon Axler)

O objeto matemático mais usado em jogos: posição, direção, velocidade, normais. Domine produto escalar e vetorial.

• Implementar Vec2 com soma, subtração, escala e comprimento
• Adicionar normalize, dot e distância
• Implementar Vec3 com cross e verificar a regra da mão direita num desenho
• Escrever reflect e projetar um vetor sobre outro
• Escrever lerp e fazer um objeto seguir o mouse suavemente
• Criar testes unitários para todas as operações

Livros: Essential Mathematics for Games and Interactive Applications (2ª ed.) (Van Verth & Bishop) · Foundations of Game Engine Development, Vol. 1: Mathematics (Eric Lengyel) · Geometria Analítica (Steinbruch & Winterle) · Math for Programmers (3D graphics, ML, simulations) (Paul Orland) · Mathematics of Game Development (Jacob Enfield)

Retas, planos, esferas e interseções. Base de raycasting, colisão e picking com mouse.

• Calcular a distância de um ponto a uma reta e a um plano
• Escrever a equação do plano a partir de 3 pontos
• Implementar interseção raio–plano
• Implementar interseção raio–esfera
• Implementar interseção raio–triângulo (Möller–Trumbore)
• Implementar interseção raio–AABB (slab method)

Livros: Geometria Analítica (Steinbruch & Winterle) · Essential Mathematics for Games and Interactive Applications (2ª ed.) (Van Verth & Bishop) · Foundations of Game Engine Development, Vol. 1: Mathematics (Eric Lengyel) · Geometry for Programmers (Oleksandr Kaleniuk)

Translação, rotação e escala viram multiplicação de matrizes. Model–View–Projection é só isso, em cadeia.

• Implementar Mat3 e Mat4 com multiplicação
• Criar translate, scale e rotação em torno dos eixos X, Y e Z
• Provar que M·N ≠ N·M com um exemplo em código
• Implementar transposta e inversa de matrizes ortogonais/afins
• Escrever `lookAt` e `perspective`, e comparar a saída com GLM
• Desenhar no papel os espaços local → mundo → câmera → clip → NDC → tela

Livros: Essential Mathematics for Games and Interactive Applications (2ª ed.) (Van Verth & Bishop) · Foundations of Game Engine Development, Vol. 1: Mathematics (Eric Lengyel) · Álgebra Linear (Steinbruch & Winterle) · Álgebra Linear com Aplicações (10ª ed.) (Howard Anton & Chris Rorres) · Computer Graphics: Theory and Practice (Gomes, Velho, Sousa et al.)

Espaços vetoriais, bases, transformações lineares, autovalores. Dá a intuição de por que as matrizes funcionam.

• Assistir à série 'Essence of Linear Algebra' (3Blue1Brown) e anotar uma frase por episódio
• Resolver sistema linear por eliminação de Gauss à mão
• Calcular determinante 2x2 e 3x3 e explicar o que ele mede
• Escrever uma transformação linear como matriz e desenhar o efeito num quadrado
• Fazer Gram–Schmidt em 3 vetores e verificar a ortogonalidade em código

Livros: Álgebra Linear (Steinbruch & Winterle) · Álgebra Linear com Aplicações (10ª ed.) (Howard Anton & Chris Rorres) · Linear Algebra (Jim Hefferon) · Álgebra Linear e suas Aplicações (David C. Lay et al.)

Rotações 3D sem gimbal lock, interpolação suave de câmeras e animações.

• Reproduzir gimbal lock com ângulos de Euler numa demo
• Implementar Quat: multiplicação, conjugado, normalização
• Rotacionar um vetor por um quaternion e comparar com a matriz
• Implementar slerp e comparar com lerp normalizado
• Converter quaternion ↔ Mat4
• Implementar uma curva Bézier cúbica e mover um objeto por ela
• Implementar Catmull-Rom por uma lista de pontos

Livros: Essential Mathematics for Games and Interactive Applications (2ª ed.) (Van Verth & Bishop) · Foundations of Game Engine Development, Vol. 1: Mathematics (Eric Lengyel) · Mathematics of Game Development (Jacob Enfield) · Math for Programmers (3D graphics, ML, simulations) (Paul Orland)

Não é preciso muito, mas física de jogos é cálculo disfarçado: velocidade = derivada da posição; integrar = somar passos no tempo.

• Assistir 'Essence of Calculus' (3Blue1Brown) e explicar derivada com suas palavras
• Derivar à mão polinômios, sin, cos e exp
• Calcular posição a partir de aceleração constante (integral) à mão
• Simular uma mola com Euler explícito
• Trocar para Euler semi-implícito e comparar a energia ao longo do tempo
• Implementar RK4 e comparar com os dois

Livros: Pré-Cálculo: Uma Preparação para o Cálculo (Sheldon Axler)

O suficiente para escrever jogos: RAII, smart pointers, move semantics, templates básicos, STL, lambdas, constexpr.

• Ler A Tour of C++ (capítulos básicos) e anotar 10 coisas que você não usava
• Escrever uma classe com RAII (arquivo ou buffer) e provar o fechamento com um teste
• Trocar new/delete por unique_ptr num trecho do seu código
• Implementar move constructor e move assignment num vetor próprio
• Escrever um template de função com um concept
• Usar `std::variant` + `std::visit` em um exemplo
• Usar ranges/algorithms para filtrar e transformar uma lista

Livros: A Tour of C++ (3ª ed.) (Bjarne Stroustrup) · C++20 Recipes (Browning & Sutherland) · C++ Memory Management (Patrice Roy)

O básico que todo jogo usa: arrays, listas, pilhas, filas, hash, árvores, grafos, ordenação, busca, BFS/DFS/Dijkstra/A*.

• Ler Grokking Algorithms (busca binária, grafos, Dijkstra)
• Implementar busca binária e verificar com testes
• Implementar uma hash table simples e comparar com unordered_map
• Implementar BFS e DFS num grafo em grade
• Implementar uma fila de prioridade (heap)
• Implementar Dijkstra
• Implementar A* e visualizar a busca

Livros: Grokking Algorithms (Aditya Bhargava) · Algoritmos (CLRS, edição em português) (Thomas Cormen et al.) · C Data Structures and Algorithms (Marcin Jamro)

Soluções clássicas para problemas de estrutura: loop, estado, comando, componentes, observador, pool.

• Ler Game Programming Patterns: Command, Flyweight, Observer
• Ler: Prototype, Singleton, State
• Ler: Double Buffer, Game Loop, Update Method
• Ler: Bytecode, Subclass Sandbox, Type Object
• Ler: Component, Event Queue, Service Locator
• Ler: Data Locality, Dirty Flag, Object Pool, Spatial Partition
• Escolher 2 padrões e aplicá-los num jogo seu

Livros: Game Programming Patterns (Robert Nystrom) · Game Engine Architecture, Vol. I (4ª ed.) (Jason Gregory)

Cache, stack vs. heap, alocação, layout de dados. Jogos vivem de frames de 16 ms.

• Medir o custo de new/delete em loop de 1 milhão de iterações
• Implementar um linear (arena) allocator
• Implementar um pool allocator
• Comparar AoS vs. SoA com 1 milhão de partículas
• Rodar um profiler (Tracy ou Instruments) em um programa seu
• Ler os capítulos de cache e alocação de C++ High Performance

Livros: C++ Memory Management (Patrice Roy) · C++ High Performance (2ª ed.) (Andrist, Sehr, Garney) · Game Engine Architecture, Vol. I (4ª ed.) (Jason Gregory)

Linkar libs de terceiros, ler erros de compilação/linker, usar sanitizers.

• Compilar com -fsanitize=address,undefined e achar um bug de propósito
• Adicionar Catch2 ou doctest e escrever 5 testes
• Criar um macro de ASSERT com mensagem
• Criar um sistema de log com níveis
• Separar o projeto em bibliotecas via CMake (core, math, app)

O coração de um jogo: ler input, atualizar, desenhar. O passo de tempo fixo torna a física estável e determinística.

• Abrir janela e limpar a tela a cada frame
• Medir o delta time e mostrar o FPS
• Implementar timestep fixo de 60 Hz com acumulador
• Limitar o acumulador para evitar a espiral da morte
• Interpolar o render entre dois estados de física

Livros: Game Programming Patterns (Robert Nystrom) · Game Engine Architecture, Vol. I (4ª ed.) (Jason Gregory)

Teclado, mouse e gamepad com mapeamento de ações; buffer de input.

• Ler teclado e mouse por polling
• Criar um mapa de ações (Pular, Mover, Atirar) desacoplado das teclas
• Adicionar gamepad com zona morta
• Implementar input buffer de 100 ms para o pulo
• Implementar coyote time

Livros: Game Programming Patterns (Robert Nystrom) · C++ Game Development Cookbook (Druhin Mukherjee)

Representar jogador, inimigos, projéteis; criar/destruir objetos com segurança.

• Criar uma struct Entity com posição, velocidade e sprite
• Gerenciar uma lista de entidades com remoção segura no fim do frame
• Implementar um object pool de projéteis
• Usar IDs/handles em vez de ponteiros crus

Livros: Game Programming Patterns (Robert Nystrom) · Mastering C++ Game Development (Mickey MacDonald)

AABB, círculo, SAT simples; resolução por separação; triggers.

• Implementar AABB vs. AABB
• Implementar círculo vs. círculo e círculo vs. AABB
• Resolver a colisão empurrando pelo menor vetor de separação
• Separar triggers de sólidos
• Criar o Breakout completo com sua colisão

Livros: Essential Mathematics for Games and Interactive Applications (2ª ed.) (Van Verth & Bishop) · Physics for Game Developers (Bourg & Bywalec) · Physics for JavaScript Games, Animation, and Simulations (Dobre & Ramtal)

Menu → jogo → pausa → game over. Estados do personagem (idle/run/jump).

• Desenhar a máquina de estados do jogo (menu, jogo, pausa, game over)
• Implementar a pilha de estados
• Implementar uma FSM para o personagem (idle, run, jump)
• Adicionar reinício com tecla

Livros: Game Programming Patterns (Robert Nystrom) · Programming Game AI by Example (Mat Buckland)

O que faz a mecânica ser gostosa: easing, screenshake, partículas, hit stop, som.

• Adicionar screenshake ao colidir
• Adicionar easing a um movimento de UI
• Adicionar hit stop de 50 ms em impacto
• Criar um sistema de partículas simples (explosão)
• Adicionar 3 sons de feedback

O que acontece entre um triângulo na CPU e um pixel na tela: vertex → rasterização → fragment → framebuffer.

• Desenhar o pipeline (vertex → raster → fragment) de memória
• Explicar o que acontece com um vértice do código até o pixel
• Listar os espaços de coordenadas e a matriz de cada passagem

Livros: Learn OpenGL (Joey de Vries) · Foundations of Game Engine Development, Vol. 2: Rendering (Eric Lengyel) · Computer Graphics Programming in OpenGL Using C++ (3ª ed.) (Gordon & Clevenger) · Computer Graphics: Theory and Practice (Gomes, Velho, Sousa et al.)

GLFW (ou SDL) + glad: criar contexto OpenGL e carregar funções.

• Criar a janela com GLFW e um contexto OpenGL core
• Carregar funções com glad e imprimir a versão do GL
• Ativar o debug callback (ou checar glGetError)
• Tratar o redimensionamento da janela e o viewport

Livros: Learn OpenGL (Joey de Vries) · Computer Graphics Programming in OpenGL Using C++ (3ª ed.) (Gordon & Clevenger)

Enviar dados para a GPU e desenhar. Aqui você entende de verdade o estado do OpenGL.

• Desenhar o triângulo com VBO + VAO
• Desenhar um quadrado com EBO
• Passar a cor por atributo de vértice
• Animar a cor com um uniform de tempo
• Compilar shaders lendo de arquivos externos, com log de erros

Livros: Learn OpenGL (Joey de Vries) · Learn OpenGL: Beginners guide to 3D rendering (Frahaan Hussain)

Carregar imagens, coordenadas UV, filtros, mipmaps, wrapping.

• Carregar uma textura com stb_image
• Aplicar coordenadas UV no quadrado
• Testar nearest, linear e mipmaps, e ver a diferença
• Misturar duas texturas no fragment shader
• Testar GL_REPEAT e GL_CLAMP_TO_EDGE

Livros: Learn OpenGL (Joey de Vries) · Computer Graphics Programming in OpenGL Using C++ (3ª ed.) (Gordon & Clevenger)

Aplicar a matemática da Fase 1 na prática: MVP, câmera livre, FPS.

• Desenhar um cubo com MVP
• Ativar o depth test e desenhar 10 cubos
• Implementar câmera livre com WASD + mouse (yaw/pitch)
• Usar delta time para velocidade constante
• Adicionar zoom (FOV) com o scroll

Livros: Learn OpenGL (Joey de Vries) · Essential Mathematics for Games and Interactive Applications (2ª ed.) (Van Verth & Bishop)

Ambiente + difusa + especular; normais; múltiplas luzes; tipos de luz.

• Calcular a matriz normal e passar as normais ao shader
• Implementar luz ambiente + difusa
• Adicionar a especular (Phong) e depois Blinn-Phong
• Adicionar mapas de difusa e especular
• Implementar luz direcional, pontual (atenuação) e spot
• Usar 4 luzes pontuais ao mesmo tempo

Livros: Learn OpenGL (Joey de Vries) · Foundations of Game Engine Development, Vol. 2: Rendering (Eric Lengyel) · Computer Graphics Programming in OpenGL Using C++ (3ª ed.) (Gordon & Clevenger) · OpenGL 4 Shading Language Cookbook (David Wolff)

Importar malhas, materiais e hierarquias de arquivos reais.

• Carregar um .obj com Assimp
• Carregar um glTF com submalhas e materiais
• Respeitar a hierarquia de nós do glTF
• Mostrar o modelo 'Sponza' e navegar nele

Livros: Learn OpenGL (Joey de Vries) · Learn OpenGL: Beginners guide to 3D rendering (Frahaan Hussain)

Renderizar para textura: base de sombras, bloom, HDR e efeitos de tela cheia.

• Renderizar a cena para uma textura (FBO) e mostrá-la num quad
• Aplicar um efeito simples de tela (grayscale, inversão)
• Implementar blur (kernel) em pós-processamento
• Renderizar em HDR (float) com tone mapping
• Implementar bloom

Livros: Learn OpenGL (Joey de Vries) · Foundations of Game Engine Development, Vol. 2: Rendering (Eric Lengyel) · OpenGL: Build High Performance Graphics (Movania, Wolff et al.)

Primeiro efeito 'de verdade' de renderização. Exige FBO, matrizes de luz e bias.

• Renderizar o depth map da luz
• Calcular a matriz da luz e transformar fragmentos
• Aplicar a sombra no shader principal
• Corrigir shadow acne com bias
• Suavizar com PCF

Livros: Learn OpenGL (Joey de Vries) · Foundations of Game Engine Development, Vol. 2: Rendering (Eric Lengyel) · OpenGL 4 Shading Language Cookbook (David Wolff) · Computer Graphics Programming in OpenGL Using C++ (3ª ed.) (Gordon & Clevenger)

Fundo, reflexo e refração com cubemaps.

• Carregar um cubemap de 6 imagens
• Desenhar o skybox sem escrever profundidade
• Implementar reflexão com cubemap
• Implementar refração com cubemap

Livros: Learn OpenGL (Joey de Vries)

Interface imediata para depurar parâmetros em tempo real. Vai salvar horas do seu tempo.

• Integrar Dear ImGui com GLFW + OpenGL
• Criar um slider para a posição da luz
• Criar um color picker para a cor da luz
• Mostrar FPS e tempo de frame num painel

Tipos, vetores, swizzling, funções built-in, uniforms, in/out, precisão.

• Ler a seção de funções built-in e testar mix, step, smoothstep, clamp, fract, mod
• Treinar swizzling com 10 expressões
• Reescrever o shader de iluminação sem olhar o tutorial
• Passar dados do vertex ao fragment com interpolação e analisar o resultado

Livros: Practical Shader Development (Kyle Halladay) · GLSL Essentials (Jacobo Rodriguez) · OpenGL 4 Shading Language Cookbook (David Wolff)

Moldar valores (smoothstep, easing) e desenhar formas pelo campo de distância.

• Desenhar um círculo com `length`/`distance` e `smoothstep`
• Desenhar um retângulo e uma estrela por SDF
• Combinar formas com união, interseção e subtração
• Fazer um logo só com SDFs

Livros: Practical Shader Development (Kyle Halladay)

Value noise, Perlin, simplex, fBm. Base de terrenos, nuvens, fogo, água.

• Implementar um hash 2D e visualizar como ruído branco
• Implementar value noise 2D
• Implementar gradient (Perlin) noise
• Somar oitavas (fBm) e gerar nuvens
• Usar domain warping para fazer fogo/mármore

Livros: OpenGL 4 Shading Language Cookbook (David Wolff) · Procedural Content Generation for C++ Game Development (Dale Green)

Os efeitos que valem portfólio: dissolve, outline, toon, hologram, água, fresnel.

• Efeito dissolve com ruído e borda brilhante
• Outline (inverted hull ou pós-processamento)
• Toon shading com degraus de luz
• Fresnel/rim light
• Água: ondas senoidais + reflexo
• Holograma (scanlines + fresnel)

Livros: Practical Shader Development (Kyle Halladay) · OpenGL 4 Shading Language Cookbook (David Wolff) · OpenGL: Build High Performance Graphics (Movania, Wolff et al.)

Sem printf: como investigar o que a GPU faz.

• Visualizar normais como cor
• Visualizar UVs e profundidade
• Capturar um frame com o Xcode GPU Capture ou RenderDoc
• Achar um bug de propósito num shader usando só cores de debug

Ordem de start-up/shutdown, módulos independentes, logging, configuração.

• Desenhar o diagrama dos módulos (core, platform, renderer, game)
• Criar o log com níveis e arquivo
• Ler a configuração de um arquivo JSON
• Implementar start-up e shutdown em ordem inversa

Livros: Game Engine Architecture, Vol. I (4ª ed.) (Jason Gregory) · Mastering 3D Game Engine Development with C++ (Andrew M. Jones)

Entidade–Componente–Sistema: composição em vez de herança.

• Implementar entidades como IDs
• Armazenar componentes em sparse sets
• Escrever uma query: todas as entidades com Transform + Mesh
• Criar 3 sistemas (movimento, render, vida)
• Substituir pelo EnTT e comparar

Livros: Game Programming Patterns (Robert Nystrom) · Game Engine Architecture, Vol. I (4ª ed.) (Jason Gregory)

Carregar/liberar texturas, malhas, shaders e áudio com handles e cache; hot reload.

• Criar handles para texturas e malhas
• Evitar carregar o mesmo asset duas vezes (cache)
• Implementar hot reload de shaders
• Liberar recursos sem uso

Livros: Game Engine Architecture, Vol. I (4ª ed.) (Jason Gregory) · C++ Memory Management (Patrice Roy)

Scene graph, transform local/mundo, parent/child.

• Implementar transform local e matriz de mundo
• Implementar parent/child com atualização suja
• Fazer uma torreta filha de um tanque
• Salvar e carregar uma cena

Livros: Game Engine Architecture, Vol. II (4ª ed.) (Jason Gregory) · Essential Mathematics for Games and Interactive Applications (2ª ed.) (Van Verth & Bishop)

Abstração: submeter 'draw items', ordenar, agrupar e renderizar.

• Criar uma fila de draw items
• Ordenar por pipeline/material
• Implementar debug draw (linhas, AABB)
• Separar a câmera da cena

Livros: Game Engine Architecture, Vol. II (4ª ed.) (Jason Gregory) · Foundations of Game Engine Development, Vol. 2: Rendering (Eric Lengyel) · Mastering 3D Game Engine Development with C++ (Andrew M. Jones)

Desacoplar sistemas: dispatcher, fila de eventos.

• Implementar um event dispatcher tipado
• Disparar eventos de dano e morte
• Medir o custo de eventos por frame

Livros: Game Programming Patterns (Robert Nystrom)

Grade, quadtree/octree, BVH para colisão e visibilidade.

• Implementar uma grade uniforme
• Implementar um quadtree
• Comparar o tempo de colisão de 10 mil objetos com e sem estrutura
• Implementar frustum culling

Livros: Game Programming Patterns (Robert Nystrom) · Game Engine Architecture, Vol. II (4ª ed.) (Jason Gregory) · Foundations of Game Engine Development, Vol. 2: Rendering (Eric Lengyel) · Essential Mathematics for Games and Interactive Applications (2ª ed.) (Van Verth & Bishop)

Salvar estado do jogo e carregar níveis.

• Salvar um componente em JSON
• Salvar a cena inteira
• Versionar o formato do arquivo
• Implementar save/load do jogo

Livros: Game Engine Architecture, Vol. I (4ª ed.) (Jason Gregory)

Posição, velocidade, aceleração. Escolher o integrador certo muda a estabilidade.

• Simular queda livre com Euler e Verlet e comparar
• Adicionar arrasto do ar
• Simular órbita de um planeta e medir a deriva da energia
• Usar timestep fixo

Livros: Physics for Game Developers (Bourg & Bywalec) · Physics for JavaScript Games, Animation, and Simulations (Dobre & Ramtal) · Essential Mathematics for Games and Interactive Applications (2ª ed.) (Van Verth & Bishop)

Massa, inércia, torque, momento linear e angular.

• Criar a struct RigidBody (massa, inércia, velocidade, ω)
• Aplicar uma força fora do centro e gerar torque
• Integrar orientação
• Visualizar a velocidade angular

Livros: Physics for Game Developers (Bourg & Bywalec) · C++ Game Physics Simulations (Katie Millie) · Game Engine Architecture, Vol. II (4ª ed.) (Jason Gregory)

Broad phase + narrow phase: AABB, SAT, GJK.

• Implementar uma broad phase por grade
• Implementar SAT para polígonos convexos 2D
• Calcular os pontos de contato
• Visualizar normais e profundidade de penetração

Livros: Physics for Game Developers (Bourg & Bywalec) · Essential Mathematics for Games and Interactive Applications (2ª ed.) (Van Verth & Bishop) · Game Engine Architecture, Vol. II (4ª ed.) (Jason Gregory)

Calcular impulsos, atrito e restituição; lidar com empilhamento.

• Calcular o impulso normal
• Adicionar restituição
• Adicionar atrito
• Iterar vários passes de solver
• Empilhar 5 caixas estáveis por 10 s

Livros: Physics for Game Developers (Bourg & Bywalec) · C++ Game Physics Simulations (Katie Millie)

A física que o jogador sente: andar em rampas, pular, subir degraus, plataformas móveis.

• Mover o personagem com colisão deslizante
• Subir degraus pequenos
• Andar em rampas sem escorregar
• Plataforma móvel carregando o jogador

Livros: Physics for Game Developers (Bourg & Bywalec) · Game Engine Architecture, Vol. II (4ª ed.) (Jason Gregory)

Integrar um motor de física profissional ao seu engine.

• Integrar o Box2D num protótipo 2D
• Integrar o Jolt Physics na cena 3D
• Sincronizar a física com os transforms do ECS
• Criar um trigger de dano

A base da IA de 90% dos jogos.

• Desenhar a FSM do inimigo
• Implementar os estados patrulha, perseguir e atacar
• Adicionar o estado fugir com vida baixa
• Visualizar o estado atual sobre a cabeça do inimigo

Livros: Programming Game AI by Example (Mat Buckland) · Game Programming Patterns (Robert Nystrom)

Seek, flee, arrive, pursuit, wander, evade, separação, alinhamento, coesão (flocking).

• Implementar seek e flee
• Implementar arrive
• Implementar pursuit/evade
• Implementar separação, alinhamento e coesão (boids)
• Fazer um bando de 200 agentes

Livros: Programming Game AI by Example (Mat Buckland)

A* em grade, grafos e navmesh; custo de terreno; suavização de caminho.

• Criar uma grade de navegação com obstáculos
• Rodar A* e desenhar o caminho
• Suavizar o caminho
• Recalcular o caminho com obstáculos móveis
• Testar Recast/Detour num mapa 3D

Livros: Programming Game AI by Example (Mat Buckland) · Grokking Algorithms (Aditya Bhargava) · Algoritmos (CLRS, edição em português) (Thomas Cormen et al.)

Visão (cone), audição, memória; reação ao jogador.

• Implementar um cone de visão
• Bloquear a visão com raycast
• Adicionar memória da última posição vista
• Alertar inimigos próximos

Livros: Programming Game AI by Example (Mat Buckland)

Combate, vida, dano, buffs, cooldowns, inventário e progressão.

• Criar a struct de Stats com modificadores
• Criar habilidades descritas em JSON (dano, custo, cooldown)
• Implementar cooldowns e buffs temporários
• Criar um sistema de inventário
• Criar uma tabela de loot

Livros: Game Programming Patterns (Robert Nystrom) · Game Engine Architecture, Vol. I (4ª ed.) (Jason Gregory)

Core loop, risco/recompensa, curva de dificuldade, balanceamento. É a parte que torna o jogo divertido.

• Escrever o pitch do jogo em uma frase
• Descrever o core loop em 5 passos
• Definir 3 pilares do jogo
• Escrever um GDD de 1 página

Onde encontrar e como escolher um estilo coerente.

• Escolher um pack de estilo único
• Baixar e organizar em assets/
• Criar o LICENCAS.md com origem e licença de cada asset
• Verificar se a licença permite uso comercial

glTF para modelos, PNG/KTX2 para texturas, WAV/OGG para áudio.

• Exportar um modelo para glTF/GLB
• Gerar atlas de texturas
• Escrever um script que valida os assets (tamanho, nomes)

Livros: Game Engine Architecture, Vol. I (4ª ed.) (Jason Gregory)

Abrir, ajustar escala/origem, aplicar materiais simples, exportar glTF.

• Fazer o tutorial do donut (primeiras 2 partes)
• Importar um modelo, corrigir escala e origem
• Aplicar um material simples
• Exportar para glTF e carregar no seu engine

Livros: Blender 3D Basics (Blender 2.7) (Gordon C. Fisher)

Efeitos e música livres, sons retrô gerados.

• Gerar 5 efeitos com sfxr
• Normalizar o volume
• Escolher uma trilha com licença livre

Barras de vida, menus e texto legíveis.

• Desenhar a barra de vida
• Desenhar o texto de pontuação
• Testar a UI em 3 resoluções

Uma mecânica, um loop, uma página de GDD.

• Listar 3 ideias e avaliar cada uma (escopo, risco, diversão)
• Escolher UMA e escrever o pitch
• Fixar o prazo e a lista 'precisa / seria bom / sonho'

Opções que combinam com gráficos 3D + mecânicas + IA.

• Listar o que cada ideia exercita (render, física, IA, PCG)
• Escolher a ideia final e criar as 3 primeiras tarefas
• Criar o repositório e o quadro de tarefas

Livros: Procedural Content Generation for C++ Game Development (Dale Green) · Programming Game AI by Example (Mat Buckland) · Physics for Game Developers (Bourg & Bywalec) · Mastering C++ Game Development (Mickey MacDonald)

Mecânica jogável com formas simples antes de qualquer arte.

• Fazer o personagem se mover e interagir com formas simples
• Implementar a mecânica central
• Jogar 30 minutos e anotar o que não funciona
• Gravar um vídeo curto do protótipo
• Decidir seguir ou cortar

Livros: Game Programming Patterns (Robert Nystrom)

Uma fase completa com qualidade final: prova que o jogo funciona de ponta a ponta.

• Definir as dimensões do nível vertical slice
• Aplicar a arte e o áudio finais nesse nível
• Adicionar UI, feedback e juice
• Passar o nível do menu à vitória sem bugs graves

Replicar o que funciona: mais níveis, inimigos, itens e variação.

• Criar a ferramenta/arquivo de dados para níveis
• Fazer 5 níveis (ou 3 inimigos novos)
• Ajustar a curva de dificuldade

O que separa protótipo de produto.

• Criar o menu principal e a pausa
• Criar as configurações de áudio e vídeo
• Implementar save/load
• Adicionar a tela de créditos
• Tratar os erros de arquivos ausentes sem travar

Livros: Game Engine Architecture, Vol. I (4ª ed.) (Jason Gregory)

Medir primeiro; caçar gargalos de CPU e GPU.

• Medir o frame time com Tracy
• Achar os 3 maiores gargalos
• Corrigir um gargalo e medir de novo
• Estabilizar 60 FPS no hardware-alvo

Livros: C++ High Performance (2ª ed.) (Andrist, Sehr, Garney) · Game Engine Architecture, Vol. I (4ª ed.) (Jason Gregory)

Gerar executáveis para outras máquinas e testar em máquina limpa.

• Gerar o build Release
• Empacotar os assets junto
• Testar em um computador limpo
• Configurar o CI para gerar os builds

Observe pessoas jogando em silêncio. Os problemas ficam óbvios.

• Chamar 5 pessoas para jogar
• Observar em silêncio e anotar onde travam
• Listar os 10 maiores problemas
• Corrigir os 5 mais graves

3 projetos fortes com vídeo curto, README claro e código limpo.

• Criar um README para cada projeto, com GIF ou vídeo
• Gravar um vídeo de 60 s por projeto
• Escrever um post técnico sobre algo que aprendeu
• Organizar o GitHub (pins, descrição, licença)
• Escrever um currículo de 1 página

Treinam escopo, prazo e finalização. Melhor atalho para terminar jogos.

• Escolher a primeira game jam e se inscrever
• Definir um escopo de 48 h
• Entregar o jogo
• Escrever o pós-mortem

Primeiro lançamento, grátis, ótimo feedback.

• Criar a conta no itch.io
• Preparar capturas de tela e uma descrição
• Subir os builds para cada plataforma
• Publicar e divulgar com um devlog

Se for vender: página, wishlists e prazos.

• Ler os requisitos do Steamworks e a taxa atual
• Criar a página 'Coming soon'
• Gravar um trailer de 30 s
• Planejar a data de lançamento e o Next Fest