Genesis Lowpoly

Genesis Lowpoly es el motor lowpoly de Fire Tower Games. Recibe la descripción de algo (una cara, un vehículo, un edificio, un mundo entero) y devuelve su dibujo en SVG: planos poligonales de color plano, sin contorno, cada uno con su tono según la luz.

• Determinista. La misma entrada da siempre el mismo SVG, y una semilla da siempre la misma persona.
• Sin dependencias y sin DOM. Son funciones que devuelven texto. Corre igual en Node (22 o superior) y en el navegador.
• Todo en metros. Una persona mide 1,75 m y una celda de edificio, 4 m. La escala de dibujo la elige el juego.
• La luz es una hora. daylight(18.5) tiñe, alarga las sombras y enciende las ventanas de lo que dibuje.

Está pensado para estudios de juegos y apps que necesitan muchos personajes, vehículos, edificios y mundos coherentes entre sí, generados en tiempo de ejecución, sin un pipeline de arte ni IA.

Genesis Lowpoly is Fire Tower Games’ lowpoly engine. You describe something (a face, a vehicle, a building, a whole world) and it returns the drawing as SVG: flat-colored polygons with no outlines, each one shaded by the light.

• Deterministic. The same input always produces the same SVG, and a seed always produces the same person.
• No dependencies, no DOM. Every call is a function that returns a string. It runs the same in Node (22 or later) and in the browser.
• Everything in meters. A person is 1.75 m tall and a building cell is 4 m wide. Your game picks the drawing scale.
• Light is an hour of the day. daylight(18.5) tints whatever you draw, stretches its shadows and lights its windows.

It is built for game studios and apps that need large numbers of consistent characters, vehicles, buildings and worlds, generated at runtime, without an art pipeline or AI.

El paquete @firetower/genesis-lowpoly se entrega con licencia desde el registro npm del estudio, npm.firetower.games. No está publicado en el registro público de npm.

Al comprar, quien compra agrega a los desarrolladores de su plan. Cada uno entra a su cuenta de Genesis con su correo, con un enlace que le llega o con Google, y ahí encuentra su clave personal de npm y las dos líneas para su proyecto. La clave sirve mientras la licencia esté vigente. Los planes y sus precios están en Precios; los términos, en Licencia.

El paquete trae el motor completo como módulos ES y como script clásico (dist/genesis.js): los generadores, los kits y los paquetes de piezas que documenta esta guía.

The @firetower/genesis-lowpoly package is delivered under license from the studio’s npm registry, npm.firetower.games. It is not published on the public npm registry.

After buying, the buyer adds the developers of their plan. Each one signs in to their Genesis account with their email, through a link sent to them or with Google, and finds their personal npm token and the two lines for their project there. The token works while the license is active. Plans and prices are on Pricing; the terms, on License.

The package contains the whole engine as ES modules and as a classic script (dist/genesis.js): the generators, kits and piece packs described in these docs.

Crea un archivo .npmrc en la carpeta del proyecto con estas dos líneas; la clave la copias de tu cuenta de Genesis:

• @firetower:registry=https://npm.firetower.games/
• //npm.firetower.games/:_authToken=<tu clave>

Después instala como cualquier paquete: npm install @firetower/genesis-lowpoly. Para actualizar, npm update @firetower/genesis-lowpoly; lee antes «Versiones y cambios». No subas el .npmrc con tu clave a un repositorio público. Si tu entorno no puede usar npm, la cuenta también ofrece el archivo .tgz para npm install ./firetower-genesis-lowpoly-<versión>.tgz.

Cada generador devuelve un texto SVG. En Node se escribe a un archivo; en el navegador se pone en el DOM o en un <img> con una URL data:. El motor no tiene estado: no hay nada que inicializar.

Create a .npmrc file in the project folder with these two lines; copy the token from your Genesis account:

• @firetower:registry=https://npm.firetower.games/
• //npm.firetower.games/:_authToken=<your token>

Then install it like any package: npm install @firetower/genesis-lowpoly. To update, npm update @firetower/genesis-lowpoly; read “Versioning and changelog” first. Never commit the .npmrc holding your token to a public repository. If your environment cannot use npm, your account also offers the .tgz file for npm install ./firetower-genesis-lowpoly-<version>.tgz.

Every generator returns an SVG string. In Node you write it to a file; in the browser you put it in the DOM, or in an <img> through a data: URL. The engine holds no state, so there is nothing to initialize.

Genesis separa tres capas:

• Motor: capacidades y kits. Cómo se dibuja, la luz, cómo se pone una prenda, cómo se arma un vehículo, cómo envejece o se daña algo. No trae el aspecto de ningún juego y nunca importa un paquete.
• Paquetes (…/packs): piezas, planos y escenas hechos con los kits públicos, que sirven a más de un juego: ropa, edificios, mobiliario, especies, trofeos.
• Tu juego: lo que es solo tuyo (una librea, una prenda, un plano), hecho con los mismos kits que usan los paquetes: …/faces/kit, …/vehicles/kit, …/buildings/kit y vehicle({ model }).

