Tech

O Woof-Lands também está na Steam... só que é mais complicado

Coleção: Woof-Lands

No último texto que fiz sobre o Woof-Lands, eu falei bastante sobre uma decisão que doeu um pouco mais do que eu gostaria de admitir: jogar praticamente todo o programa fora e começar novamente no Godot.

Não vou contar aquela história inteira de novo porque já escrevi sobre isso, mas vale lembrar rapidamente onde eu estava. O Woof-Lands começou como uma aplicação web e, durante bastante tempo, isso fazia sentido. O problema é que em algum momento eu parei de construir apenas uma ficha digital ou uma ferramenta para RPG e comecei a tentar colocar dentro da mesma coisa multiplayer, estados diferentes para Mestre e jogador, logs, progressão, dados persistentes, mídia, rolagens 3D, sincronização, OBS e mais uma quantidade razoável de coisas que claramente estavam começando a se comportar muito mais como um jogo do que como um site.

E a arquitetura não cresceu junto com essa ambição.

O resultado foi aquele tipo de problema particularmente irritante de programação em que cada coisa individual funciona, mas mexer em uma delas começa a quebrar outras três. Interface dependia de estado, estado dependia de comunicação, comunicação começava a depender das regras e, quanto mais eu tentava resolver isso adicionando novas camadas por cima, mais difícil ficava descobrir exatamente onde uma regressão tinha começado.

A versão 0.3.0 foi basicamente o momento em que eu aceitei isso.

Eu tinha acabado de passar dias mexendo no Dice Engine e em várias outras partes do aplicativo, gastando uma quantidade considerável de contexto, automação e paciência para chegar numa versão que, no fim, continuava quebrando funcionalidades que já deveriam estar resolvidas. O pior nem era existir bug. Bug faz parte. O problema era eu já não confiar completamente no estado anterior do programa.

Eu corrigia uma coisa sem ter certeza se aquilo não tinha quebrado alguma função seis versões atrás.

Então, em vez de continuar construindo em cima de um chão que eu já não confiava, eu fiz uma coisa que normalmente parece uma péssima ideia quando você olha para a quantidade de trabalho envolvida:

Comecei de novo.

Não reaproveitei a aplicação antiga como base. Ela virou referência.

Os dados continuaram sendo úteis, o comportamento que eu já tinha descoberto continuou sendo útil, as telas serviram como referência visual, os erros principalmente serviram como referência do que eu NÃO queria fazer novamente, mas o novo Woof-Lands começou com um projeto vazio no Godot.

E olhando agora, algumas semanas depois, foi provavelmente uma das melhores decisões que tomei nesse projeto.

Refazer do zero não significou esquecer tudo

Uma coisa interessante sobre esse recomeço é que eu não precisei fingir que o programa antigo nunca existiu.

Em determinado momento eu criei um processo para importar uma parte da base antiga somente como material de teste. Hoje o Godot consegue carregar as antigas fichas, habilidades, forças, armas, armaduras e outros dados para que eu consiga desenvolver as telas usando informação real, sem precisar inventar um monte de “João Guerreiro, espada +10” só para descobrir se uma interface aguenta o tamanho dos dados de verdade.

Foram importadas para essa base de teste 7 fichas, 78 habilidades, 22 forças, 194 armas, 48 armaduras e uma magia, além de outros registros auxiliares.

Mas existe uma diferença importante aqui.

Esses dados não viraram automaticamente a nova estrutura oficial do programa. Eles entram através de uma camada de adaptação, como uma espécie de fotografia congelada do sistema antigo, para que o novo software consiga lê-los sem transformar o legado na fundação da arquitetura nova.

Isso parece uma distinção meio burocrática até você lembrar que foi exatamente a falta desse tipo de separação que me colocou naquela situação da primeira vez.

Dessa vez eu comecei pelas coisas chatas

Talvez a mudança mais importante do novo Woof-Lands nem seja o Godot em si.

É a forma como eu estou construindo.

Em vez de criar uma feature enorme, mexer em quinze sistemas e depois tentar descobrir o que sobreviveu, cada versão agora parte de um estado que eu sei que funciona e precisa terminar em outro estado que eu sei que funciona.

Eu literalmente passei a chamar isso de known-good.

