@ludra/core 0.4.0 → 0.7.0

package/dist/ascii.js

@@ -39,8 +39,8 @@ export function renderAscii(world, options = {}) {
         ["G", (e) => !!e.goal],
         ["^", (e) => !!e.hazard && e.body.type !== "kinematic"],
         ["E", (e) => !!e.hazard && e.body.type === "kinematic"],
-        ["D", (e) => e.body.type === "dynamic" && !e.platformer],
-        ["@", (e) => !!e.platformer],
+        ["D", (e) => e.body.type === "dynamic" && !e.platformer && !e.topdown],
+        ["@", (e) => !!(e.platformer || e.topdown)],
     ];
     for (const [char, test] of passes) {
         for (const e of withBody.filter(test))

package/dist/assertions.d.ts

@@ -1,5 +1,5 @@
-import { type GameEventType, type SceneDef } from "./types.ts";
-import { type GameEvent, type WorldSnapshot } from "./world.ts";
+import { type SceneDef } from "./types.ts";
+import { type GameEvent, type WorldOptions, type WorldSnapshot } from "./world.ts";
 declare const OPERATORS: readonly ["<=", ">=", "==", "!=", "<", ">"];
 type Operator = (typeof OPERATORS)[number];
 declare const ENTITY_FIELDS: readonly ["x", "y", "vx", "vy", "grounded", "exists"];
@@ -9,19 +9,27 @@ type WorldField = (typeof WORLD_FIELDS)[number];
 type Subject = {
     kind: "world";
     field: WorldField;
-} | {
+}
+/** Built-in event types, or custom events fired by scripts with world.emit(name). */
+ | {
     kind: "events";
-    type: GameEventType;
+    name: string;
+    builtin: boolean;
 } | {
     kind: "entity";
     id: string;
     field: EntityField;
+} | {
+    kind: "state";
+    id: string;
+    key: string;
 };
+type Value = number | boolean | string;
 export interface Assertion {
     source: string;
     subject: Subject;
     operator: Operator;
-    expected: number | boolean;
+    expected: Value;
     /** Frame to check at, or "end" for the last frame of the run. */
     at: number | "end";
 }
@@ -32,7 +40,7 @@ export declare function parseAssertion(source: string): Assertion;
 export interface AssertionResult {
     source: string;
     pass: boolean;
-    actual: number | boolean | undefined;
+    actual: unknown;
     time: number;
     message: string;
 }
@@ -53,5 +61,5 @@ export interface TestResult {
     results: AssertionResult[];
     error?: string;
 }
-export declare function runTest(scene: SceneDef, test: TestCase): TestResult;
+export declare function runTest(scene: SceneDef, test: TestCase, options?: WorldOptions): TestResult;
 export {};

package/dist/assertions.js

@@ -8,7 +8,7 @@ const ENTITY_FIELDS = ["x", "y", "vx", "vy", "grounded", "exists"];
 const WORLD_FIELDS = ["score", "deaths", "won"];
 export class AssertionSyntaxError extends Error {
 }
-const EXAMPLES = 'Examples: "player.x > 400", "player.grounded == true at 1s", "score >= 3", "won == true", "deaths == 0", "events.jump == 1 at end", "coin1.exists == false".';
+const EXAMPLES = 'Examples: "player.x > 400", "player.grounded == true at 1s", "score >= 3", "won == true", "deaths == 0", "events.jump == 1 at end", "coin1.exists == false", "door.state.open == true", "boss.state.phase == \\"angry\\"", "events.shoot >= 3".';
 /** Parses `<subject> <op> <value> [at <time|end>]`. */
 export function parseAssertion(source) {
     const match = /^\s*([\w.-]+)\s*(<=|>=|==|!=|<|>)\s*(\S+?)(?:\s+at\s+(\S+))?\s*$/.exec(source);
@@ -16,31 +16,35 @@ export function parseAssertion(source) {
         throw new AssertionSyntaxError(`Cannot parse assertion "${source}". ${EXAMPLES}`);
     const [, lhs = "", operator, rhs = "", at] = match;
     let subject;
+    const stateMatch = /^(.+)\.state\.([\w-]+)$/.exec(lhs);
     if (WORLD_FIELDS.includes(lhs)) {
         subject = { kind: "world", field: lhs };
     }
-    else if (lhs.startsWith("events.")) {
-        const type = lhs.slice("events.".length);
-        if (!EVENT_TYPES.includes(type)) {
-            throw new AssertionSyntaxError(`Unknown event "${type}" in "${source}". Events: ${EVENT_TYPES.join(", ")}.`);
-        }
-        subject = { kind: "events", type: type };
+    else if (lhs.startsWith("events.") && lhs.length > "events.".length) {
+        const name = lhs.slice("events.".length);
+        subject = { kind: "events", name, builtin: EVENT_TYPES.includes(name) };
+    }
+    else if (stateMatch) {
+        subject = { kind: "state", id: stateMatch[1], key: stateMatch[2] };
     }
     else {
         const dot = lhs.lastIndexOf(".");
         const field = lhs.slice(dot + 1);
         if (dot <= 0 || !ENTITY_FIELDS.includes(field)) {
-            throw new AssertionSyntaxError(`"${lhs}" is not something Ludra can check. Use ${WORLD_FIELDS.join(", ")}, events.<${EVENT_TYPES.join("|")}> or <entityId>.<${ENTITY_FIELDS.join("|")}>.`);
+            throw new AssertionSyntaxError(`"${lhs}" is not something Ludra can check. Use ${WORLD_FIELDS.join(", ")}, events.<name>, <entityId>.<${ENTITY_FIELDS.join("|")}> or <entityId>.state.<key>.`);
         }
         subject = { kind: "entity", id: lhs.slice(0, dot), field: field };
     }
     let expected;
     if (rhs === "true" || rhs === "false")
         expected = rhs === "true";
+    else if (/^".*"$/.test(rhs))
+        expected = rhs.slice(1, -1);
     else if (Number.isFinite(Number(rhs)))
         expected = Number(rhs);
-    else
-        throw new AssertionSyntaxError(`Expected a number or true/false after "${operator}" in "${source}", got "${rhs}".`);
+    else {
+        throw new AssertionSyntaxError(`Expected a number, true/false or a "quoted string" after "${operator}" in "${source}", got ${rhs}.`);
+    }
     let frame = "end";
     if (at !== undefined && at !== "end") {
         try {
@@ -62,10 +66,30 @@ export function evaluateAssertion(assertion, snapshot, events) {
             actual = snapshot[subject.field];
             label = subject.field;
             break;
-        case "events":
-            actual = events.filter((e) => e.type === subject.type && e.frame <= snapshot.frame).length;
-            label = `events.${subject.type}`;
+        case "events": {
+            const matches = (e) => (subject.builtin ? e.type === subject.name : e.type === "custom" && e.name === subject.name);
+            actual = events.filter((e) => matches(e) && e.frame <= snapshot.frame).length;
+            label = `events.${subject.name}`;
+            break;
+        }
+        case "state": {
+            const entity = snapshot.entities[subject.id];
+            label = `${subject.id}.state.${subject.key}`;
+            if (!entity) {
+                return { source, pass: false, actual: undefined, time, message: `entity "${subject.id}" does not exist at ${time.toFixed(2)}s.` };
+            }
+            actual = entity.state?.[subject.key];
+            if (actual === undefined) {
+                return {
+                    source,
+                    pass: false,
+                    actual,
+                    time,
+                    message: `${label} is not set at ${time.toFixed(2)}s. Scripts set it with self.state.${subject.key} = ...`,
+                };
+            }
             break;
+        }
         case "entity": {
             const entity = snapshot.entities[subject.id];
             label = `${subject.id}.${subject.field}`;
@@ -85,13 +109,19 @@ export function evaluateAssertion(assertion, snapshot, events) {
         }
     }
     if (typeof actual !== typeof expected) {
-        return { source, pass: false, actual, time, message: `${label} is a ${typeof actual}, but it is compared with ${JSON.stringify(expected)}.` };
+        return {
+            source,
+            pass: false,
+            actual,
+            time,
+            message: `${label} is ${JSON.stringify(actual)} (a ${typeof actual}), but it is compared with ${JSON.stringify(expected)}.`,
+        };
     }
-    if (typeof actual === "boolean" && operator !== "==" && operator !== "!=") {
-        return { source, pass: false, actual, time, message: `${label} is true/false, so only == and != can be used.` };
+    if (typeof actual !== "number" && operator !== "==" && operator !== "!=") {
+        return { source, pass: false, actual, time, message: `${label} is a ${typeof actual}, so only == and != can be used.` };
     }
     const pass = compare(actual, operator, expected);
-    const shown = typeof actual === "number" ? round(actual) : actual;
+    const shown = typeof actual === "number" ? round(actual) : JSON.stringify(actual);
     return { source, pass, actual, time, message: `${label} = ${shown} at ${time.toFixed(2)}s` };
 }
 function compare(a, operator, b) {
@@ -113,7 +143,7 @@ function compare(a, operator, b) {
 function round(n) {
     return Math.round(n * 100) / 100;
 }
-export function runTest(scene, test) {
+export function runTest(scene, test, options = {}) {
     let script;
     let assertions;
     let frames;
@@ -134,11 +164,18 @@ export function runTest(scene, test) {
     }
     const wanted = new Set(assertions.map((a) => (a.at === "end" ? frames : Math.min(a.at, frames))));
     const snapshots = new Map();
-    const world = new World(scene);
-    simulate(world, script, frames, (w) => {
-        if (wanted.has(w.frame))
-            snapshots.set(w.frame, w.snapshot());
-    });
+    let world;
+    try {
+        world = new World(scene, options);
+        simulate(world, script, frames, (w) => {
+            if (wanted.has(w.frame))
+                snapshots.set(w.frame, w.snapshot());
+        });
+    }
+    catch (err) {
+        // A throwing script fails this test, not the whole run.
+        return { name: test.name, pass: false, duration: frames * FIXED_DT, results: [], error: err.message };
+    }
     const results = assertions.map((a) => {
         const frame = a.at === "end" ? frames : Math.min(a.at, frames);
         return evaluateAssertion(a, snapshots.get(frame), world.events);

package/dist/browser.d.ts

@@ -2,6 +2,10 @@ import type { SceneDef } from "./types.ts";
 export interface GameOptions {
     /** URL prefix for image and audio paths in the scene. Defaults to "". */
     assetBase?: string;
+    /** URL prefix the scene's script paths are imported from. Defaults to `assetBase`. */
+    scriptBase?: string;
+    /** Scripts to load. Defaults to those the scene references; include any that `world.spawn` uses. */
+    scriptPaths?: readonly string[];
 }
 /**
  * Runs a scene in a canvas with keyboard controls, images, particles and

package/dist/browser.js

@@ -1,8 +1,17 @@
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
 import { SoundPlayer } from "./audio.js";
 import { parseFrames } from "./components.js";
 import { collectAssetPaths } from "./effects.js";
 import { InputScript } from "./input.js";
 import { ParticleSystem } from "./particles.js";
+import { PostFx } from "./postfx.js";
 import { FIXED_DT } from "./time.js";
 import { World } from "./world.js";
 const KEYMAP = {
@@ -23,6 +32,89 @@ const KEYMAP = {
 const MAX_FRAME_TIME = 0.25;
 /** Screen shake decays by this factor every step. */
 const SHAKE_DECAY = 0.88;
+/** Imports the game's script modules, keyed by their path in the scene. */
+async function loadScripts(scene, options) {
+    const base = options.scriptBase ?? options.assetBase ?? "";
+    const paths = options.scriptPaths ?? collectAssetPaths(scene).filter((ref) => ref.kind === "script").map((ref) => ref.path);
+    const scripts = new Map();
+    await Promise.all([...new Set(paths)].map(async (path) => {
+        const module = (await import(__rewriteRelativeImportExtension(base + path)));
+        if (!module.default)
+            throw new Error(`Script ${path} has no default export.`);
+        scripts.set(path, module.default);
+    }));
+    return scripts;
+}
+/** Fonts load from Google Fonts or project files; a slow or offline font never blocks the game for long. */
+async function loadFonts(scene, assetBase) {
+    const fonts = Object.entries(scene.fonts ?? {});
+    if (fonts.length === 0)
+        return;
+    const load = async ([family, src]) => {
+        if (src === "google") {
+            const name = encodeURIComponent(family).replace(/%20/g, "+");
+            // Not every family has every weight, and Google rejects the request if one is missing.
+            for (const weights of [":wght@400;500;600;700;800;900", ":wght@400;700", ""]) {
+                const response = await fetch(`https://fonts.googleapis.com/css2?family=${name}${weights}&display=block`);
+                if (!response.ok)
+                    continue;
+                const style = document.createElement("style");
+                style.textContent = await response.text();
+                document.head.append(style);
+                break;
+            }
+            await Promise.all(["400", "700", "900"].map((weight) => document.fonts.load(`${weight} 16px "${family}"`)));
+        }
+        else {
+            const face = new FontFace(family, `url("${assetBase}${src}")`);
+            // FontFaceSet.add is missing from some TypeScript DOM typings.
+            document.fonts.add(await face.load());
+        }
+    };
+    const all = Promise.all(fonts.map((font) => load(font).catch((err) => console.warn(`[ludra] could not load font "${font[0]}": ${err}`))));
+    await Promise.race([all, new Promise((resolve) => setTimeout(resolve, 4000))]);
+}
+/**
+ * Loads everything a scene needs and sets up its canvases. With `postfx`, `canvas`
+ * becomes the offscreen source and a WebGL canvas takes its place in the page.
+ */
+async function prepare(canvas, scene, options) {
+    const ctx = canvas.getContext("2d");
+    if (!ctx)
+        throw new Error("Canvas 2D context is not available.");
+    const assetBase = options.assetBase ?? "";
+    const shaderPath = scene.postfx?.shader;
+    const [images, scripts, shader] = await Promise.all([
+        loadImages(scene, assetBase),
+        loadScripts(scene, options),
+        shaderPath
+            ? fetch(assetBase + shaderPath).then(async (r) => (r.ok ? r.text() : new Error(`could not load ${shaderPath} (${r.status})`)))
+            : undefined,
+        loadFonts(scene, assetBase),
+    ]);
+    const stage = { ctx, output: canvas, images, scripts, present: () => { } };
+    if (scene.postfx && shader !== undefined) {
+        try {
+            if (shader instanceof Error)
+                throw shader;
+            const fx = new PostFx(canvas.width, canvas.height, shader, scene.postfx);
+            fx.canvas.id = canvas.id;
+            fx.canvas.className = canvas.className;
+            fx.canvas.style.cssText = canvas.style.cssText;
+            canvas.replaceWith(fx.canvas);
+            stage.output = fx.canvas;
+            stage.present = (time) => fx.render(canvas, time);
+        }
+        catch (err) {
+            stage.error = `postfx: ${message(err)}`;
+            console.error("[ludra]", err);
+        }
+    }
+    return stage;
+}
+function message(err) {
+    return err instanceof Error ? err.message : String(err);
+}
 /**
  * Runs a scene in a canvas with keyboard controls, images, particles and
  * sound. The simulation uses the same fixed step as headless runs, so what
@@ -30,17 +122,15 @@ const SHAKE_DECAY = 0.88;
  * Resolves (after images load) to a function that stops the game.
  */
 export async function startGame(canvas, scene, options = {}) {
-    const ctx = canvas.getContext("2d");
-    if (!ctx)
-        throw new Error("Canvas 2D context is not available.");
-    const assetBase = options.assetBase ?? "";
-    const images = await loadImages(scene, assetBase);
-    const sounds = new SoundPlayer(assetBase);
+    const { ctx, images, scripts, present, error } = await prepare(canvas, scene, options);
+    const sounds = new SoundPlayer(options.assetBase ?? "");
     const view = new View(scene, images);
-    let world = new World(scene);
+    let world = new World(scene, { scripts });
+    let crash = error;
     const restart = () => {
-        world = new World(scene);
+        world = new World(scene, { scripts });
         view.reset();
+        crash = error;
     };
     const held = new Set();
     // Keys pressed since the last step. A tap shorter than one frame still reaches the simulation.
@@ -76,13 +166,31 @@ export async function startGame(canvas, scene, options = {}) {
     const frame = (now) => {
         accumulator += Math.min(MAX_FRAME_TIME, (now - last) / 1000);
         last = now;
-        while (accumulator >= FIXED_DT) {
-            world.step(tapped.size > 0 ? new Set([...held, ...tapped]) : held);
+        while (accumulator >= FIXED_DT && !crash) {
+            try {
+                world.step(tapped.size > 0 ? new Set([...held, ...tapped]) : held);
+            }
+            catch (err) {
+                // A script threw: freeze the game and show why, instead of failing silently.
+                crash = message(err);
+                console.error("[ludra]", err);
+            }
             tapped.clear();
             view.step(world, (sound) => sounds.play(sound));
             accumulator -= FIXED_DT;
         }
-        view.draw(ctx, world, sounds.muted);
+        try {
+            view.draw(ctx, world, sounds.muted);
+        }
+        catch (err) {
+            // A draw hook threw. Same treatment as a simulation error.
+            if (!crash)
+                console.error("[ludra]", err);
+            crash ??= message(err);
+        }
+        if (crash)
+            drawCrash(ctx, crash);
+        present(world.time);
         raf = requestAnimationFrame(frame);
     };
     raf = requestAnimationFrame(frame);
@@ -100,12 +208,11 @@ export async function startGame(canvas, scene, options = {}) {
  * `ludra play --screenshot`.
  */
 export async function captureFrames(canvas, scene, options) {
-    const ctx = canvas.getContext("2d");
-    if (!ctx)
-        throw new Error("Canvas 2D context is not available.");
-    const images = await loadImages(scene, options.assetBase ?? "");
+    const { ctx, output, images, scripts, present, error } = await prepare(canvas, scene, options);
+    if (error)
+        throw new Error(error);
     const view = new View(scene, images);
-    const world = new World(scene);
+    const world = new World(scene, { scripts });
     const script = InputScript.parse(options.inputs ?? "");
     const wanted = new Set(options.frames);
     const last = Math.max(0, ...options.frames);
@@ -113,7 +220,8 @@ export async function captureFrames(canvas, scene, options) {
     for (let frame = 0;; frame++) {
         if (wanted.has(frame)) {
             view.draw(ctx, world, false);
-            captured.push({ frame, time: frame * FIXED_DT, png: canvas.toDataURL("image/png") });
+            present(world.time);
+            captured.push({ frame, time: frame * FIXED_DT, png: output.toDataURL("image/png") });
         }
         if (frame >= last)
             break;
@@ -122,6 +230,30 @@ export async function captureFrames(canvas, scene, options) {
     }
     return captured;
 }
+function drawCrash(ctx, message) {
+    const { width, height } = ctx.canvas;
+    ctx.fillStyle = "rgba(20, 0, 8, 0.85)";
+    ctx.fillRect(0, 0, width, height);
+    ctx.fillStyle = "#ff9b9b";
+    ctx.textAlign = "left";
+    ctx.font = "700 22px system-ui, sans-serif";
+    ctx.fillText("Script error", 32, 56);
+    ctx.font = "15px ui-monospace, monospace";
+    // Wrap the message to the canvas width.
+    let line = "";
+    let y = 92;
+    for (const word of message.split(" ")) {
+        if (ctx.measureText(line + word).width > width - 64) {
+            ctx.fillText(line, 32, y);
+            line = "";
+            y += 22;
+        }
+        line += `${word} `;
+    }
+    ctx.fillText(line, 32, y);
+    ctx.fillStyle = "rgba(255, 255, 255, 0.6)";
+    ctx.fillText("Fix the script; the page reloads on save. R restarts.", 32, y + 40);
+}
 async function loadImages(scene, assetBase) {
     const images = new Map();
     const paths = new Set(collectAssetPaths(scene).filter((ref) => ref.kind === "image").map((ref) => ref.path));
@@ -145,6 +277,8 @@ class View {
     facing = new Map();
     emitTimers = new Map();
     frameCache = new Map();
+    /** ctx.local for each entity's draw hooks. */
+    local = new Map();
     shake = 0;
     handledEvents = 0;
     scene;
@@ -157,13 +291,14 @@ class View {
         this.particles.clear();
         this.facing.clear();
         this.emitTimers.clear();
+        this.local.clear();
         this.shake = 0;
         this.handledEvents = 0;
     }
     /** Runs once per simulation step: turns new events into effects and advances particles. */
     step(world, playSound) {
         for (const event of world.events.slice(this.handledEvents)) {
-            const effect = this.scene.effects?.[event.type];
+            const effect = this.scene.effects?.[event.type === "custom" ? event.name : event.type];
             if (!effect)
                 continue;
             if (effect.particles)
@@ -195,7 +330,7 @@ class View {
         ctx.imageSmoothingEnabled = false;
         ctx.fillStyle = world.background;
         ctx.fillRect(0, 0, viewWidth, viewHeight);
-        const target = world.entities.find((e) => e.camera) ?? world.entities.find((e) => e.platformer);
+        const target = world.entities.find((e) => e.camera) ?? world.entities.find((e) => e.platformer || e.topdown);
         const zoom = target?.camera?.zoom ?? 1;
         const visibleWidth = viewWidth / zoom;
         const visibleHeight = viewHeight / zoom;
@@ -205,14 +340,27 @@ class View {
             cameraX += (this.particles.random() - 0.5) * 2 * this.shake;
             cameraY += (this.particles.random() - 0.5) * 2 * this.shake;
         }
+        const viewInfo = { width: viewWidth, height: viewHeight, cameraX, cameraY, zoom };
         ctx.save();
         ctx.scale(zoom, zoom);
         ctx.translate(-cameraX, -cameraY);
-        const visible = world.entities.filter((e) => e.sprite).sort((a, b) => a.sprite.layer - b.sprite.layer);
-        for (const e of visible)
-            this.drawSprite(ctx, e, world.time);
+        const layer = (e) => e.sprite?.layer ?? 0;
+        const visible = world.entities.filter((e) => e.sprite || e.script?.module.draw).sort((a, b) => layer(a) - layer(b));
+        for (const e of visible) {
+            if (e.sprite)
+                this.drawSprite(ctx, e, world.time);
+            if (e.script?.module.draw)
+                this.drawHook(ctx, world, e, "draw", viewInfo);
+        }
         this.particles.draw(ctx);
         ctx.restore();
+        if (world.hasHook("drawUI")) {
+            // The game draws its own interface.
+            for (const e of [...world.entities])
+                if (e.script?.module.drawUI)
+                    this.drawHook(ctx, world, e, "drawUI", viewInfo);
+            return;
+        }
         ctx.textAlign = "left";
         ctx.font = "600 18px system-ui, sans-serif";
         ctx.fillStyle = "#ffffff";
@@ -233,6 +381,31 @@ class View {
             ctx.fillText(`Score ${world.score} · ${winTime.toFixed(1)}s · Press R to play again`, viewWidth / 2, viewHeight / 2 + 30);
         }
     }
+    drawHook(ctx, world, e, hook, view) {
+        let local = this.local.get(e.id);
+        if (!local)
+            this.local.set(e.id, (local = {}));
+        ctx.save();
+        try {
+            world.callDrawHook(e, hook, {
+                g: ctx,
+                time: world.time,
+                local,
+                view,
+                recent: (name, seconds = 0.5) => recentEvents(world, name, seconds),
+                image: (path) => this.images.get(path),
+                burst: (x, y, particles = {}) => this.particles.burst(x, y, particles),
+                shake: (amount) => {
+                    this.shake = Math.max(this.shake, amount);
+                },
+                random: () => this.particles.random(),
+            });
+        }
+        finally {
+            // Whatever the hook changed (transform, alpha, blend mode, filter) ends with it.
+            ctx.restore();
+        }
+    }
     drawSprite(ctx, e, time) {
         const sprite = e.sprite;
         const width = sprite.width || e.body?.width || 16;
@@ -300,6 +473,21 @@ class View {
         return [0];
     }
 }
+function recentEvents(world, name, seconds) {
+    const since = world.time - seconds;
+    const result = [];
+    // Events are in time order, so walk back until they get too old.
+    for (let i = world.events.length - 1; i >= 0; i--) {
+        const event = world.events[i];
+        if (event.time < since)
+            break;
+        const eventName = event.type === "custom" ? event.name : event.type;
+        if (name !== undefined && eventName !== name)
+            continue;
+        result.push({ name: eventName, time: event.time, x: event.x, y: event.y, entity: event.entity, data: event.type === "custom" ? event.data : undefined });
+    }
+    return result.reverse();
+}
 function animationState(e) {
     const b = e.body;
     if (!b)

package/dist/components.d.ts

@@ -22,6 +22,12 @@ export type FieldSpec = {
     type: "frames";
     default?: string;
     description: string;
+}
+/** Any JSON object. */
+ | {
+    type: "object";
+    default?: Record<string, unknown>;
+    description: string;
 };
 export interface ComponentSpec {
     description: string;
@@ -29,7 +35,7 @@ export interface ComponentSpec {
     /** Fields without a default are required. */
     fields: Record<string, FieldSpec>;
 }
-export declare const COMPONENT_NAMES: readonly ["transform", "body", "sprite", "platformer", "collectible", "patrol", "hazard", "goal", "emitter", "camera"];
+export declare const COMPONENT_NAMES: readonly ["transform", "body", "sprite", "platformer", "topdown", "collectible", "patrol", "hazard", "goal", "emitter", "script", "camera"];
 export type ComponentName = (typeof COMPONENT_NAMES)[number];
 /** Shared by the `emitter` component and the particles of scene `effects`. Purely visual. */
 export declare const PARTICLE_FIELDS: Record<string, FieldSpec>;
@@ -49,6 +55,7 @@ export interface Body {
     height: number;
     sensor: boolean;
     gravityScale: number;
+    bounce: number;
     vx: number;
     vy: number;
 }
@@ -82,6 +89,10 @@ export interface ParticleSpec {
 export interface Emitter extends Omit<ParticleSpec, "count"> {
     rate: number;
 }
+export interface ScriptComponent {
+    src: string;
+    params: Record<string, unknown>;
+}
 export interface Platformer {
     speed: number;
     jumpSpeed: number;
@@ -89,6 +100,11 @@ export interface Platformer {
     jumpBuffer: number;
     variableJump: boolean;
 }
+export interface Topdown {
+    speed: number;
+    directions: "8" | "4" | "x" | "y";
+    clampToWorld: boolean;
+}
 export interface Collectible {
     score: number;
 }