Tech

Por que eu recomecei o aplicativo do Woof-Lands no Godot

Coleção: Woof-Lands

Faz um tempo que eu venho desenvolvendo o aplicativo do Woof-Lands RPG, e acho que chegou num ponto em que vale registrar como esse projeto acabou chegando onde está hoje. A versão atual não nasceu porque eu simplesmente acordei e pensei “acho que vou usar Godot agora”. Foi muito mais uma sequência de tentativas, decisões que fizeram sentido na época, coisas que funcionaram bem por um tempo e outras que começaram a ficar cada vez mais difíceis de manter conforme o projeto crescia. No começo, o aplicativo era uma coisa muito mais simples: ficha, algumas ferramentas pro Mestre, rolagens, informações da campanha e por aí vai. Só que o Woof-Lands foi crescendo, eu fui tendo mais ideias, e em algum momento o que era pra ser um aplicativo de apoio virou praticamente uma mesa virtual própria do sistema.

A partir daí eu queria campanha persistente, Mestre e jogadores conectados ao mesmo tempo, ficha sincronizada, inventário, grimório, progressão, logs, presença online, sala de jogo, OBS, dados 3D, personalização dos dados e uma porrada de outras coisas que eu provavelmente ainda nem terminei de inventar. O problema é que a arquitetura antiga não tinha sido pensada originalmente pra isso tudo. Ela foi crescendo junto comigo, e isso funciona até certo ponto, mas chega uma hora em que você percebe que está empilhando coisa nova em cima de decisões antigas que já não combinam tanto com o que o projeto virou.

O maior problema nem era implementar uma feature nova. Isso eu fazia. O problema era implementar uma coisa nova sem estragar alguma coisa que já funcionava. Começou a acontecer aquele ciclo infernal em que eu mexia numa parte, outra quebrava, eu corrigia a segunda, aí voltava na primeira e descobria que tinha dado problema de novo. Quanto mais o projeto crescia, mais dependências apareciam entre interface, estado, comunicação, regras e todo o resto. Em algum momento eu percebi que estava gastando tempo demais tentando descobrir o que tinha parado de funcionar, quando na verdade eu queria estar construindo coisa nova.

E isso começou a mexer também com a minha confiança nas versões. Eu tinha commits, builds, pastas, versões diferentes, mas não tinha uma sensação realmente segura de “essa aqui é a versão boa, se tudo der errado eu volto pra ela e pronto”. Isso parece uma coisa pequena, mas quando o projeto começa a ficar grande, vira um problema enorme. Se eu não tenho certeza de qual estado do programa é realmente estável, cada mudança nova vira meio que uma aposta.

A v0.3.0 foi a hora em que eu parei e pensei “chega”

A versão que mais me fez repensar tudo foi a 0.3.0. Ela tinha uma quantidade grande de coisa pra entrar, principalmente relacionada ao que depois virou a ideia do Woof Dice Engine, que é o meu plano de fazer um sistema de dados 3D próprio dentro do aplicativo. A ideia já era ter física, personalização, explosões, sincronização, mesa compartilhada, integração com ficha, progressão e OBS, tudo dentro do Woof-Lands sem depender de algum serviço externo.

Só que essa implementação cresceu demais. Teve processo automatizado trabalhando por dias, contexto indo embora, limite de uso sendo atingido, retomada, correção, mais arquivo sendo alterado, mais dependência aparecendo. Quando finalmente terminou, eu abri o aplicativo e fiquei com aquela sensação meio ridícula de “tá… e o que exatamente aconteceu aqui?”. Visualmente parecia praticamente a mesma coisa, só que agora algumas coisas que funcionavam antes estavam quebradas.

Aquilo foi o ponto em que eu entendi que o problema já não era mais “arrumar a v0.3.0”. Eu podia continuar remendando, e provavelmente conseguiria fazer funcionar de novo, mas ia continuar preso no mesmo tipo de problema. Eu estava tentando fazer o projeto evoluir em cima de uma fundação que já estava reclamando fazia tempo. Então resolvi fazer uma coisa que dói bastante quando você já colocou horas demais num projeto: recomeçar.

Não recomeçar no sentido de jogar tudo fora e fingir que nada aconteceu. Pelo contrário. A versão antiga serviu pra eu descobrir o que o aplicativo precisava ser. Eu só parei de insistir que aquela mesma estrutura tinha que continuar sendo a estrutura definitiva.

Foi aí que o Godot começou a fazer muito mais sentido