A lógica é simples: faço uma parte pequena, testo, verifico regressão, salvo aquele estado e só depois continuo.

Então o novo Woof-Lands começou na 0.0.1 praticamente sem fazer nada além de abrir corretamente.

Depois veio a estrutura visual.

Depois os contratos entre as partes do programa.

Depois o backend.

Depois autenticação.

Depois gerenciamento de sessão.

Depois campanhas.

Depois as salas.

E só então comecei a colocar algumas das coisas mais ambiciosas novamente.

É bem menos emocionante escrever “implementei uma camada de sessão que separa autenticação do lifecycle do cliente Nakama” do que escrever “OLHA MEU DADO 3D EXPLODINDO NA TELA”, mas descobri da pior maneira possível que a segunda coisa fica muito mais divertida quando a primeira não resolve desmontar sozinha seis meses depois.

E o programa já mudou MUITO

A versão atual é a 0.0.8, e olhando só para esse número parece que ainda existe meia dúzia de arquivos e um botão escrito “Teste”.

Não existe.

Hoje o Woof-Lands já tem autenticação real usando Nakama, persistência através de PostgreSQL, gerenciamento de sessão, campanhas persistentes, membership de Mestre e jogadores e uma separação muito mais rígida entre aquilo que é interface, aquilo que é regra e aquilo que conversa com serviços externos.

As campanhas já não são apenas cards bonitos fingindo que representam alguma coisa.

Elas existem no backend.

Eu consigo criar uma campanha, entrar nela com outro usuário, consultar membros e derivar quem é Mestre, quem é Player e quem ainda está pendente.

Isso pode parecer pequeno perto da quantidade de coisas que eu quero colocar no Woof-Lands eventualmente, mas existe uma diferença gigantesca entre desenhar uma tela chamada “Campanhas” e efetivamente ter dois usuários diferentes conversando com um servidor e vendo o mesmo registro persistente.

Essa diferença era uma das coisas que eu queria preservar desde o começo dessa reconstrução.

A interface também mudou bastante.

Uma coisa que ficou muito evidente quando comecei a colocar todas as ferramentas de volta era que o Woof-Lands não funcionava muito bem como aquele modelo tradicional de aplicativo onde você abre uma página, fecha a página, abre outra página, fecha de novo...

Durante uma sessão eu quero olhar ficha, log, sala, inventário, grimório, campanhas e ferramentas do Mestre ao mesmo tempo.

Então o programa começou a ficar mais parecido com um software desktop de verdade.

Hoje existem janelas internas que podem ser abertas simultaneamente, arrastadas, redimensionadas, transformadas em abas, encaixadas em regiões diferentes da tela, minimizadas, maximizadas e restauradas depois que o programa é fechado.

Se eu quiser deixar uma ficha na esquerda, o log na direita e a sala embaixo, posso.

Se eu quiser transformar Habilidades e Inventário em abas, posso.

E, mais importante, o aplicativo lembra disso depois.

É uma daquelas coisas que eu não tinha colocado no plano original como uma “grande feature”, mas depois que comecei a usar ficou difícil imaginar o programa sem ela.

E agora chegamos novamente à Steam

Essa parte ficou particularmente curiosa porque aconteceu praticamente ao mesmo tempo que eu estava colocando o 13 Reis lá.

No caso do 13 Reis, eu consegui montar o jogo, validar o executável, empacotar os arquivos e mandar para o Depot.

É um programa relativamente autocontido.

No Woof-Lands, eu fiz praticamente o mesmo processo.

Criei um pipeline específico para gerar um Alpha Windows, validar os arquivos, garantir que nenhuma credencial, cache ou arquivo de desenvolvimento entrou no pacote, verificar os executáveis, abrir o programa standalone e só então permitir que aquela build fosse enviada para a Valve.

E ela foi.

Então sim.

O WOOF-LANDS TAMBÉM ESTÁ NA STEAM.

Tecnicamente.

O aplicativo já possui AppID 5377580, o Depot Windows é o 5377581 e, no dia 3 de outubro, o primeiro upload real foi aceito pela Steam como o BuildID 25700454.

A Steam recebeu os arquivos do programa e registrou a build como:

Woof-Lands RPG v0.0.8-alpha

Então existe neste momento uma cópia real do Woof-Lands dentro da infraestrutura da Valve.

