←
AITYBlog
Engenharia

Copilot CLI: Código Vira Dungeon Roguelike Dinâmico

Transformando Código em Aventura com GitHub Copilot CLI

Como Engenheiro de Software Sênior e Arquiteto de Soluções na AITY, sempre busco ferramentas que otimizem o processo de desenvolvimento e expandam as fronteiras da inovação. Recentemente, fui impactado por uma demonstração fascinante do GitHub Copilot CLI, que não só simplificou tarefas complexas, mas também inspirou a criação de algo inesperado: um jogo de RPG roguelike gerado a partir de qualquer base de código.

Este artigo explora como o GitHub Copilot CLI, combinado com princípios de geração procedural, permitiu construir uma extensão que transforma seu repositório de código em um dungeon roguelike único. Uma jornada que começa com um simples prompt e culmina em uma nova perspectiva sobre o potencial da engenharia assistida por IA.

GitHub Dungeons: Seu Código, Um Novo Mundo

O projeto, batizado de GitHub Dungeons, é um jogo de terminal que gera um dungeon a partir do seu codebase. Ele oferece uma experiência de jogo única onde:

A Essência dos Roguelikes e Geração Procedural

Os jogos roguelike, originários dos anos 1980 com títulos como "Rogue", são aventuras baseadas em terminal caracterizadas por:

Essa combinação, formalizada em conceitos como a "Berlin Interpretation", confere ao gênero um ar surprisingly moderno. A geração procedural ("procgen") é a criação algorítmica de conteúdo, como níveis, mapas, inimigos ou itens, em tempo de execução, usando um conjunto de regras e um toque de aleatoriedade. Em vez de projetar um único dungeon, você projeta um sistema que gera muitos.

Isso é o que garante a rejogabilidade dos roguelikes: * Sempre uma nova experiência: Diferente a cada vez. * Exploração: Descobrir o desconhecido. * Desafio: Reagir a situações inesperadas.

No GitHub Dungeons, esse sistema é amarrado ao seu repositório. O layout é semeado pelo seu último commit, garantindo que o mesmo código produza o mesmo dungeon, mas evoluindo a cada mudança no código.

Construindo com GitHub Copilot CLI e Agentes

A construção do GitHub Dungeons demonstrou o poder do GitHub Copilot CLI. Em vez de escrever tudo do zero, pude descrever o comportamento desejado. Um comando que fez uma grande diferença foi /delegate. Diferente de apenas gerar código inline, /delegate entrega a tarefa a um agente de codificação do Copilot, executando na nuvem.

Eu podia descrever o que queria em linguagem natural, iniciar o processo e focar em outras tarefas enquanto o agente trabalhava. Ao finalizar, ele abria um pull request com os resultados.

Por exemplo, um prompt como: /delegate Make each level progressively harder e.g. on level 2 there are extra baddies, but more health potions

O Copilot gerou um primeiro rascunho sólido assincronamente. Eu revisei e ajustei o PR até que o equilíbrio estivesse certo. A mesma abordagem foi usada para outros recursos, como adicionar códigos de trapaça.

Cheguei a ter o Copilot gerando um "agente escriba de dungeon", um pequeno auxiliar que adicionou documentação e diagramas ASCII para explicar como os dungeons eram gerados – o que se alinha perfeitamente com a proposta de um roguelike de terminal. Trabalhar dessa forma é como ter um exército de NPCs à disposição para fazer o que eu quiser que façam.

Descrever recursos, delegá-los ao Copilot e revisar os pull requests resultantes significou menos tempo com casos de borda e código boilerplate, e mais tempo focado na experiência do jogador e no design do jogo.

Binary Space Partitioning (BSP) em Detalhe

No coração do design de cada dungeon está uma técnica chamada Binary Space Partitioning (BSP). Embora o nome possa soar intimidante, a ideia é surpreendentemente simples: dividir um espaço em pedaços menores até ter uma coleção de salas que podem ser conectadas.

Roguelikes precisam de mapas que sejam: * Rejogáveis: Nunca o mesmo duas vezes. * Interessantes: Com estrutura e complexidade. * Exploráveis: Com segredos e desafios.

