Engine C++ de Desenvolvimento de Jogos
A G69 Platform Game Engine nasceu da inquietação de quem acredita que entender o "como" é tão importante quanto o "o quê".
Trata-se de uma engine 2D desenvolvida do zero em C/C++, criada não para atender demandas comerciais ou seguir tendências, mas para explorar fundamentos reais de jogos: renderização, física, colisão, câmera, áudio e pipeline de assets, tudo sob controle direto do código.
A G69 Engine existe como exercício de engenharia, curiosidade técnica e prazer em construir sistemas simples, previsíveis e eficientes. Um laboratório vivo onde cada decisão é consciente, cada linha tem propósito e o aprendizado vem antes de qualquer atalho.
A G69 é resultado direto de experiência prática com C/C++, raylib, Tiled, Aseprite e, principalmente, da recusa em aceitar soluções mágicas quando se pode escrever as próprias.
O que ela já faz:
- Loop principal sólido com separação clara entre update, fixedUpdate e render
- Sistema de câmera 2D com follow suave, offset, zoom e limites de cenário
- Renderização de tilemaps a partir do Tiled com camadas
- Suporte a parallax em múltiplas camadas
- Sistema de entidades (Player, objetos de cenário, inimigos em estrutura inicial)
- Física básica própria: gravidade, aceleração, velocidade e estados (grounded, jump)
- Sistema de colisão com tiles retangulares e rampas inclinadas
- Leitura de polígonos de colisão a partir do Tiled
- Debug visual (caixas, contatos, polígonos, overlays)
- Sistema de animação via atlas JSON (Aseprite)
- Áudio: efeitos sonoros e música usando raylib
- Estrutura modular em C++ (core, physics, audio, game, renderer)
Em resumo, a G69 já é uma engine funcional e não um protótipo vazio. O que falta não é "milagre tecnológico", mas lapidação, organização e maturidade.
Coisa pra se construir com calma, sem pressa e sem maquiagem.
Parallax
Parallax é uma técnica visual usada em jogos 2D para criar sensação de profundidade, fazendo diferentes camadas do cenário se moverem em velocidades distintas conforme a câmera se desloca. Elementos mais distantes se movem mais lentamente, enquanto os mais próximos acompanham a câmera com maior intensidade, simulando a forma como o olho humano percebe o espaço no mundo real. O resultado é um cenário mais vivo, com leitura espacial clara e maior imersão, mesmo em ambientes bidimensionais.
Mapa de colisão
Colisão é o sistema que define como o jogador e os objetos interagem fisicamente com o mundo do jogo: onde é possível andar, cair, escorregar ou bater. Para isso, o visual do cenário não é usado diretamente; em vez disso, existe um mapa de colisão, uma representação invisível e simplificada das superfícies sólidas. Esse mapa descreve o chão, paredes e rampas por meio de caixas e polígonos, permitindo cálculos precisos e eficientes. Assim, o jogo mantém fidelidade visual enquanto garante movimento estável, previsível e fisicamente coerente.
Sprites Animados
Animação em jogos 2D é o resultado da exibição rápida de quadros sequenciais, cada um representando uma pose ligeiramente diferente de um personagem ou objeto. Esses quadros são organizados em um spritesheet, uma única imagem que concentra todas as variações de movimento, facilitando o carregamento e o controle pelo código. Ao alternar os quadros no tempo correto, a engine cria a ilusão de movimento contínuo, mantendo desempenho, precisão visual e total controle sobre o ritmo da animação.
Do zero?
Desenvolver uma engine e um jogo diretamente em C++ é uma escolha consciente, quase filosófica. É optar por compreender o funcionamento real das coisas em vez de apenas utilizá-las. Diferente de plataformas prontas como Unity ou Godot, que oferecem soluções rápidas e altamente produtivas, o desenvolvimento do zero expõe cada camada do sistema: o loop principal, o gerenciamento de memória, a física, a renderização, o áudio, o carregamento de assets. Nada está escondido. Tudo é decisão. Tudo é responsabilidade.
Engines prontas resolvem problemas de forma genérica e isso tem valor. Elas aceleram protótipos, viabilizam projetos comerciais e reduzem barreiras de entrada. Mas também impõem caminhos, abstrações e limites invisíveis. Quando algo não se comporta como esperado, muitas vezes a resposta está enterrada em camadas que o desenvolvedor não controla. Criar em C++ é o oposto disso: é saber exatamente por que algo funciona e por que quebra quando não funciona. É trocar conveniência por domínio.
Há também o prazer real, quase artesanal de programar. O prazer de escrever código que faz sentido, que você entende do início ao fim. O prazer de não depender de um produto engessado, de não esperar atualizações, de não adaptar sua ideia à ferramenta, mas sim a ferramenta à sua ideia. Se hoje é mais prático usar um spritesheet gerado por uma ferramenta pronta, ótimo. Se amanhã surgir a necessidade de criar um spritesheeter próprio, o caminho está aberto. Não há amarras, apenas possibilidades.
Nesse contexto, o Linux surge quase naturalmente. Um ambiente onde o desenvolvedor tem controle, previsibilidade e liberdade. Onde ferramentas existem para servir, não para vigiar. Onde o ato de programar ainda é valorizado como construção, não como consumo. Desenvolver em C++ no Linux é, de certa forma, um retorno às raízes: menos camadas artificiais, mais entendimento, mais intenção.
Este não é um convite para abandonar engines prontas, nem um manifesto contra quem as usa. É um convite a ir além. A programar mais. A questionar mais. A ser menos um usuário que aceita tudo pronto e mais alguém que constrói, entende e decide. Porque no fim, programar não é apenas fazer algo funcionar é saber exatamente por que funciona.