Só que aqui começa a diferença importante.

No 13 Reis, colocar o executável na Steam resolve uma parte gigantesca do problema de distribuição.

No Woof-Lands, colocar o executável na Steam resolve... o executável.

Porque o Woof-Lands não vive sozinho.

A Steam é uma peça da máquina, não a máquina inteira

Quando alguém abre o Woof-Lands e faz login, essa autenticação não acontece magicamente dentro do executável.

Existe uma chamada para um servidor Nakama.

Quando uma campanha é criada, ela precisa continuar existindo depois que o Mestre fecha o programa.

Isso precisa ser persistido.

Quando outro jogador entra naquela campanha, o servidor precisa reconhecer que aquela pessoa existe e determinar qual é a relação dela com aquele grupo.

Então existe banco de dados.

Existem chamadas de rede.

Existe estado que não pode depender da memória do computador do Mestre.

E hoje, durante o desenvolvimento, esse backend ainda roda localmente.

O cliente usa por padrão:

127.0.0.1:7350

Ou seja, “o servidor está neste mesmo computador”.

Isso é perfeito enquanto eu estou desenvolvendo.

É completamente inútil para uma pessoa que baixar o jogo pela Steam em outro lugar do planeta.

Se eu simplesmente publicar essa build amanhã, a Steam vai instalar o programa perfeitamente, ele vai abrir, a interface vai aparecer... e quando chegar a hora de conversar com o backend ele vai procurar um servidor Nakama dentro do próprio computador daquela pessoa.

Surpresa: não existe um.

Então antes de transformar esse upload em um Alpha realmente distribuível eu preciso resolver o ambiente de produção.

Preciso hospedar o backend em algum lugar, configurar os endpoints corretamente, garantir conexão segura, separar desenvolvimento, Alpha e produção, revisar como autenticação e configuração são entregues e fazer tudo isso sem colocar credencial sensível dentro de um executável que qualquer pessoa pode baixar.

E isso já transforma “colocar o jogo na Steam” em uma coisa um pouco diferente de apertar Upload.

E eu ainda resolvi colocar a Steam DENTRO do programa

Para facilitar, obviamente eu também resolvi integrar o próprio sistema de salas à Steam.

Porque aparentemente eu gosto de problemas.

As campanhas continuam existindo no Nakama e no PostgreSQL porque elas são persistentes. Uma campanha precisa continuar existindo independentemente de alguém estar online naquele momento.

Mas uma Sala é diferente.

Uma Sala existe enquanto as pessoas estão reunidas jogando.

Então agora o Woof-Lands usa Steamworks Lobbies para essa parte.

O Mestre cria um Lobby privado, jogadores podem entrar usando convite da Steam ou o identificador da sala, a presença vem da própria Steam e o programa cruza aquela pessoa com o membership salvo na campanha para decidir se ela é Mestre, Player ou alguém que não deveria estar ali.

Isso já está funcionando localmente com Steam real.

O teste consegue criar Lobby, publicar metadados, reconhecer presença e sair corretamente.

Também existe suporte para o fluxo nativo de convite.

E uma coisa que faço questão de preservar é que nenhuma tela do programa conversa diretamente com a Steam. A interface pede alguma coisa para o aplicativo, o aplicativo conversa com um serviço de Sala e só depois existe uma camada específica que conhece GodotSteam.

Parece excesso de zelo.

Até o dia em que eu resolver trocar alguma coisa e descobrir que 47 botões diferentes possuem Steam. escrito diretamente no código.

Eu conheço essa história.

Foi literalmente por isso que comecei tudo de novo.

E ainda tem vídeo, áudio, OBS e mais um pequeno inferno pela frente

Talvez a parte mais absurda seja que o sistema de Sala nem é o ponto final.

O Woof-Lands sempre teve aquela ideia de servir também como ambiente de sessão, então dentro da Sala existe agora uma fundação para até um Mestre e oito jogadores, com nove espaços de participantes, layouts automáticos, foco em participante, HUD de ficha e separação entre aquilo que o Mestre vê e aquilo que pode aparecer numa saída pública.

Eu quero que essa saída eventualmente possa alimentar OBS, gravação e outras formas de apresentação.

Também comecei a desenhar as fronteiras para câmera, captura de tela, canais independentes de áudio, efeitos VST3 e gravação separada dos participantes.