Los colores de equipo, los textos y los logos entran siempre desde el juego: el motor no sabe de ninguno.

Genesis is split into three layers:

• Engine: capabilities and kits. How things are drawn and lit, how a garment is worn, how a vehicle is assembled, how things age or get damaged. It carries no game’s look and never imports a pack.
• Packs (…/packs): pieces, blueprints and scenes built with the public kits and shared by more than one game: clothing, buildings, furniture, species, trophies.
• Your game: whatever is yours alone (a livery, a garment, a blueprint), built with the same kits the packs use: …/faces/kit, …/vehicles/kit, …/buildings/kit and vehicle({ model }).

Team colors, text and logos always come from your game. The engine knows none of them.

Todo lo que tiene volumen se modela en metros, con los mismos ejes: x hacia adelante (el morro de un vehículo), y hacia la izquierda y z hacia arriba. El suelo es z = 0.

• Un modelo se coloca con at: [x, y] o at: [x, y, z] y se gira con turn, en grados sobre la vertical (0 mira hacia +x).
• Medidas de referencia: una persona, 1,75 m; una celda de edificio, CELL = 4 m; un piso, FLOOR = 3,2 m; un monoplaza, unos 5,6 m de largo.
• Como todo comparte la misma unidad, un auto, una casa y una persona salen a escala entre sí sin ajustar nada.

Everything with volume is modeled in meters on the same axes: x forward (a vehicle’s nose), y to the left and z up. The ground is z = 0.

• You place a model with at: [x, y] or at: [x, y, z] and turn it with turn, in degrees around the vertical axis (0 faces +x).
• Reference sizes: a person is 1.75 m; a building cell is CELL = 4 m; a floor is FLOOR = 3.2 m; a single-seater is about 5.6 m long.
• Because everything shares one unit, a car, a house and a person come out at the right scale next to each other with no tuning.

Los generadores en 3D proyectan su modelo con una cámara paralela. Las vistas tienen nombre:

Cada generador declara las suyas: VIEWN (vehículos), VIEWF (figuras), VIEWT (naturaleza) y VIEWC (criaturas) tienen side, three, top e iso; VIEWB (edificios) no tiene cenital; WORLD_VIEWS añade front. Una vista que el generador no conoce cae en su vista por defecto, sin error.

3D generators project their model through a parallel camera. Views are named:

Each generator lists its own: VIEWN (vehicles), VIEWF (figures), VIEWT (nature) and VIEWC (creatures) offer side, three, top and iso; VIEWB (buildings) has no top view; WORLD_VIEWS adds front. A view a generator does not know falls back to its default without an error.

Sin scale, un generador en 3D ajusta el dibujo a su marco: un vehículo llena 400 × 260, un edificio 400 × 300. Sirve para fichas y tarjetas, donde cada cosa se ve sola.

Con scale (píxeles por metro), cada cosa se dibuja a su tamaño real: el SVG declara su width y su height, apoya su base abajo y deja salir su sombra (overflow="visible"). Dos dibujos con la misma escala se pueden poner uno junto a otro y guardan su proporción.

Los rostros son 2D y no tienen escala: se encuadran con frame. world() siempre dibuja a escala (10 px/m si no se dice).

Without scale, a 3D generator fits the drawing to its frame: a vehicle fills 400 × 260, a building 400 × 300. Use it for cards and thumbnails, where each thing is shown on its own.

With scale (pixels per meter), each thing is drawn at its true size: the SVG states its width and height, rests its base on the bottom edge and lets its shadow spill out (overflow="visible"). Two drawings at the same scale can sit side by side and keep their proportions.

Faces are 2D and have no scale; you frame them with frame. world() always draws to scale (10 px/m by default).

La luz es un sistema aparte de todo generador. daylight(hora, opciones) devuelve la luz de una hora continua de 0 a 24 (18.5 son las seis y media de la tarde): de dónde viene el sol o la luna, el tinte, la oscuridad, la fuerza y el largo de las sombras, qué parte de las ventanas se enciende (lights), las estrellas y los colores del cielo.

• Se le pasa como light a cualquier generador en 3D y a world().
• De noche se encienden las ventanas de los edificios (lights, de 0 a 1, siempre las mismas), las farolas y su charco de luz en el suelo.
• Lo plano (un rostro, un dibujo propio) se tiñe con inLight(svg, luz).
• Opciones: sunrise y sunset (6 y 18 por defecto) y darkness, lo oscura que llega la noche (0,52 por defecto). MOMENTS trae seis horas con nombre, del amanecer a la noche.

Light is a system of its own, separate from every generator. daylight(hour, options) returns the light of a continuous hour from 0 to 24 (18.5 is half past six in the evening): where the sun or moon is, the tint and darkness, how strong and long shadows are, the share of windows lit (lights), the stars and the sky colors.