Eu já estava usando Godot em outros projetos e comecei a olhar pro aplicativo do Woof-Lands com outra cabeça. Em algum momento eu pensei: “por que eu estou tentando fazer uma aplicação que cada vez mais se comporta como um jogo usando uma estrutura que precisa ficar se adaptando pra isso?”. Porque no fundo o app já tinha deixado de ser só um programa de formulário fazia tempo. Ele estava virando uma aplicação interativa com cena, 3D, física, partículas, áudio, multiplayer, estados diferentes de usuário e um monte de coisa que uma engine já resolve naturalmente.

O sistema de dados foi uma das coisas que mais pesaram nessa decisão. Na estrutura anterior, colocar um sistema 3D robusto significava praticamente enfiar um pequeno jogo dentro do aplicativo. No Godot, isso deixa de ser uma gambiarra conceitual e vira simplesmente parte do ambiente. O dado é um objeto 3D, tem corpo físico, malha, colisão, material, som, efeito, script, pronto. Eu não preciso gastar energia fazendo a ferramenta aceitar que eu quero um dado caindo numa mesa; eu posso gastar energia fazendo o dado cair direito, que é muito mais útil.

E esse detalhe fica ainda mais importante porque o rolador do Woof-Lands não vai ser só um botão que gera um número. Eu quero explosões, vários tipos de dado, personalização, limite de dados físicos na tela, rolagem livre, rolagem pela ficha, sincronização entre jogadores e, mais pra frente, ligação direta com regras de progressão. Então quanto mais eu olhava pra isso, mais óbvio ficava que uma engine fazia sentido como base.

Também parei de querer vários aplicativos fazendo quase a mesma coisa

Outra coisa que começou a me incomodar era a ideia de ter estruturas muito separadas pra Mestre, jogador, versão web e outras variações. Isso até pode funcionar, mas também cria uma chance enorme de eu corrigir uma coisa num lugar e esquecer outro. Na versão nova eu quero um núcleo só. O aplicativo entende se quem está ali é PLAYER, MESTRE, ADMIN ou uma visualização de OBS, e libera o que precisa liberar conforme o papel daquela pessoa.

Pra mim isso simplifica muita coisa, porque eu não quero manter três versões levemente diferentes da mesma lógica. Se eu corrigir uma parte do sistema, eu quero corrigir uma vez e seguir em frente. Quanto mais duplicação existe, mais fácil é criar divergência sem perceber.

Ao mesmo tempo, eu também não quero cair no erro oposto e colocar tudo dentro do Godot. O Godot vai ser o cliente: ele mostra a interface, recebe input, renderiza, anima, toca som, mostra o dado, organiza a experiência. Mas as coisas importantes mesmo, principalmente em multiplayer, precisam ter uma camada separada dizendo “isso aqui aconteceu oficialmente”. Por isso eu estou usando Nakama com PostgreSQL no backend.

Na prática, a lógica fica mais ou menos assim: o Godot pede uma ação, a camada de aplicação organiza essa intenção, um adapter fala com o Nakama, e o Nakama persiste o que precisa no PostgreSQL. Isso é importante porque eu não quero que a tela do jogador seja a autoridade sobre uma rolagem, um gasto de XP ou uma mudança de ficha. O jogador pode pedir a ação, mas a decisão oficial precisa existir fora da interface.

A física do dado, por exemplo, pode ser responsável por como ele cai e como a rolagem aparece na tela. Mas o resultado oficial da rolagem é outra coisa. Separar essas duas responsabilidades agora vai poupar muita dor de cabeça quando entrarem progressão, ficha, permissões e logs de verdade.

A maior mudança não foi a engine, foi a forma como eu estou construindo

Essa talvez seja a parte mais importante dessa história toda. A migração pro Godot ajudou muito, mas a mudança principal foi eu parar de querer fazer versões gigantes de uma vez. No projeto antigo eu acabava pensando algo na linha de “nessa atualização vamos fazer dados, multiplayer, progressão, interface, login, sala e mais umas três coisas”. Parece ótimo até dar problema, porque aí você tem oito sistemas novos mexendo ao mesmo tempo e nenhuma ideia muito clara de qual deles começou a bagunça.

Agora eu estou tentando trabalhar quase como uma escada. Primeiro o projeto abre direito. Depois vem a interface base. Depois backend. Depois autenticação. Depois sessão. Depois campanhas. Depois salas. Depois realtime. Só depois começam a entrar dados, ficha e as regras mais pesadas do sistema. Cada parte precisa estar minimamente sólida antes da próxima depender dela.