Mas aqui existe uma palavra importante:

fronteiras.

A câmera real ainda não está sendo transmitida.

Não existe ainda um servidor de vídeo mágico enviando nove câmeras.

Não existe host VST3 processando áudio dentro do programa.

Não existe encoder gravando uma sessão inteira.

O que existe agora é a estrutura que define onde essas coisas vão entrar sem eu precisar desmontar o programa quando chegar a hora.

Eu aprendi essa lição.

Um pouco tarde, talvez.

Mas aprendi.

E a mídia também não vai simplesmente “passar pela Steam”. A Steam ficou responsável pela presença e pela sessão. O transporte de vídeo e áudio será uma responsabilidade separada, provavelmente envolvendo uma arquitetura própria de transporte e eventualmente WebRTC/SFU.

Ou seja, antes mesmo de pensar em lançamento existem várias infraestruturas diferentes precisando conversar corretamente sem se transformar naquela teia de dependências que matou a versão antiga.

Godot.

Steam.

Nakama.

PostgreSQL.

Mídia.

Persistência.

Identidade.

Permissões.

Tudo isso precisa parecer uma coisa só para quem está usando.

Mas no código elas precisam continuar sendo coisas diferentes.

Talvez essa seja a principal diferença entre o Woof-Lands antigo e o novo.

Dessa vez eu sei exatamente onde as coisas terminam

Uma coisa que eu não percebia muito na aplicação antiga era como as fronteiras tinham começado a desaparecer.

Em algum momento tudo conhecia tudo.

No novo projeto eu tenho documentos inteiros basicamente dizendo:

“Você não atravessa esta linha.”

A UI não escreve direto no banco.

A UI não decide regra.

A Sala não vira banco de campanha.

A Steam não determina quem é Mestre.

O Nakama não precisa renderizar dado 3D.

O sistema de mídia não pode receber informação privada só porque seria conveniente.

O cliente pode pedir uma rolagem, mas não deveria poder simplesmente afirmar para o servidor que tirou o resultado que queria.

Cada uma dessas decisões parece pequena individualmente.

Juntas elas são provavelmente a coisa que está permitindo que o projeto cresça novamente sem eu sentir aquela sensação constante de que estou empilhando móveis em cima de um piso podre.

E, ironicamente, refazer tudo do zero acabou fazendo o projeto avançar muito mais rápido depois que a fundação ficou pronta.

Então... já dá para baixar pela Steam?

Não.

Essa é a parte divertida.

O arquivo está lá.

A Valve recebeu a build.

O executável existe.

A integração com o AppID real existe.

O pipeline de atualização existe.

O Steam Lobby existe.

Mas eu ainda não coloquei nenhuma build como SetLive, nem publiquei uma branch Alpha para distribuição.

A default continua sem uma build pública.

E eu não quero liberar isso antes de resolver corretamente o backend remoto, porque testar um programa multiplayer distribuído fingindo que localhost é uma infraestrutura de produção seria uma forma bastante eficiente de recriar exatamente o tipo de dívida técnica da qual eu acabei de fugir.

Então, diferente do 13 Reis, chegar à Steam não é exatamente a linha de chegada dessa etapa.

É mais como chegar no estacionamento.

Ainda preciso entrar no prédio.

Mas existe uma diferença psicológica bastante grande entre “um dia eu quero colocar isso na Steam” e abrir o Steamworks e ver:

Woof-Lands RPG v0.0.8-alpha

BuildID 25700454.

Talvez eu esteja ficando perigosamente acostumado com essa sensação.

Em questão de poucos dias eu mandei dois projetos diferentes para os servidores da Valve.

Um deles é um jogo de estratégia que começou com uma ideia estranha envolvendo xadrez.

O outro é uma ferramenta de RPG que começou como uma aplicação web, cresceu até a própria arquitetura não aguentar mais, foi desmontada, reconstruída praticamente do zero em outra engine e agora está começando a recuperar funções que meses atrás eu tinha genuinamente medo de tocar.

Então acho que o estado atual do Woof-Lands pode ser resumido de uma forma relativamente simples:

Ele ainda não está pronto.

Mas dessa vez eu sei por quê.

E, mais importante, eu sei o que falta.