• Pass it as light to any 3D generator and to world().
• At night, building windows light up (lights, 0 to 1, always the same windows), and so do street lamps and the pool of light they cast.
• Flat drawings (a face, your own art) are tinted with inLight(svg, light).
• Options: sunrise and sunset (6 and 18 by default) and darkness, how dark the night gets (0.52 by default). MOMENTS names six hours, from dawn to night.

El motor no usa Math.random para dibujar. Todo lo que varía sale de una semilla entera a través de un generador pseudoaleatorio propio (rng(seed) del núcleo), así que la misma entrada da el mismo SVG cada vez. La suite de pruebas compara el hash de cada dibujo de referencia con el aprobado.

• random(seed, g) sortea una cara; seed en vehículos, árboles, rocas, criaturas e isotipos varía cada ejemplar sin cambiar su tipo.
• Por eso un juego puede guardar solo la semilla de un rival y volver a dibujarlo igual años después.
• La única excepción es del editor: randomize() sin semilla elige una al azar. ed.seed() dice cuál salió.

The engine never uses Math.random to draw. Everything that varies comes from an integer seed through the core’s own pseudo-random generator (rng(seed)), so the same input yields the same SVG every time. The test suite compares the hash of every reference drawing with the approved one.

• random(seed, g) rolls a face; seed on vehicles, trees, rocks, creatures and isotypes varies each instance without changing its kind.
• That means a game can store just a rival’s seed and draw it identically years later.
• The one exception is the editor: randomize() without a seed picks one at random, and ed.seed() tells you which.

Lo que un juego guarda es quién es algo, en un texto corto; lo del momento (la edad, la expresión, el desgaste, los patrocinios, la hora) se pasa al dibujar.

• Rostros: encode(spec) y decode(text), por ejemplo 1-f-4.3.1.1.0.1.2.1.0--5.1.-7.-5.
• Vehículos: encodeVehicle y decodeVehicle, con prefijo vehicle:. Edificios: encodeBuilding y decodeBuilding, con building:. Emblemas: EMBLEM.encode, con emblem:.
• Un texto roto se rechaza con un error que dice qué está mal: nunca se dibuja otra cosa.
• whose(text, [FACE, VEHICLE, BUILDING]) dice qué generador escribió un texto. Los rostros son el único texto sin prefijo.

What a game stores is who or what something is, as a short string. Anything of the moment (age, expression, wear, sponsors, the hour) is passed in when drawing.

• Faces: encode(spec) and decode(text), for example 1-f-4.3.1.1.0.1.2.1.0--5.1.-7.-5.
• Vehicles: encodeVehicle and decodeVehicle, prefixed vehicle:. Buildings: encodeBuilding and decodeBuilding, prefixed building:. Emblems: EMBLEM.encode, prefixed emblem:.
• A malformed string is rejected with an error that says what is wrong. It never draws something else.
• whose(text, [FACE, VEHICLE, BUILDING]) tells you which generator wrote a string. Faces are the only strings without a prefix.

Un dibujo guardado por un juego no debe cambiar cuando se actualiza el motor. Estas reglas lo sostienen:

• Los catálogos solo crecen por el final. Un texto guardado son posiciones (hair: 3), así que una pieza nueva se añade al final y las existentes no se reordenan ni se quitan. Vale para HAIR, PARTS, TYPES, BLOCKS, CYCLES, MATERIALS y los demás.
• Los ids nunca se renombran ni se quitan: prendas (ITEMS), piezas del mundo (PIECES), planos (BLUEPRINTS), trofeos, especies.
• random() es estable. Los rasgos nuevos (marcas en la piel, mentón, orejas, peso) no entran al sorteo, así que una semilla sigue dando la misma cara. La única vez que el sorteo cambió fue en la v0.6.0, y está en el registro de cambios.
• Los textos viejos se siguen leyendo. Un rasgo nuevo en su valor inicial no cambia el texto, y un vehículo guardado con menos piezas lee las que faltan como la primera.
• Todo cambio de dibujo pasa por una galería de referencia: las pruebas fallan si una cara de referencia sale distinta, y un cambio querido se revisa a ojo antes de aprobarse.

A drawing a game has saved should not change when the engine is updated. These rules make sure of it:

• Catalogs only grow at the end. A saved string holds positions (hair: 3), so new pieces are appended and existing ones are never reordered or removed. This applies to HAIR, PARTS, TYPES, BLOCKS, CYCLES, MATERIALS and the rest.
• Ids are never renamed or removed: garments (ITEMS), world pieces (PIECES), blueprints (BLUEPRINTS), trophies, species.
• random() is stable. New traits (skin marks, chin, ears, weight) are never rolled, so a seed keeps producing the same face. The roll changed only once, in v0.6.0, and the changelog records it.
• Old strings keep decoding. A new trait at its default does not change the string, and a vehicle saved with fewer parts reads the missing ones as the first option.
• Every drawing change goes through a reference gallery: the test suite fails if a reference face comes out different, and an intended change is reviewed by eye before it is approved.

