Um mini-jogo que segura 60 fps no estúdio começa a engasgar em um celular real no instante em que um chefe aparece. O primeiro instinto do time é culpar a GPU, cortar polígonos e rezar. Esse palpite costuma estar errado. Os frames não morrem no renderizador. Morrem na thread principal, onde sua lógica de jogo divide uma fila com a manutenção da plataforma — e uma tarefa longa ali derruba tudo.

A GPU é bode expiatório

Em mini-jogos o gargalo raramente parece gráfico. Você não está renderizando uma cena AAA; está renderizando algumas centenas de sprites. A GPU do celular comeria isso no café da manhã. O que ela não sobrevive é a thread principal congelar por 50 milissegundos enquanto seu código faz algo que não deveria ter feito naquele frame.

Runtimes de mini-programa executam seu jogo na mesma thread que o host usa para seu próprio trabalho. Então seu update() e o passe de layout da plataforma são vizinhos. Se o vizinho ocupa a rua, seu frame perde o trem.

Três culpados que aparecem em cada engasgo

Layout thrash. Você lê uma posição, escreve um estilo, lê de novo — em um loop sobre 200 nós. Cada leitura obriga o navegador a descarregar o layout primeiro. Isso não é problema de GPU. É você fazendo a thread principal recalcular a página inteira entre leituras. Agrupe suas escritas e leia uma vez.

Storage síncrono e JSON grande na inicialização. Um arquivo de fase de 4 MB parseado com JSON.parse na rota crítica, ou um getStorageSync que bloqueia até o disco responder, é uma travada garantida bem quando o jogador é mais impaciente. Parseie fora da rota crítica, ou faça em streaming.

Lixo por frame. Alocar um novo array de objetos todo frame faz o coletor de lixo acordar e pausar tudo para limpar. O coletor não se importa que você esteja no meio de uma animação. Reuse objetos, coloque suas partículas em pool, e o GC fica quieto.

O que um runtime pode fazer e você não pode de dentro do jogo

Um runtime próprio do host se senta abaixo do seu código e pode fazer coisas que um autor de jogos sozinho não tem permissão de fazer. Pode dar ao seu jogo um worker dedicado para que o parse pesado e o passo de física parem de competir com a chamada de desenho. Pode agrupar escritas de layout que a plataforma de outro modo descarregaria uma a uma. E pode pré-buscar os assets da próxima fase enquanto você ainda está na tela de carregamento, para que o primeiro chefe não dispare uma leitura de disco no meio da luta.

Nada disso exige reescrever o motor. O runtime muda onde o trabalho acontece, não o que o trabalho é.

SintomaOnde realmente viveOtimizado por runtime
Engasgo no chefeTarefa longa na thread principalWorker dedicado para lógica
Travada na inicializaçãoParse síncrono + storagePrefetch + parse fora da rota
Micro-congelamentosPausas do GCGuia de pooling de objetos
Jank em celulares baratosLayout thrashEscritas de layout agrupadas

A concessão que você tem de aceitar

Mover trabalho para um worker não é de graça. Cada mensagem que você passa pela fronteira da thread tem um custo, e se dividir demais, trocou um congelamento por mil pequenas pausas. O movimento honesto é mover só o trabalho realmente pesado e infrequente — parse de fase, ordenações grandes, crunch de rede — e deixar o loop por frame onde está. Um runtime que descarrega tudo é um runtime que gasta mais em overhead do que economiza.

Meça o frame, não a sensação

Não ajuste no olho. Puxe a contagem de tarefas longas e o percentil 95 do tempo de frame de dispositivos reais em um Android de médio porte, o que seus jogadores realmente usam. Um jogo que se sente "mais ou menos bem" costuma esconder uma dúzia de frames de 80 ms no primeiro minuto — e esses são exatamente os frames onde um jogador decide que o jogo parece barato e o fecha.

Suave não é luxo em mini-jogos. É o produto. Um jogo que derruba frames no momento errado não tem segunda chance dentro de um super app onde o próximo jogo está a um toque.

Fontes