Here To Slay, parte 8: colocando no ar
Do jogo que só rodava na minha máquina a um executável que conecta num servidor de 1 vCPU e 2 GB, o teste de carga que achou um bug no lobby e o que as primeiras partidas com outras pessoas mostraram.
Com a engine nova da parte 7, as regras estavam no lugar. Mas o Here To Slay ainda só existia de verdade na minha máquina, com três brokers Kafka e um monte de réplicas rodando no Docker, e todas as partidas eram eu contra eu mesmo em duas abas. Para jogar com os amigos faltavam três coisas: um jeito de as pessoas abrirem o jogo, um servidor para ele rodar e um jogo que aguentasse gente de verdade do outro lado.
Antes de chamar alguém
Jogar sozinho em duas abas esconde muita coisa. Ninguém demora para carregar, ninguém cai no meio da partida e ninguém tenta entrar em duas mesas ao mesmo tempo. Antes de chamar alguém, fui atrás desses casos:
- Tela de carregamento. Fiquei em dúvida sobre como jogos de verdade lidam com isso, e a resposta é quase sempre a mesma: a partida espera todo mundo se conectar antes de começar. Agora ela espera até 30 segundos e começa com quem chegou.
- Queda de conexão. Se a conexão de alguém cai no meio da partida, só essa pessoa é desconectada. O chat avisa a mesa, a partida espera 60 segundos para ela voltar e depois segue sem ela. Quem quiser sair de vez tem um botão de desistir.
- Uma mesa por jogador. Dava para entrar em duas partidas ao mesmo tempo, com resultados bem estranhos. Agora o lobby sabe quem já está jogando e bloqueia a segunda.
- Todo mundo vê a escolha. Quando um efeito pede para escolher uma carta ou um jogador, os outros ficavam olhando para a mesa parada. Agora todos veem a mesma tela de seleção de quem está escolhendo, sem poder mexer.
O bloqueio de mesa mudou o papel de um tópico. Na parte 3, o match-state-store foi pensado para guardar o estado inteiro de cada partida, e eu admiti que essa recuperação não funcionava direito. Hoje ele guarda outra coisa: a lista de jogadores de cada partida (o roster), quem ainda está ativo e se a partida terminou. Cada engine republica essa lista a cada cinco minutos, como um sinal de que a partida continua viva. O lobby lê o tópico para saber quem já está jogando, e o gateway usa a mesma lista para entregar os alertas do monitoramento.
O mesmo código, dois tamanhos
O servidor é pequeno: 1 vCPU e 2 GB de RAM, com um Nginx na frente cuidando do HTTPS e encaminhando o WebSocket para o gateway. Daí para dentro, a arquitetura é a mesma da parte 3: gateway, lobby, engine e monitoramento conversando só por tópicos do Kafka.
Três brokers e sete réplicas não cabem ali, então existe um segundo arquivo de Compose, mais enxuto: um broker, um container de cada serviço e JVMs limitadas para caber na memória.
gateway:
environment:
JAVA_TOOL_OPTIONS: "-Xmx160m -Xss512k -XX:+UseSerialGC"
kafka-broker-1:
environment:
KAFKA_HEAP_OPTS: "-Xms256m -Xmx320m"
Essa foi uma vantagem inesperada de ter separado tudo por tópicos: o código é o mesmo nos dois ambientes. Só muda quantas cópias de cada coisa estão rodando.
Um executável
Dá para jogar pelo navegador, mas eu queria que meus amigos baixassem um arquivo, abrissem e caíssem direto no jogo, sem configurar nada. Para isso, empacotei o cliente React com o Electron, que gera um executável já apontando para o servidor. Escolhi gerar só a versão portátil, para Windows e Mac: um arquivo que abre sem instalar.
As primeiras versões do executável trouxeram problemas que o navegador não tinha:
- Os símbolos das classes não apareciam. Eles vinham de uma fonte carregada da internet, e a política de segurança do Electron bloqueava. A fonte passou a vir junto com o app.
- Fechar e abrir de novo voltava para o login, mas a conta antiga continuava presa na partida. Agora o cliente guarda a sessão e, ao abrir, retoma a mesma conta e volta para a mesa ou partida onde estava.
- O arquivo é pesado. O portátil tem uns 159 MB, e quase nada disso é o jogo. O Electron traz um Chromium inteiro dentro do app, e a música de fundo, uma hora de MP3, ocupa sozinha 58 MB. O código do jogo tem menos de 1 MB.
Quanto o servidor aguenta
Com o jogo no ar, a pergunta seguinte foi quantas pessoas cabem num servidor desse tamanho. Para descobrir, escrevi um script em Node que abre conexões WebSocket como se fosse o cliente: cada partida tinha dois jogadores simulados que faziam login, criavam ou entravam numa mesa, marcavam pronto e jogavam em ritmo humano, com uma ação a cada 1,5 a 3 segundos. Fui aumentando o número de partidas simultâneas aos poucos, segurando cada nível por pouco mais de um minuto, enquanto media o tempo de resposta de cada ação e a CPU e a memória do servidor.
| Partidas (jogadores) | Resposta mediana | p95 | CPU média |
|---|---|---|---|
| 10 (20) | 165 ms | 210 ms | 26% |
| 30 (60) | 168 ms | 324 ms | 50% |
| 60 (120) | 184 ms | 351 ms | 78% |
| 100 (200) | ~200 ms | até 549 ms | ~85% |
| 130 (260) | 276 ms | 909 ms | 98% |
O servidor aguenta cerca de 100 partidas ao mesmo tempo, ou 200 jogadores. O limite é o processador único, que satura perto de 130 partidas; a memória da engine subiu só de 95 para 124 MB. Para um jogo de cartas entre amigos, sobra muito.
O bug que o teste achou
O número mais útil do teste não estava na tabela. De vez em quando, uma mesa não começava: um dos jogadores tinha entrado e marcado pronto, mas o lobby agia como se ele nunca tivesse feito isso. Com dezenas de mesas sendo criadas ao mesmo tempo, o problema aparecia o tempo todo.
A causa estava em como o lobby usa o Kafka. Cada mudança numa mesa é gravada no tópico compactado lobby-state-store, e todas as instâncias do lobby leem esse tópico em segundo plano para manter as réplicas em dia. Só que a instância que gravou também lia a própria gravação, e às vezes ela chegava atrasada: uma foto antiga da mesa sobrescrevia, na memória, uma entrada ou um “pronto” que tinha acabado de acontecer. Um segundo problema piorava tudo: o id de cada mesa era o horário em milissegundos, e duas mesas criadas no mesmo milissegundo ficavam com o mesmo id.
A correção foi marcar cada gravação com a instância que a fez, num header do Kafka, e ignorar as próprias gravações na leitura em segundo plano. Os ids passaram a seguir o relógio, mas sem nunca repetir:
long now = System.currentTimeMillis();
long uniqueId = lastLobbyId.updateAndGet(prev -> Math.max(prev + 1, now));
Esse é o tipo de bug que um teste com duas abas nunca mostraria. Ele só aparece quando muita coisa acontece ao mesmo tempo, e poderia acontecer com jogadores de verdade.
O que as partidas de teste mostraram
Depois do teste de carga, vieram as partidas de verdade, com outras pessoas jogando pelo executável. Cada partida terminava com uma lista de anotações, quase todas sobre tempo e visibilidade, coisas que nenhum teste automatizado pegaria:
- O resultado dos dados precisa ficar na tela. Os dados paravam e a partida seguia na hora, e ninguém conseguia ver o que tinha saído, principalmente depois dos modificadores. Agora cada resultado fica visível por alguns segundos, mesmo quando ninguém joga modificador.
- A barra da rolagem acompanha os modificadores. O número em cima mudava, mas a barra de 2 a 12 continuava mostrando o valor original. Hoje as duas mostram o mesmo total.
- Todo mundo pode reagir. As janelas de modificador e de desafio passaram a abrir para todos os jogadores e a esperar o tempo inteiro, e quem passou a vez pode voltar atrás enquanto a janela estiver aberta.
- Escolher é sempre uma escolha. Mesmo quando só existe uma opção, como destruir um herói quando o adversário só tem um, o jogador precisa escolher. Resolver sozinho deixava as pessoas sem entender o que tinha acontecido.
- O chat virou uma gaveta, que dá para recolher sem perder as mensagens novas, e o texto de vitória só aparece depois que as animações da última jogada terminam.
- A carta desafiada sai voando de quem a jogou, para ficar claro de onde ela veio.
- Recarregar a página não tira ninguém da partida. O cliente reconecta e volta para a mesa no ponto em que estava.
E algumas regras estavam implementadas diferente do manual. A ordem dos turnos não saía da maior rolagem de iniciativa, os modificadores não entravam nas rolagens contra monstros e a Fist of Reason não valia em todas as rolagens de desafio. As três foram corrigidas.
O jogo ainda está em teste com alguns jogadores, e cada partida com gente nova traz uma lista nova de ajustes. Colocar no ar mostrou que fazer o jogo funcionar na minha máquina era só metade do trabalho: a outra metade aparece quando outras pessoas começam a jogar.