• Cada generador devuelve un texto SVG completo (<svg xmlns=…>), o un objeto con .svg y datos para el juego (anclajes, contornos, tamaños). Nada toca el DOM.
• La animación va en el propio SVG, con SMIL (<animate>, <animateTransform>, <animateMotion>): ruedas que giran, ciclos de figuras, gestos de una cara. Sin JavaScript ni CSS del juego, así que también se anima dentro de un <img>. La única excepción es el parpadeo de una cara (blink: true), que deja los párpados en la clase .bl para el CSS del juego.
• XML estricto: ningún elemento repite un atributo, así que el SVG sirve igual en línea, como archivo o como URL data:. Una prueba pasa los acabados, tipos y vistas de los vehículos por un analizador estricto.
• Los SVG de los generadores llevan role="img" y un aria-label genérico en inglés («Generated face», «Generated world»…); los emblemas y las placas no llevan ninguno. Si la accesibilidad importa en tu pantalla, pon tu propia etiqueta alrededor.

• Every generator returns a complete SVG string (<svg xmlns=…>), or an object with .svg plus data for your game (anchors, outlines, sizes). Nothing touches the DOM.
• Animation lives inside the SVG, as SMIL (<animate>, <animateTransform>, <animateMotion>): spinning wheels, figure cycles, facial gestures. No JavaScript and no CSS from your game, so it animates inside an <img> too. The one exception is a face’s blink (blink: true), which tags the eyelids with the .bl class for your CSS.
• Strict XML: no element repeats an attribute, so the SVG works the same inline, as a file or as a data: URL. A test runs vehicle finishes, types and views through a strict parser.
• The generators’ SVGs carry role="img" and a generic English aria-label (“Generated face”, “Generated world”…); emblems and nameplates carry none. If accessibility matters on your screen, wrap it with your own label.

• Dibuja una vez y reutiliza. Como la salida es determinista, se puede guardar en caché por el texto guardado y los parámetros del momento. Dibujar cada cuadro de nuevo casi nunca hace falta.
• La animación pesa. Un ciclo de figura de 12 cuadros pesa entre 50 y 90 KB; con frames: 6, la mitad. Un equipo de mecánicos animado pesa unas cuatro veces más que quieto.
• Lo que camina, con recorrido. En world(), una figura con track (figureTrack()) dibuja cada pose una vez y el SVG la desliza: un caminante pasó de unos 600 KB en cuadros a 130 KB.
• Un mundo grande, en pila. world({ split: true }) devuelve stack, imágenes en el orden de pintado: la base quieta, tramos quietos y lo que se mueve aparte. Pon cada una en su propio <img> con will-change: transform, para que el navegador no vuelva a pintar la base debajo de lo que se mueve. En un mapa de ciudad medido en Chrome, la pila pasó de 6–7 fps a 144 con una capa por imagen.
• bounds fija el encuadre de un mundo para que la imagen no se mueva mientras las cosas se mueven.

• Draw once, reuse. Output is deterministic, so you can cache it by the saved string plus the parameters of the moment. Redrawing every frame is almost never needed.
• Animation has a cost. A 12-frame figure cycle weighs 50 to 90 KB; with frames: 6, half that. An animated pit crew weighs about four times its still version.
• Use tracks for walkers. In world(), a figure with a track (figureTrack()) draws each pose once and lets the SVG slide it: one walker went from about 600 KB as frames to 130 KB.
• Stack large worlds. world({ split: true }) returns stack, images in paint order: the still base, still runs, and whatever moves on its own. Put each in its own <img> with will-change: transform so the browser does not repaint the base under every moving thing. On a city map measured in Chrome, the stack went from 6–7 fps to 144 fps with one layer per image.
• bounds holds a world’s framing still while things move inside it.

face(opciones) dibuja un rostro. Lo que es la persona (rasgos, colores, forma) viene de random(seed, g), del editor o de decode(); lo demás lo pone el juego al dibujar.

• years: edad continua de 1 a 100 (30 si falta).
• expr: EXPR.REST, HAPPY, SPENT, FOCUSED, SURPRISED, ANGRY, SAD o CONFUSED. Con animate: true, el SVG reproduce el gesto.
• outfit: [primario, secundario]. Sin él, el cuerpo sale como un maniquí de planos lisos, listo para que el juego lo vista.
• frame: 'full' (300 × 400, por defecto), 'portrait', 'chest' (3:4), 'bust' o 'head' (cuadrados). El motor mide cada cara, así que un moño alto o una cabeza de niño tienen su propio encuadre.
• bg: un color, o 'none' para no tener fondo.

face(options) draws a face. Who the person is (traits, colors, shape) comes from random(seed, g), the editor or decode(); everything else is passed by your game at draw time.

• years: continuous age from 1 to 100 (30 when missing).
• expr: EXPR.REST, HAPPY, SPENT, FOCUSED, SURPRISED, ANGRY, SAD or CONFUSED. With animate: true, the SVG plays the gesture.
• outfit: [primary, secondary]. Without it, the body is a plain mannequin, ready for your game to dress.
• frame: 'full' (300 × 400, the default), 'portrait', 'chest' (3:4), 'bust' or 'head' (square). Each face is measured, so a tall bun or a child’s head gets its own framing.
• bg: a color, or 'none' for no background.

