Un mini-juego que aguanta 60 fps en el estudio empieza a temblar en un teléfono real en cuanto aparece un jefe. El primer instinto del equipo es culpar a la GPU, recortar polígonos y rezar. Esa suposición suele estar equivocada. Los frames no mueren en el renderizador. Mueren en el hilo principal, donde tu lógica del juego comparte una cola con el mantenimiento de la plataforma — y una tarea larga allí tira todo.

La GPU es un chivo expiatorio

En los mini-juegos el cuello de botella rara vez se parece a gráficos. No estás renderizando una escena AAA; estás renderizando unos pocos cientos de sprites. La GPU del teléfono se los comería en el desayuno. Lo que no sobrevive es que el hilo principal se congele 50 milisegundos mientras tu código hace algo que no debería haber hecho en ese frame.

Los runtimes de mini-programa ejecutan tu juego en el mismo hilo que el host usa para su propio trabajo. Así que tu update() y el pase de layout de la plataforma son vecinos. Si tu vecino ocupa la calle, tu frame pierde el tren.

Tres culpables que aparecen en cada temblor

Layout thrash. Lees una posición, escribes un estilo, vuelves a leer — en un bucle sobre 200 nodos. Cada lectura obliga al navegador a vaciar el layout primero. Eso no es un problema de GPU. Es tú haciendo que el hilo principal recalcule toda la página entre lecturas. Agrupa tus escrituras y lee una vez.

Almacenamiento síncrono y JSON grande al inicio. Un archivo de nivel de 4 MB parseado con JSON.parse en la ruta crítica, o un getStorageSync que bloquea hasta que el disco responde, es un tirón garantizado justo cuando el jugador es más impaciente. Parsea fuera de la ruta crítica, o hazlo en streaming.

Basura por frame. Asignar un nuevo arreglo de objetos cada frame significa que el recolector de basura despierta y pausa todo para limpiar. El recolector no le importa que estés a mitad de una animación. Reusa objetos, pon tus partículas en pool, y el GC se queda callado.

Lo que un runtime puede hacer y tú no desde dentro del juego

Un runtime propio del host se sienta debajo de tu código y puede hacer cosas que un autor de juegos no está solo autorizado a hacer. Puede darle a tu juego un worker dedicado para que el parse pesado y el paso de física dejen de competir con la llamada de dibujo. Puede agrupar escrituras de layout que la plataforma de otro modo vaciaría una por una. Y puede prefetchear los assets del siguiente nivel mientras sigues en la pantalla de carga, para que el primer jefe no dispare una lectura de disco a mitad de pelea.

Nada de esto requiere reescribir el motor. El runtime cambia dónde ocurre el trabajo, no qué trabajo es.

SíntomaDónde vive realmenteOptimizado por runtime
Temblor en jefeTarea larga en hilo principalWorker dedicado para lógica
Tirón al inicioParse síncrono + storagePrefetch + parse fuera de ruta
Micro-congelacionesPausas de GCGuía de pooling de objetos
Jank en teléfonos baratosLayout thrashEscrituras de layout agrupadas

La concesión que tienes que aceptar

Mover trabajo a un worker no es gratis. Cada mensaje que pasas por la frontera del hilo tiene un costo, y si divides demasiado, cambias un congelamiento por mil pequeñas pausas. El movimiento honesto es mover solo el trabajo realmente pesado e infrecuente — parse de nivel, ordenamientos grandes, crunch de red — y dejar el bucle por frame donde está. Un runtime que descarga todo es un runtime que gasta más en overhead de lo que ahorra.

Mide el frame, no la sensación

No ajustes a ojo. Saca el conteo de tareas largas y el percentil 95 del tiempo de frame de dispositivos reales en un Android de gama media, el que tus jugadores realmente usan. Un juego que se siente "mayormente bien" suele tener una docena de frames de 80 ms escondidos en el primer minuto — y esos son exactamente los frames donde un jugador decide que el juego se siente barato y lo cierra.

Lo fluido no es un lujo en los mini-juegos. Es el producto. Un juego que tira frames en el momento equivocado no tiene una segunda oportunidad dentro de un super app donde el siguiente juego está a un toque.

Fuentes