JARU 0.9.7: editor de escenas, más velocidad en placa y un IDE renovado
Ya está disponible JARU 0.9.7. Si la 0.9.6 fue la versión del motor de físicas y del sonido, esta es la de hacer juegos más deprisa y que corran mejor en la placa: llega un editor de escenas para diseñar salas sin escribir el código a mano, el intérprete va bastante más rápido y gasta menos memoria en los ESP32, y el IDE estrena aspecto y un editor de sprites nuevo.
Antes de recompilar tus proyectos, mira el apartado de cambios incompatibles: hay que grabar el firmware nuevo en las placas, y unos pocos cambios de comportamiento pueden pedir tocar código.
Editor de escenas
Es la novedad grande. Una escena es una sala de tu juego —la Fase 1, el castillo, la pantalla del jefe— y se diseña en su propia ventana del IDE:
- Capas de tiles, de imagen y de objetos, con parallax y repetición, y una cámara que sigue a un objeto dentro de sus límites.
- Objetos con comportamientos que se añaden sin escribir código: patrullar, seguir una ruta, perseguir o huir, control de plataformas o top-down, vida, animación, generadores de enemigos... Doce en total, y cada objeto puede llevar su masa, su fricción, su rebote o su gravedad.
- Reglas de la sala: cuando el jugador toca una moneda, suma puntos y destrúyela; cuando cae al foso, pierde una vida y repite la sala.
- Máquinas de estados: un enemigo que patrulla despacio y, si te acercas, te persigue deprisa.
- Variables y controles del juego, que pasan de una sala a otra: puntos, vidas, y las teclas, los GPIO de cada placa o los botones de un mando.
- Un panel de problemas que avisa antes de ejecutar de lo que no va a funcionar, y un Play que ejecuta la sala en la VM sin salir del editor.
Lo importante es cómo funciona por dentro: al compilar, cada escena se traduce a código JARU normal, un .aru que tu juego importa. No hace falta nada especial en la VM, así que una sala hecha en el editor funciona igual en Windows y en todas las placas, y siempre puedes abrir el código generado para ver qué hace. Un juego con muchas salas puede además cargarlas como datos con SceneLoad: el Build guarda como datos las salas que no llevan comportamientos, máquinas de estados, plantillas, variables ni código propio, y el juego no carga el código de cada una.
Para empezar, la guía nueva Tu primer juego con salas explica el bucle del juego, cómo se cambia de sala y la pantalla de título y de fin. Los ejemplos StarterPlatformer y StarterTopDown del IDE son plantillas listas para copiar.
Más rápido y con menos memoria en la placa
- Superinstrucciones: el compilador fusiona las secuencias de bytecode más frecuentes en instrucciones únicas. Sobre JaruBench, 1,47‑1,48 veces más rápido en ESP32, ESP32-S3 y ESP32-P4, y hasta 2,5 veces en bucles apretados. No cambia nada del lenguaje.
- Tablas de saltos en el intérprete de las placas: otro 1,2‑1,7 en ESP32 y S3.
- Volcado parcial de pantalla en ESP32 y S3:
Display.update()solo manda al LCD lo que ha cambiado. - Menos RAM interna: decenas de KB por juego en la TTGO, entre el montón sin heap poisoning, las cadenas en un solo bloque y las constantes compartidas.
- Un BMP por sprite en vez de uno por fotograma: JaruGoody carga en la TTGO en 6 segundos en vez de 49.
Ritmo fijo con Display.fps
Al ir más rápida, una placa pinta los fotogramas sin scroll varias veces más deprisa que los que tienen scroll, y un juego que avanza una cantidad fija por fotograma cambiaba de velocidad según lo que hubiera en pantalla. Ahora basta una línea:
Display.fps = 30 // 30 pasos por segundo en todas las placas
Display.update() espera hasta el siguiente paso y devuelve cuántos tocan, por si el juego quiere recuperar los que se han quedado atrás sin pintarlos; Display.dt da los segundos reales entre fotogramas. Los detalles, en la guía de Display.
Físicas y colisiones
En el anuncio de la 0.9.6 avisé de un límite: el motor no sostenía una pila de cajas. Ya la sostiene, también a 20‑30 fps en la placa. Además, un cuerpo KINEMATIC que gira golpea de verdad (las paletas de un pinball) y la colisión con mapas recibe una tanda larga de arreglos: plataformas de un solo sentido pisadas por la esquina, rectángulos girados, grid.get con wrap y el collider que se voltea con el sprite.
Para los juegos que resuelven sus propios choques, sprite.contacts() devuelve la normal y la profundidad de cada contacto:
// Sacar al jugador de los obstáculos que está tocando
var contactos = jugador.contacts(obstaculos)
if (contactos != nil) then
foreach (var c in contactos)
var nx = c[1], ny = c[2], depth = c[3]
jugador.x += nx * depth
jugador.y += ny * depth
end
end
IDE
- JARU Slate: un estilo oscuro común a todas las ventanas, con el azul reservado para lo que está encendido o es la acción principal.
- Editor de sprites nuevo: deshacer, corte por lotes, pivote y collider editables, y actores y poses. Un actor agrupa los sprites de un personaje y el IDE genera el código que los carga:
var tiki = ActorTikiLoad(). - Imágenes y mapas: selección rectangular con copiar y pegar, rejilla de tile y herramientas Rect y Line en el editor de mapas.
- Ejecutar: el Play ya no deja una consola abierta y lo que imprime el juego llega al Output; Run en placa comprueba qué firmware lleva y, si no es la VM de JARU, ofrece grabarlo.
- Unos ochenta arreglos que salen de un análisis de usabilidad, sobre todo de los que perdían trabajo sin avisar.
Placa nueva: ESP32-S31
Hay una VM para el ESP32-S31 (placa ESP32-S31-Korvo-1), con pantalla RGB de 800x480, teclado USB y SD, y el IDE la configura y la graba como las demás. Y para cualquier placa con bus I2C, soporte para el mando Adafruit Mini I2C Gamepad: se asigna en los controles del juego igual que una tecla o un GPIO.
Cambios incompatibles
| Cambio | Qué hacer |
|---|---|
| Los programas compilados con 0.9.7 necesitan el firmware 0.9.7 | Graba la VM en cada placa con Flash Firmware antes de subir programas |
/ entre dos enteros va en doble precisión y div es exacto | Nada, salvo que el programa dependa del redondeo de antes |
nan == nan es false, como en cualquier lenguaje | Para saber si un valor es NaN, v != v |
Una función sin su end es un error de compilación (suele ser un else if, que en JARU es elsif) | Corrige el end o el elsif que señala el error |
grid.set y grid.clear solo aceptan valores de 0 a 255 | Los valores fuera de rango lanzan un error en vez de recortarse sin avisar |
flipX y flipY voltean también el collider | Revisa los colliders descentrados de los sprites que se voltean |
| El sprite trae el pivote y el collider del editor de sprites | Quita las compensaciones a mano, si las había |
La lista completa, con los arreglos y los problemas conocidos, está en las notas de la versión, que también se instalan con el IDE.
Descarga
JARU IDE 0.9.7 para Windows está disponible en la web:
Descomprime el ZIP y ejecuta el instalador que hay dentro. Si ya tienes el IDE instalado, él mismo te avisará de que hay versión nueva.
FAQ
¿Tengo que recompilar mis proyectos de 0.9.6?
Sí. El bytecode y los sprites del Build han cambiado, así que hay que regenerarlos; el IDE lo hace al compilar. Revisa además la tabla de cambios incompatibles.
¿Tengo que volver a grabar las placas?
Sí, una vez: Flash Firmware en cada placa. Un firmware 0.9.6 no sabe ejecutar el bytecode nuevo, y no avisa al recibirlo: el programa se para en la primera instrucción nueva con «Unknown Opcode encountered». Si te pasa, graba el firmware y vuelve a pulsar Run. Desde la 0.9.7, la propia VM rechaza con un aviso los programas de una versión posterior.
¿El editor de escenas sustituye a escribir código?
No. Genera código JARU normal que tu juego importa, y en cada sala puedes añadir tu propio código, por objeto o al crearla. Lo que el editor no cubre se sigue haciendo como siempre.
¿Necesito un ESP32-S31?
No. Es una placa más. La versión funciona igual en ESP32, ESP32-S3 y ESP32-P4, y el desarrollo sigue empezando en la VM de Windows.