La misma persona va de 1 a 100 años: de niño la cabeza es grande y redonda sobre un cuerpo pequeño, y desde los 38 aparecen canas, arrugas y papada. La calvicie sale con la edad y es siempre la misma para la misma cara. gray y bald (0–1) mandan sobre lo que pone la edad.

• heir(padre, seed) da un heredero de 14 años que se le parece; la semilla decide cuál.
• Rasgos guardados con la cara, que random() nunca sortea: freckles, mole, scar, chin (CHIN), ears (EARS, también en punta), beast (BEASTS: cabezas de animal sobre la misma cara) y shape.weight (0–10).
• skin, iris y hairColor aceptan un índice del catálogo o cualquier '#rrggbb'.
• Opciones de dibujo para mundos de fantasía, que no se guardan: halo, shadow, eyeGlow, smoke y void.

The same person ages from 1 to 100: as a child the head is large and round on a small body, and from 38 on come gray hair, wrinkles and a double chin. Baldness arrives with age and is always the same for the same face. gray and bald (0–1) override what age decides.

• heir(parent, seed) returns a 14-year-old heir who resembles the parent; the seed picks which one.
• Traits stored with the face that random() never rolls: freckles, mole, scar, chin (CHIN), ears (EARS, pointed ones included), beast (BEASTS: animal heads over the same face) and shape.weight (0–10).
• skin, iris and hairColor take a catalog index or any '#rrggbb'.
• Drawing options for fantasy worlds, never stored: halo, shadow, eyeGlow, smoke and void.

Las prendas y objetos son piezas que se pasan en gear. Las de los paquetes se piden por id con wear(id, colores, { parts, decals, logo }); sin colores, cada pieza usa los suyos (ITEMS[id].colors).

• Ranuras (SLOTS): body, neck, head, eyes, hands, face y back. Se apilan en su orden, sin importar el orden en que se pasen.
• Cada pieza dice qué se le puede cambiar: roles (el nombre de cada color), parts (variantes numeradas) y zones (dónde va un patrón del juego, con decals). Las que tienen badge llevan el logo del equipo.
• Ningún casco ni sombrero deja ver el pelo. Paquetes de ropa: racing, sport, classic, work, traditional, care, fan y fantasy (PACKS).
• palette(spec) da { skin, hair, iris } de una cara, para dibujar a la misma persona de cuerpo entero.

Clothes and items are pieces passed in gear. Pack pieces are requested by id with wear(id, colors, { parts, decals, logo }); without colors, each piece uses its own (ITEMS[id].colors).

• Slots (SLOTS): body, neck, head, eyes, hands, face and back. Pieces stack in slot order, whatever order you pass them in.
• Each piece declares what can be customized: roles (a name for each color), parts (numbered variants) and zones (where your game’s pattern goes, through decals). Pieces with a badge carry the team logo.
• No helmet or hat ever shows the hair beneath. Clothing packs: racing, sport, classic, work, traditional, care, fan and fantasy (PACKS).
• palette(spec) returns a face’s { skin, hair, iris }, so you can draw the same person full-body.

Para que el jugador cree lo suyo, createEditor(generador, inicial) guarda el estado de un creador y sus reglas, sin pintar nada. No sabe qué edita: trabaja sobre el objeto que expone cada generador (FACE, VEHICLE, BUILDING o el que devuelve emblemMaker()). La pantalla, los textos y el orden son del juego.

ed.controls dice qué se puede cambiar. Cada control tiene key, type y group (body, color, features, marks, shape). Los tipos:

Un valor fuera de catálogo lanza RangeError: un creador nunca guarda una pieza que no existe. Lo que no es un control (los bloques de un edificio) cambia con acciones: ed.act(nombre, …).

To let players make their own, createEditor(generator, initial) holds a creator’s state and its rules, and draws nothing. It does not know what it edits: it works on the object each generator exposes (FACE, VEHICLE, BUILDING, or the one emblemMaker() returns). The screen, labels and order are your game’s.

ed.controls lists what can change. Each control has a key, a type and a group (body, color, features, marks, shape). The types:

An out-of-catalog value throws a RangeError, so a creator can never store a piece that does not exist. Whatever is not a control (a building’s blocks) changes through actions: ed.act(name, …).

Personas de cuerpo entero sobre un esqueleto en 3D. figure(opciones) da el SVG; figureModel(opciones) da sus caras en metros, para un mundo.

• cycle (CYCLES): movimientos que se repiten sin corte (walk, run, skate, swim, bike, dance…) y poses en su sitio (stand, sit, kneel, cheer, drive…).
• Quieta, phase (0–1) elige el momento del ciclo. Con animate: true, el SVG lo reproduce solo: frames (12 por defecto) en duration segundos (cada ciclo trae la suya, PERIOD).
• colors: los dos colores del juego, que cada ciclo viste a su modo. ...palette(spec) pone la piel y el pelo de una cara.
• style (STYLES): toon, el personaje de juego, robusto y legible de lejos (por defecto), o real.
• Vistas: side (por defecto), three, top e iso. Toma light, scale y bg: 'none'.

