Here To Slay, parte 9: a parte visual e o Electron
Por que o cliente do Here To Slay é uma aplicação web em TypeScript dentro do Electron, o que essa escolha cobra e se vale a pena trocá-la por uma ferramenta feita para jogos, como o Godot ou o PixiJS.
Quase todos os textos até aqui falaram do servidor: o Kafka, o monitoramento, a engine de regras. A parte que os jogadores realmente veem aparece nos prints, no redesign da parte 5 e no executável da parte 8, mas nunca ganhou um texto só dela. Este texto é sobre ela: do que o cliente é feito, por que ele não usa uma engine de jogo e se vale a pena mudar isso.
O que é o cliente
O cliente é escrito em TypeScript com React, e o Vite cuida do desenvolvimento e do build. Para virar um aplicativo de desktop, ele é empacotado com o Electron, que junta um navegador Chromium e o Node.js num executável e abre o jogo ali dentro. O mesmo código também roda direto no navegador.
As cartas são elementos HTML, as animações são feitas com CSS, Framer Motion e GSAP, os sons tocam com o Howler, e a única peça realmente “de jogo” é a biblioteca que desenha os dados em 3D.
Por que essa escolha
O motivo mais forte é que quem decide tudo é o servidor. Desde a parte 2, o cliente recebe o estado da partida pelo WebSocket, mostra na tela e manda as ações do jogador. Ele faz algumas contas para exibir as coisas, como a chance de cada rolagem e as animações que saem da comparação entre dois estados, mas nenhuma regra do jogo roda nele. Não existe física, colisão nem um laço de jogo rodando o tempo todo, que é onde uma engine de jogo mais ajuda. Um jogo de cartas por turnos é, em boa parte, uma interface.
E boa parte dessa interface é menu: login, lista de mesas, sala de espera, chat, configurações, inspetor de cartas, três idiomas. É texto, formulário e lista, exatamente o que HTML e CSS fazem bem.
Também pesou o que eu tinha feito logo antes. Em julho de 2025, para a disciplina de Redes, eu tinha construído o Pokémon UFES Crater, um jogo multiplayer com cliente em React e Vite conversando por WebSocket com um servidor em Java. Quando o Here To Slay começou, em setembro, ele nasceu com essa mesma combinação.
O Electron veio junto desde o primeiro commit, que já tinha um script para gerar o executável de Windows. Desde o começo, então, o plano era um aplicativo de desktop, e não um site.
O que o Electron cobra
O Electron resolve um problema real: transformar uma aplicação web num aplicativo de desktop para Windows e Mac sem reescrever nada. Mas ele cobra caro, e não só no meu projeto. As críticas abaixo são bem conhecidas:
- Tamanho. Cada aplicativo Electron leva o próprio Chromium e o próprio Node.js. É por isso que, como contei na parte 8, quase nada do executável do Here To Slay é o jogo em si.
- Memória. Como é um navegador inteiro, cada janela abre vários processos, e o consumo fica bem acima do de um aplicativo nativo equivalente.
- Segurança. Uma página web com acesso ao sistema precisa ser configurada com cuidado, e as regras de segurança às vezes pegam de surpresa. Foi assim que as fontes carregadas da internet foram bloqueadas no executável, e os símbolos das classes simplesmente não apareciam.
- Atualização. Manter todo mundo na versão mais nova exige montar um sistema de atualização próprio. Enquanto isso não existe, cada pessoa fica com a versão que baixou, e foi por isso que o servidor ganhou uma versão mínima de cliente: um cliente antigo não consegue entrar e recebe o link da versão nova.
Existem alternativas que atacam parte disso sem trocar de tecnologia. A mais conhecida é o Tauri, que usa o navegador que já vem no sistema (o WebView2 no Windows e o WebKit no Mac) em vez de levar um Chromium junto. Os aplicativos ficam muito menores, mas o ganho de memória varia bastante, e cada sistema passa a desenhar o jogo com um navegador diferente, o que traz seus próprios problemas.
E se eu trocasse por uma ferramenta de jogo?
É uma pergunta que eu me faço sempre que quero uma animação mais caprichada e o CSS começa a brigar comigo. A boa notícia é que a arquitetura ajuda: como toda a lógica está no servidor, um cliente novo só precisaria falar o mesmo protocolo. O Kafka, as regras e o catálogo de cartas continuariam iguais.
A má notícia é que eu teria que reescrever o cliente inteiro, e algumas partes dariam mais trabalho do que parece:
- O protocolo não tem um contrato formal. As mensagens são JSON montado à mão no servidor, e os tipos só existem no TypeScript do cliente. Em outra linguagem, eu teria que redescobrir cada campo.
- Alguns dados só existem no cliente, como os textos das cartas e da interface nos três idiomas e o cálculo das chances de cada rolagem.
- As animações são deduzidas. Como contei na parte 5, o servidor manda só o estado da mesa, e o cliente compara o estado novo com o anterior para descobrir o que aconteceu. Toda essa lógica teria que ser refeita.
- Os menus pioram. Tudo o que hoje é formulário e lista em HTML teria que ser refeito com o sistema de interface da ferramenta nova.
As opções
Uma biblioteca de jogos dentro do app atual. O PixiJS é uma biblioteca de desenho 2D com WebGL, e o Phaser é um framework de jogos completo, os dois em JavaScript e TypeScript. Nesse caminho, login, taverna, sala de espera e chat continuam em React, e só a mesa e as cenas de jogo passam a ser desenhadas pela biblioteca. Dá para ganhar partículas, efeitos e animações mais fluidas sem perder o navegador, e a migração pode ser feita uma cena por vez, começando pela rolagem de dados, por exemplo. A desvantagem é que o Electron continua lá, com todo o peso dele.
O Godot. É a engine que mais combina com um jogo de cartas 2D: é gratuita, de código aberto, tem WebSocket e um sistema de interface bom o bastante para os menus. Exporta para Windows, Mac, Linux, Android e iOS sem levar um navegador junto. A versão para navegador melhorou bastante nas versões mais recentes, que passaram a funcionar sem recursos que o Safari não suportava, mas ainda é mais limitada que as outras. O custo é o maior de todos: uma linguagem nova, uma ferramenta nova e o cliente reescrito do zero.
Outras engines. Existem opções como o Defold, leve e voltado para 2D, o Flutter com o Flame, que faz mais sentido quando o “aplicativo” pesa mais que o “jogo”, e o Unity, que é a mais madura de todas, mas pesada demais para um jogo de cartas como este.
Vale a pena?
Hoje, para mim, não vale trocar tudo. O que o jogo mais precisa agora são os ajustes que saem das partidas de teste, e reescrever o cliente pararia isso por meses. A tecnologia atual não está impedindo nada importante de acontecer.
O que vale é preparar o terreno, porque isso ajuda qualquer caminho que eu escolher depois:
- escrever um contrato para as mensagens entre o cliente e o servidor;
- tirar os textos das cartas e da interface do código e colocá-los em arquivos de dados que qualquer cliente consiga ler.
Com isso feito, o passo mais provável é o mais gradual: colocar uma biblioteca como o PixiJS só na mesa, onde as animações mais importam.