E foi daí que surgiu uma coisa que eu comecei a gostar bastante: as versões known-good. Quando uma versão passou nos testes, passou no CI, passou nas regressões e eu confirmei no Windows que está funcionando, eu marco aquele ponto como conhecido e estável. Isso me dá um lugar exato pra voltar se eu destruir alguma coisa depois. Não é “acho que naquele commit estava bom”, nem “vamos tentar voltar uns arquivos”. É literalmente: essa versão funciona.

Isso mudou completamente a sensação de desenvolver o projeto. Eu ainda quebro coisas, claro. Só que agora o objetivo não é fingir que erro não existe; é fazer o erro aparecer cedo, antes de ele ficar enterrado no meio de mais vinte funcionalidades.

Inclusive os testes já começaram a justificar esse trabalho. Em uma implementação eu acabei usando nomes de funções que colidiam com métodos nativos do Godot. Era uma coisa besta, mas o CI pegou antes de virar um bug escondido. Em outro momento o Nakama estava despejando informação demais no terminal em modo debug, incluindo coisa que eu definitivamente não queria em log. Corrigi o nível de log e depois fiz o próprio CI falhar se aparecer senha, token ou header de autorização de novo. Esse tipo de coisa é exatamente o motivo de eu estar tentando construir com mais cuidado agora.

E o mais curioso é que recomeçar está fazendo o projeto andar melhor

A nova versão ainda não tem tudo que a antiga tentava ter, e eu acho isso ótimo. Hoje eu prefiro ter menos coisa, mas confiar nela. A fundação já foi reconstruída, o backend está funcionando, autenticação está funcionando, sessão está funcionando, campanhas persistentes estão funcionando e as salas realtime já estão funcionando com Mestre e jogador conectados.

Eu consigo rodar testes que criam uma conta de Mestre, criam uma conta de jogador, criam uma campanha, colocam o jogador nela, criam uma sala, conectam os dois, verificam a presença de ambos, identificam quem é Mestre e quem é jogador, fazem um deles sair e confirmam que o outro recebeu essa mudança. Depois o teste encerra tudo e limpa o que criou. Isso tudo sem eu precisar ficar clicando manualmente em vinte telas pra ver se deu certo.

Pra mim isso vale mais do que ter uma interface cheia de botão bonito que ainda não tem uma fundação confiável embaixo.

E o aplicativo antigo não foi perda de tempo. Muito pelo contrário. Foi ele que serviu pra descobrir o que o Woof-Lands precisava. A estrutura de ficha, as ideias de campanha, as necessidades do Mestre, o sistema de dados, as telas, as integrações, tudo isso foi sendo entendido enquanto eu fazia. A diferença é que agora eu conheço melhor o produto que estou tentando construir.

A primeira versão foi quase um protótipo gigante que cresceu demais. Agora eu estou pegando tudo que aprendi com ela e construindo de novo com uma arquitetura que combina mais com o que o projeto virou.

O plano continua enorme. Eu ainda quero ficha completa, rolador 3D, dados personalizados, explosões, progressão, HP, MP, AU, inventário, grimório, campanhas, salas, ferramentas de Mestre, OBS, logs, realtime, permissões e provavelmente mais um monte de coisa que eu ainda vou inventar no caminho. A diferença é que agora eu não estou tentando fazer tudo ao mesmo tempo.

Foi por isso que eu migrei pro Godot. Não porque “Godot é melhor que web” como regra universal, porque essa comparação nem faz sentido desse jeito. Eu migrei porque o Godot faz muito mais sentido pro aplicativo que o Woof-Lands acabou se tornando, e porque a mudança de tecnologia me deu uma oportunidade boa pra reorganizar o projeto inteiro de uma forma mais controlada.

No fim, eu cansei daquele ciclo de “funciona, mexe, quebra, corrige, quebra outra coisa e depois ninguém lembra qual versão estava boa”. Agora eu quero saber exatamente o que foi alterado, por que foi alterado e qual foi o último ponto em que tudo estava funcionando.

Ironia da coisa: recomeçar do zero está fazendo eu andar mais rápido. Porque agora, quando alguma coisa funciona, eu consigo simplesmente deixar ela funcionando e partir pra próxima.

E depois de passar alguns dias vendo uma atualização enorme terminar quase igual à anterior, só que com coisa quebrada no caminho, eu comecei a dar muito mais valor pra isso.