Full-body people on a 3D skeleton. figure(options) returns the SVG; figureModel(options) returns its faces in meters, for a world.

• cycle (CYCLES): seamless loops (walk, run, skate, swim, bike, dance…) and in-place poses (stand, sit, kneel, cheer, drive…).
• When still, phase (0–1) picks the moment in the cycle. With animate: true, the SVG plays it by itself: frames (12 by default) over duration seconds (each cycle has its own, PERIOD).
• colors: your game’s two colors, which each cycle dresses its own way. ...palette(spec) brings a face’s skin and hair.
• style (STYLES): toon, a sturdy game character that reads from afar (the default), or real.
• Views: side (the default), three, top and iso. Takes light, scale and bg: 'none'.

• role (ROLES) viste una figura por su oficio: casual, worker (chaleco reflectivo y casco), guard, mechanic (mono y gorra) y sport. wear: { top, legs, vest, stripes, hat, hatColor } escribe una ropa propia, sobre el rol o sin él.
• Poses de trabajo con lo que tienen en la mano (TOOLS): kneel, crouch, lean y hold; tool lo cambia o lo quita ('none').
• crew(caras, { count, colors, people, at, turn, animate }) pone 3 o 4 mecánicos alrededor de cualquier vehículo, cada uno en su trabajo, y devuelve objetos para world(). Con animate, la pistola golpea y la llave gira; el vehículo se dibuja una sola vez.
• pose(cycle, phase) da la pose como dato y figure({ pose }) dibuja una pose propia del juego.

• role (ROLES) dresses a figure for its job: casual, worker (hi-vis vest and hard hat), guard, mechanic (overalls and cap) and sport. wear: { top, legs, vest, stripes, hat, hatColor } writes custom clothing, over a role or without one.
• Work poses with something in hand (TOOLS): kneel, crouch, lean and hold; tool swaps or removes it ('none').
• crew(faces, { count, colors, people, at, turn, animate }) puts 3 or 4 mechanics around any vehicle, each at their task, and returns items for world(). With animate, the wheel gun hammers and the wrench turns; the vehicle is drawn only once.
• pose(cycle, phase) returns the pose as data, and figure({ pose }) draws a pose of your own.

El ciclo anima una figura en su sitio; moverla por el mundo es del juego, con dos herramientas:

• figureTrack(opciones, paradas, { cycle, frames }) arma el recorrido de una figura entre paradas [{ at, look, stay }], a su paso, de ida y vuelta. Va como track de un objeto de world(): cada pose se dibuja una vez y el SVG la desliza, sin que los pies resbalen.
• route(trazado, metros, cerrado) dice dónde está algo después de recorrer tantos metros de un trazado y hacia dónde mira: { at, turn }. Para ir al paso, phase = metros / STRIDE[cycle].

A cycle animates a figure in place; moving it through the world is up to your game, with two tools:

• figureTrack(options, stops, { cycle, frames }) builds a figure’s round between stops [{ at, look, stay }], at its own pace, there and back. It goes in as the track of a world() item: each pose is drawn once and the SVG slides it, so the feet never skate.
• route(path, meters, closed) tells you where something is after traveling that many meters along a path, and which way it faces: { at, turn }. To stay in step, use phase = meters / STRIDE[cycle].

vehicle(opciones) dibuja un vehículo lowpoly. Cada tipo es un solo modelo 3D en metros, así que una pieza nueva sale sola en todas las vistas.

• type (TYPES): 0 monoplaza, 1 Grand Prix de 1930, 2 kart, 3 auto, 4 camión.
• livery: [primario, secundario, acento], del juego.
• parts (PARTS[type]): formas numeradas por pieza, como { nose: 1, fwing: 2 }. La forma 0 es la de serie y las formas nunca cambian de orden, así que un juego puede guardarlas y venderlas por posición.
• model(opciones) da las caras en metros, para un mundo o para glb(). Vista por defecto: three.
• focus: 'fwing' gira el auto hasta donde se ve esa pieza, la resalta y apaga el resto, para una tienda o un editor; partView() da esa cámara.

vehicle(options) draws a lowpoly vehicle. Each type is a single 3D model in meters, so a new part shows up in every view on its own.

• type (TYPES): 0 single-seater, 1 1930s Grand Prix car, 2 kart, 3 car, 4 truck.
• livery: [primary, secondary, accent], from your game.
• parts (PARTS[type]): numbered shapes per part, such as { nose: 1, fwing: 2 }. Shape 0 is the stock one, and shapes never change order, so a game can store and sell them by position.
• model(options) returns the faces in meters, for a world or for glb(). Default view: three.
• focus: 'fwing' turns the car to where that part shows, highlights it and dims the rest, for a shop or an editor; partView() gives you that camera.

El motor no trae diseños de librea: pega los del juego.