O BSP atinge um equilíbrio ideal, oferecendo: * Geração rápida. * Controle sobre o resultado. * Estrutura orgânica.

Veja como funciona: 1. Início: Tudo começa como um grande retângulo, representando todo o seu dungeon. 2. Primeira Divisão: Dividimos o espaço em duas regiões. 3. Divisões Sequenciais: Essas regiões são divididas novamente, e assim por diante. 4. Orientação: Cada divisão pode ser horizontal ou vertical. 5. Critério de Parada: Continuamos dividindo até que as regiões se tornem muito pequenas para acomodar uma sala. 6. "Folhas": Isso cria uma série de regiões "folha", os blocos de construção finais. 7. Criação de Salas: Cada folha se torna uma sala, com um leve randomização de tamanho e posição para evitar um visual muito "grid-like". 8. Conexão: As salas são conectadas voltando na árvore de divisões e ligando as "irmãs". 9. Formato dos Corredores: Cada conexão geralmente assume um formato de L.

O que é interessante no BSP é que ele parece projetado, mesmo não sendo. Ele evita os dois grandes problemas da geração procedural: a aleatoriedade pura (bagunçada) e grades rígidas (previsíveis, entediantes), oferecendo algo entre os dois – muitas vezes com resultados esteticamente agradáveis.

Experimente GitHub Dungeons

Se você quer ver como seu próprio codebase se parece como um dungeon, e já tem o GitHub Copilot CLI instalado, você pode executar:

gh extension install leereilly/gh-dungeons

Após a instalação, execute gh dungeons para transformar seu repositório em um dungeon personalizado, pronto para ser conquistado. Controle seu herói com WASD, teclas de seta ou teclas Vim.

Seu objetivo é encontrar a porta oculta e escapar (e atacar!) inimigos ao longo de cinco níveis. Recursos adicionais incluem névoa de guerra que limita a visibilidade, auto-ataque e a capacidade de rastrear estatísticas como mortes e níveis conquistados.

O "Modo Louco" do Pre-Commit Hook

Para os mais aventureiros (e imprudentes), há um "modo louco" que pode ser ativado com um pre-commit hook. Este hook deleta suas alterações não salvas se você não conseguir vencer o jogo.

⚠️ AVISO: Não faça isso a menos que compreenda completamente o que isso fará ao seu repositório. Você perderá trabalho salvo e, provavelmente, um pouco de sanidade.

Para criar o pre-commit hook:

cat > .git/hooks/pre-commit << 'EOF'
#!/bin/bash
gh dungeons
if [ $? -ne 0 ]; then
echo "Você morreu! Suas mudanças foram guardadas no esquecimento..."
git stash && git stash drop stash@{0}
exit 1
fi
EOF
# Torne-o executável
chmod +x .git/hooks/pre-commit

Para ser claro, você perderá todas as suas mudanças não commitadas se habilitar isso e falhar em vencer o dungeon, aventureiro. Como Engenheiro de Software da AITY, eu fortemente desencorajo o uso desta funcionalidade em qualquer repositório de trabalho importante.

Impacto Prático e Futuro da Engenharia Assistida por IA

O que começou como um experimento despretensioso transformou minha percepção sobre o GitHub Copilot CLI e os fluxos de trabalho agentic. Fui capaz de criar um MVP rapidamente, iterar nas partes que realmente importavam e deixar o Copilot lidar com a "parte pesada", como a geração BSP e a definição de elementos do jogo.

Essa abordagem me permitiu permanecer na mentalidade de design de jogo, experimentando mecânicas e focando no que tornava o jogo divertido, em vez de me prender constantemente a detalhes de implementação e boilerplate. Para a AITY, isso significa que podemos acelerar a prototipagem, explorar ideias inovadoras com maior agilidade e otimizar a experiência de desenvolvimento para nossos engenheiros, liberando-os para focar em desafios de alto valor e soluções criativas. O futuro da engenharia de software é cada vez mais sobre descrever comportamentos e delegar, tornando a inovação mais acessível e eficiente.

Comentários

Interações
Seu Perfil

Aguardando Login...