Me aventurando no desenvolvimento Homebrew de jogos para GameBoy Advance — Parte 2

A ideia para o segundo artigo dessa série era trazer uma visão geral sobre o Hardware do GBA, mas acabei novamente preso em configurações de projeto. Sou extremamente leigo no uso do Docker, ainda, sim, resolvi me aventurar em configurar um projeto que o utilizasse, devido ao fato de eu ter formatado meu computador e perdido todo o progresso do tutorial anterior.

A primeira versão do ambiente

Então, depois de muito quebrar a cabeça, um pouco de vídeos na Udemy, um DeepSeek aqui e um ChatGPT ali, eu cheguei na primeira versão dessa empreitada.

Comecei mantendo a pasta source com um arquivo main.c, além do arquivo Makefile na raiz do projeto, lembrando que o arquivo make eu obtive dos exemplos do DevkitPro nesse repositório.

Depois, eu criei um arquivo Dockerfile bem simples:

# Imagem Oficial do DevkitPro Arm na versão mais atualizada
FROM devkitpro/devkitarm:latest

# Diretório de Trabalho
WORKDIR /workspacegba

Com isso em mente, foi só criar uma pasta de scripts onde eu tinha três arquivos.

O primeiro arquivo era o build_docker_image.sh para gerar uma imagem customizada para nosso projeto:

#!/bin/bash
docker build -t gba-dev .

Criei um script chamado build.sh para gerar nossas Room's:

#!/bin/bash
docker run -it --rm -v $(pwd):/workspacegba gba-dev make

Em seguida, criei um script chamado dev.sh para desenvolvimento que mantinha o bash do contêiner aberto para que eu pudesse gerar uma Room sempre que fosse necessário por meio do comando make:

#!/bin/bash
docker run -it --rm -v $(pwd):/workspacegba gba-dev bash

O resultado me deixou animado, os contêineres eram removidos logo após sua finalização e não era necessário ficar fazendo copy dos arquivos.

Esbarrando em um problema — Segunda Versão

Tudo estava funcionando bem, muitíssimo bem, eu chamava o script de build e obtinha minha Room na hora, nada de instalações complicadas, até que surgiu um problema, eu não tinha o IntelliSense funcionando, já que o Visual Studio Code não tinha como localizar as bibliotecas dentro do contêiner.

Em minha mente, só vieram duas possibilidades, e nenhuma me agradou até o momento. A primeira era usar o Dev Container e trabalhar dentro dele, assim o VScode teria acesso às libs facilmente, mas, para mim, isso quebra a magia do projeto que é usar o contêiner apenas para compilação.

Acabei optando por uma segunda alternativa, adicionar um script que copia as libs do DevkitPro do contêiner para nossa pasta do projeto e depois é só configurar o VScode para as reconhecer, e foi isso que eu fiz, mas, confesso que até agora não gostei dessa solução, acaba fugindo também da ideia original, por isso, se você souber um outra maneira, eu ficarei muito feliz em saber.

Vamos lá, para essa segunda versão eu modifiquei nosso Dockerfile, ficando assim:

# Imagem Oficial do DevkitPro Arm na versão mais atualizada
FROM devkitpro/devkitarm:latest

# Script para copiar as libs
COPY ./scripts/container_copy_libs.sh /usr/local/bin/copy_libs.sh

# Torna o script executável
RUN chmod +x /usr/local/bin/copy_libs.sh

# Diretório de Trabalho
WORKDIR /workspacegba

Depois, dentro de nossa pasta de scripts eu tive que adicionar mais dois arquivos. O primeiro é o container_copy_libs.sh que ficará dentro do nosso contêiner que nós já adicionamos na hora de gerar nossa imagem com o Dockerfile:

#!/bin/bash
LIB_DIR="/workspacegba/devkitpro_libs"

mkdir -p $LIB_DIR

cp -r /opt/devkitpro/libgba $LIB_DIR
cp -r /opt/devkitpro/devkitARM $LIB_DIR

Em seguida, eu criei o copy_libs.sh que vamos chamar para de fato copiar as libs do DevkitPro para a raiz de nosso projeto:

#!/bin/bash
docker run -it --rm -v $(pwd):/workspacegba gba-dev /usr/local/bin/copy_libs.sh

Depois, é só gerar nosso arquivo de configuração do Visual Studio Code para reconhecer as bibliotecas recém copiadas, para isso, eu criei um arquivo c_cpp_properties.json dentro de uma pasta chamada .vscode na raiz do projeto:

{
    "configurations": [
        {
            "name": "GBA Development",
            "includePath": [
                "${workspaceFolder}/devkitpro_libs/libgba/include",
                "${workspaceFolder}/devkitpro_libs/devkitARM/arm-none-eabi/include"
            ],
            "defines": [
                "__GBA__"
            ],
            "compilerPath": "${workspaceFolder}/devkitpro_libs/devkitARM/bin/arm-none-eabi-gcc",
            "cStandard": "c11",
            "cppStandard": "c++17",
            "intelliSenseMode": "gcc-arm"
        }
    ],
    "version": 4
}

Feito tudo isso, é só reiniciar o Editor de Código e ele já vai reconhecer as bibliotecas fornecidas pelo DevkitPro. Missão Concluída, ao menos por hora!

Eu criei um repositório com toda essa configuração para quem tiver a fim de usar e/ou colaborar com essa empreitada.

Nos vemos em breve, e quem sabe, dessa vez, sim, falaremos do Hardware do GBA.