• decals: figuras en el espacio normalizado del vehículo, sobre las partes que se digan (body, cover, pods…). on: 'side' y on: 'top' son planas (band, slant, dot ayudan a dibujarlas); on: 'space' (con slab) y on: 'dots' envuelven toda la carrocería sin cortes.
• paint: un color por pieza; PAINT[type] lista las pintables.
• marks: número y patrocinios en los espacios del tipo (MARK_SLOTS[type]), con texto en las letras del motor o con el logo del juego. El texto se achica, pasa a dos líneas y solo al final se corta; sin color, el motor elige una tinta legible.
• markFit(type, slot, text) dice antes de mostrarlo si cabe; sponsorMarks(type, patrocinadores) reparte una lista por niveles (rank 1 a 4) en los mejores espacios.

The engine ships no livery designs: it applies your game’s.

• decals: shapes in the vehicle’s normalized space, on the parts you name (body, cover, pods…). on: 'side' and on: 'top' are flat (band, slant and dot help draw them); on: 'space' (with slab) and on: 'dots' wrap the whole body without seams.
• paint: one color per part; PAINT[type] lists the paintable ones.
• marks: the number and sponsors in the type’s slots (MARK_SLOTS[type]), as text in the engine’s lettering or as your logo. Text shrinks, then wraps to two lines, and is cut only as a last resort; without a color, the engine picks a legible ink.
• markFit(type, slot, text) tells you beforehand whether it fits; sponsorMarks(type, sponsors) places a tiered list (rank 1 to 4) in the best slots.

• wear (0–1): la pintura se apaga, la suciedad sube desde el piso y aparecen rayones.
• damage (0–1 por pieza, DAMAGE[type]): un golpe hunde la pieza en facetas y la ennegrece; alerones, parabrisas y escapes se caen desde 2/3; el tren motriz pierde aceite y humea, y la electrónica echa chispas. Con la misma seed, el mismo daño.
• finish: carbon, matte, chrome o gold, en toda la librea o por pieza. El cromo y el oro reflejan el cielo y destellan solos (glints: false los deja quietos).
• speed (0–1) difumina los rayos; con animate: true las ruedas giran en el SVG, y trail: true pone líneas de velocidad.

• wear (0–1): the paint fades, grime rises from the floor and scratches appear.
• damage (0–1 per part, DAMAGE[type]): an impact dents the part into facets and blackens it; wings, windscreens and exhausts fall off from 2/3; the drivetrain leaks oil and smokes, and the electronics spark. The same seed gives the same damage.
• finish: carbon, matte, chrome or gold, for the whole livery or per part. Chrome and gold reflect the sky and glint by themselves (glints: false keeps them still).
• speed (0–1) blurs the spokes; with animate: true the wheels spin inside the SVG, and trail: true adds speed lines.

• component({ type, system, … }) dibuja un sistema solo y recortado a la pieza (SYSTEMS: aerodinámica, tren motriz, chasis, electrónica, motor), con la librea, las formas, el desgaste y el daño del auto. Se lee desde 64 px de alto.
• Los motores (ENGINES) son combinaciones de módulos: cilindros, bancadas, admisión, sobrealimentación y escape. Un juego puede pasar la suya, engine: { cylinders: 4, banks: 1 }, y pegarle su emblema (engineSlots()).
• Sonido: la misma ficha que dibuja un motor lo hace sonar. engineSound(motor, { context }) lo sintetiza en vivo en un AudioWorklet, sin grabaciones, en el contexto de audio que crea el juego; engineSample() da una muestra en .wav (también en Node), y raceSound() hace sonar una carrera entera desde las posiciones de los autos.

• component({ type, system, … }) draws one system on its own, cropped to the part (SYSTEMS: aero, drivetrain, chassis, electronics, engine), with the car’s livery, shapes, wear and damage. It reads from 64 px tall.
• Engines (ENGINES) are combinations of modules: cylinders, banks, intake, boost and exhaust. A game can pass its own, engine: { cylinders: 4, banks: 1 }, and stick its emblem on it (engineSlots()).
• Sound: the same spec that draws an engine makes it sound. engineSound(engine, { context }) synthesizes it live in an AudioWorklet, with no recordings, on the audio context your game creates; engineSample() returns a .wav sample (in Node too), and raceSound() voices a whole race from the cars’ positions.

El juego construye: pone bloques en una rejilla, celda por celda y piso por piso, y building() hace con ellos un edificio, con el mismo kit 3D, la luz y la sombra que los vehículos.

• Cada bloque es { x, y, f, kind }: x al este, y al norte, f el piso (0, la planta baja). Una celda mide CELL × CELL (4 m) y un piso FLOOR (3,2 m).
• kind (BLOCKS): room, glass, garage, solid, stand (tribuna) y cab (cabina de torre). win (WINDOWS) elige la ventana y door: 'S' | 'E' | 'N' | 'W' pone la puerta.
• roof (ROOFS): plano, a dos aguas o en dientes de sierra, para todo el edificio o por bloque. style: los colores de muros, marcos, vidrio, techo y puertas.
• signs: letreros en un muro o sobre el techo, con texto o logo; signFit() dice si caben. progress (0–1) dibuja el edificio en obra.
• Vistas: side, three e iso (por defecto).

Your game builds: it places blocks on a grid, cell by cell and floor by floor, and building() turns them into a building, with the same 3D kit, light and shadow as vehicles.

• Each block is { x, y, f, kind }: x east, y north, f the floor (0 is the ground floor). A cell is CELL × CELL (4 m) and a floor is FLOOR (3.2 m).
• kind (BLOCKS): room, glass, garage, solid, stand (grandstand) and cab (control tower cab). win (WINDOWS) picks the window and door: 'S' | 'E' | 'N' | 'W' places the door.
• roof (ROOFS): flat, gabled or sawtooth, for the whole building or per block. style: colors for walls, trim, glass, roof and doors.
• signs: signs on a wall or on the roof, with text or a logo; signFit() tells you whether they fit. progress (0–1) draws the building under construction.
• Views: side, three and iso (the default).

Un plano es un edificio del que el juego parte: sus bloques, su techo y su estilo, y si puede crecer, cuántas celdas de ancho. plan(id, { width, style, roof, view, … }) devuelve lo que toma building(), con el estilo del juego encima del del plano.

• Catálogo (BLUEPRINTS, por familia en CATALOG): de carreras (pit-garages, race-control, grandstand, team-hq), de ciudad (house, shop, apartments, workshop), deportivos (bleachers, sports-hall, pavilion) y del estudio (fire-tower, studio-hq, arcade).
• Planos propios con el kit (…/buildings/kit): blueprint(id, nombre, { width, roof, style, plan }) y blocksIn() para llenar una caja de celdas.
• Para guardar: encodeBuilding y decodeBuilding. Para editar, createEditor(BUILDING) con sus acciones: place, remove, door y use.

A blueprint is a building your game starts from: its blocks, roof and style, and, if it can grow, how many cells wide. plan(id, { width, style, roof, view, … }) returns what building() takes, with your style laid over the blueprint’s.

• Catalog (BLUEPRINTS, by family in CATALOG): racing (pit-garages, race-control, grandstand, team-hq), city (house, shop, apartments, workshop), sport (bleachers, sports-hall, pavilion) and studio (fire-tower, studio-hq, arcade).
• Your own blueprints with the kit (…/buildings/kit): blueprint(id, name, { width, roof, style, plan }), and blocksIn() to fill a box of cells.
• To save: encodeBuilding and decodeBuilding. To edit, createEditor(BUILDING) with its actions: place, remove, door and use.

Lo que crece y lo que está tirado en el suelo, en metros. tree() da un SVG; las funciones …Model dan caras para un mundo.

• Árboles (TREES): pine, leafy, poplar, palm y bush, con height, leaves y bark del juego. Cada semilla, otro árbol.
• hedgeModel(trazado, { height }): un seto a lo largo de un trazado. rockModel({ size, seed }): una roca.
• grassModel(): una mata de pasto. meadowModel(contorno, { density, flowers }): una pradera con flores.
• Proyectan su sombra y se iluminan con la hora. Vista por defecto: iso.

Things that grow and things lying on the ground, in meters. tree() returns an SVG; the …Model functions return faces for a world.

• Trees (TREES): pine, leafy, poplar, palm and bush, with your height, leaves and bark. Each seed gives another tree.
• hedgeModel(path, { height }): a hedge along a path. rockModel({ size, seed }): a rock.
• grassModel(): a tuft of grass. meadowModel(outline, { density, flowers }): a meadow with flowers.
• They cast shadows and take the hour’s light. Default view: iso.

Animales y bestias hechos por un creador, no uno por uno. Una criatura es una forma de cuerpo (PLANS: quad, biped, slug), sus proporciones y sus piezas (trompa, colmillos, cuernos, alas, crin, púas, placas, silla de montar…). Todo es dato: el motor no conoce ningún animal.

• height va en metros, a la cruz; lo demás, en alturas a la cruz, así una especie conserva su forma a cualquier tamaño.
• Las especies vienen en el paquete bestiary: species(id, opciones) da la ficha con lo del juego encima (mammoth, dragon, wolf, bear, bison, dog, horse, brute, snail, slug, mastiff, upright-bear, grub).
• style: toon o real. seed varía cada ejemplar dentro de su especie. creatureModel(spec) da sus caras para un mundo.

Animals and beasts made by a creator, not one by one. A creature is a body plan (PLANS: quad, biped, slug), its proportions and its parts (trunk, tusks, horns, wings, mane, spikes, plates, a saddle…). It is all data: the engine knows no animal.

• height is in meters, at the withers; everything else is in multiples of that height, so a species keeps its shape at any size.
• Species come in the bestiary pack: species(id, options) returns the spec with yours laid over it (mammoth, dragon, wolf, bear, bison, dog, horse, brute, snail, slug, mastiff, upright-bear, grub).
• style: toon or real. seed varies each individual within its species. creatureModel(spec) returns its faces for a world.