@downdraft/engine 0.1.1 → 0.2.0

package/dist/modules/html-ui/src/index.js

@@ -0,0 +1,5 @@
+export { PanelBlitPass } from "./composite.js";
+export { createHtmlUi, HtmlUiTok, isPointerOverUI } from "./create-html-ui.js";
+export { createDocCore, createLocalBackend, createWorkerBackend } from "./doc-backend.js";
+export { HtmlUiHost } from "./host.js";
+export { Fragment, jsx, jsxDEV, jsxs, renderHtml } from "./jsx-runtime.js";

package/dist/modules/html-ui/src/jsx-dev-runtime.js

@@ -0,0 +1,9 @@
+// ============================================================================
+// jsx-dev-runtime.ts — dev-mode JSX entry point.
+//
+// Vite/TS emit `jsxDEV` calls against "<jsxImportSource>/jsx-dev-runtime"
+// when jsxDev is enabled; the production transform uses "./jsx-runtime".
+// Same implementation — jsxDEV's extra args (key, isStaticChildren, source,
+// self) are ignored by this markup serializer.
+// ============================================================================
+export { jsx, jsxs, jsxDEV, Fragment, renderHtml } from "./jsx-runtime.js";

package/dist/modules/html-ui/src/jsx-runtime.js

@@ -0,0 +1,121 @@
+// ============================================================================
+// jsx-runtime.ts — minimal JSX→markup runtime for html-ui panels.
+//
+// Games write .tsx components with
+//   /** @jsxImportSource @downdraft/engine/modules/html-ui */
+// which call these exports to build vnode trees; `renderHtml(v)` serializes
+// to the markup string handed to a panel doc. There is no DOM and no vdom
+// diffing — re-render a panel on state change, or use mutator ops for hot
+// paths (progress bars, tickers).
+//
+// Interactivity: `data-*` attributes pass through (data-action drives the
+// event channel); `on*` props are rejected — events arrive via the doc's DOM
+// event queue, dispatched by data-action / selector handlers.
+// ============================================================================
+import { createLogger } from "@downdraft/engine/util/logger";
+const log = createLogger();
+export const Fragment = Symbol.for("ddx.fragment");
+const KEY = Symbol.for("ddx.jsx.key");
+function vnode(t, p) {
+    return { t, p, k: p?.key };
+}
+export function jsx(t, p) { return vnode(t, p); }
+export function jsxs(t, p) { return vnode(t, p); }
+export function jsxDEV(t, p) { return vnode(t, p); }
+const VOID = new Set(["area", "base", "br", "col", "embed", "hr", "img", "input", "link", "meta", "source", "track", "wbr"]);
+function esc(s) {
+    return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+const UNITLESS = new Set(["opacity", "zIndex", "z-index", "fontWeight", "font-weight", "lineHeight", "line-height", "flex", "flexGrow", "flex-grow", "flexShrink", "flex-shrink", "order", "gridArea"]);
+function styleObjToCss(v) {
+    if (typeof v === "string")
+        return v;
+    if (!v || typeof v !== "object")
+        return "";
+    let out = "";
+    for (const [k, val] of Object.entries(v)) {
+        if (val == null)
+            continue;
+        const prop = k.replace(/[A-Z]/g, (c) => "-" + c.toLowerCase());
+        const s = typeof val === "number" && !UNITLESS.has(k) && !UNITLESS.has(prop) ? `${val}px` : String(val);
+        out += `${prop}:${s};`;
+    }
+    return out;
+}
+let warnedOn = false;
+function attrString(p) {
+    if (!p)
+        return "";
+    let out = "";
+    for (const [k, v] of Object.entries(p)) {
+        if (k === "children" || k === "key" || k === "dangerouslySetInnerHTML" || v == null || v === false)
+            continue;
+        if (k.startsWith("on") && typeof v === "function") {
+            if (!warnedOn) {
+                warnedOn = true;
+                log.warn("html-ui", "on* props are ignored — use data-action + ui.onAction()");
+            }
+            continue;
+        }
+        if (k === "className") {
+            out += ` class="${esc(String(v))}"`;
+            continue;
+        }
+        if (k === "htmlFor") {
+            out += ` for="${esc(String(v))}"`;
+            continue;
+        }
+        if (k === "style") {
+            out += ` style="${esc(styleObjToCss(v))}"`;
+            continue;
+        }
+        if (v === true) {
+            out += ` ${k}`;
+            continue;
+        }
+        out += ` ${k}="${esc(String(v))}"`;
+    }
+    return out;
+}
+function renderInner(c, out) {
+    if (c == null || typeof c === "boolean")
+        return;
+    if (Array.isArray(c)) {
+        c.forEach((x) => { renderInner(x, out); ; });
+        return;
+    }
+    if (typeof c === "string" || typeof c === "number") {
+        out.push(esc(String(c)));
+        return;
+    }
+    out.push(renderNode(c));
+}
+function renderNode(v) {
+    const { t, p } = v;
+    if (t === Fragment) {
+        const out = [];
+        renderInner(p?.children, out);
+        return out.join("");
+    }
+    if (typeof t === "function") {
+        const r = t({ ...p });
+        const out = [];
+        renderInner(r, out);
+        return out.join("");
+    }
+    const attrs = attrString(p);
+    if (VOID.has(t))
+        return `<${t}${attrs}>`;
+    const raw = p?.dangerouslySetInnerHTML;
+    if (raw?.__html != null)
+        return `<${t}${attrs}>${raw.__html}</${t}>`;
+    const inner = [];
+    renderInner(p?.children, inner);
+    return `<${t}${attrs}>${inner.join("")}</${t}>`;
+}
+/** Serialize a vnode tree to an HTML fragment string for a panel doc. */
+export function renderHtml(v) {
+    const out = [];
+    renderInner(v, out);
+    return out.join("");
+}

package/dist/modules/html-ui/src/protocol.js

@@ -0,0 +1,6 @@
+// ============================================================================
+// protocol.ts — message contract between the html-ui host (main thread) and
+// the doc backend (ui worker, or in-process fallback). All panel-local
+// coordinates are CSS px; the backend multiplies by the doc's scale.
+// ============================================================================
+export {};

package/dist/modules/html-ui/src/ui-worker.js

@@ -0,0 +1,10 @@
+// ============================================================================
+// ui-worker.ts — Bun worker entry: owns every OsrDoc off the main thread.
+// Loaded via `new Worker(new URL("./ui-worker.ts", import.meta.url))`.
+// ============================================================================
+import { createDocCore } from "./doc-backend.js";
+// Frame buffers are freshly allocated per emit (see createDocCore) — transfer
+// them instead of structured-cloning, so a fullscreen repaint doesn't memcpy
+// tens of MB through postMessage.
+const core = createDocCore((m) => postMessage(m, m.type === "frame" && m.pixels ? [m.pixels] : []));
+self.onmessage = (e) => core.handle(e.data);

package/dist/modules/mcp/src/index.js

@@ -0,0 +1,62 @@
+import { resourceToken } from "@downdraft/engine";
+import { EngineContext, MCPServer } from "@downdraft/engine/mcp";
+import { createLogger } from "@downdraft/engine/util/logger";
+const log = createLogger("info");
+/** Token for the MCP server instance provided by the mcp plugin. */
+export const McpServerTok = resourceToken("mcp:server");
+export function createMcpModule(opts) {
+    let server = null;
+    return {
+        name: "mcp",
+        version: "0.1.0",
+        requires: [],
+        provides: [McpServerTok],
+        register(ctx) {
+            const engineContext = EngineContext.fromGame(opts);
+            server = new MCPServer({ engineContext });
+            ctx.provide(McpServerTok, server);
+            if (opts.transport !== "http") {
+                server.start();
+                ctx.onDispose(() => server?.stop());
+                return;
+            }
+            // HTTP transport — node:http and the PID-file dir are Node APIs, so
+            // they're dynamic-imported (keeps this module loadable in non-node
+            // contexts; same convention as createNodeFs in the editor module).
+            let disposed = false;
+            let transport = null;
+            let removePidFile = null;
+            void (async () => {
+                const [{ McpHttpTransport }, { writeMcpPidFile }] = await Promise.all([
+                    import("@downdraft/engine/mcp/http-transport"),
+                    import("@downdraft/engine/app/shared/mcp-discovery"),
+                ]);
+                if (disposed || !server)
+                    return;
+                transport = new McpHttpTransport({
+                    mcpServer: server,
+                    port: opts.port ?? (Number(process.env.MCP_EDITOR_PORT) || 0),
+                    requireAuth: opts.requireAuth,
+                    artifactDir: opts.artifactDir,
+                });
+                await transport.start();
+                if (disposed) {
+                    await transport.stop();
+                    return;
+                }
+                if (opts.advertise !== false) {
+                    removePidFile = writeMcpPidFile(transport.getPort(), transport.getAuthToken(), ".editor");
+                }
+                log.info("mcp", `Editor MCP server listening on 127.0.0.1:${transport.getPort()}`);
+            })().catch((e) => {
+                log.warn("mcp", `Editor MCP HTTP endpoint failed to start: ${e.message}`);
+            });
+            ctx.onDispose(() => {
+                disposed = true;
+                removePidFile?.();
+                void transport?.stop();
+            });
+        },
+    };
+}
+export { EngineContext, MCPServer };

package/dist/modules/movement-2d/src/grid-character.js

@@ -0,0 +1,345 @@
+// ============================================================================
+// GridCharacterController — shared 2D platformer physics for grid-based games
+//
+// Generalized from the falling-sand `player.ts` / mining-rpg `mining-player.ts`
+// / overburden `blockhead.ts` copies. An AABB character moves through a grid
+// world where cells may be solid, liquid, climbable, or damaging.
+//
+// The game supplies a `GridCharacterWorld` of cell predicates, so this works
+// over any grid representation (Uint32 packed material ids, Uint16 block ids,
+// foreground + background layers, etc.).
+// ============================================================================
+// ─── Implementation ──────────────────────────────────────────────────────────
+export function createGridCharacterController(cfg) {
+    const W2 = cfg.width / 2;
+    const H = cfg.height;
+    const collisionStep = cfg.collisionStep ?? Infinity;
+    const fineSnap = cfg.fineSnap ?? false;
+    const restOnGround = cfg.restOnGround ?? false;
+    const stepUp = cfg.stepUp ?? 0;
+    const swimMin = cfg.swim?.minCells ?? 2;
+    const swimBuoyPerCell = cfg.swim?.buoyancyPerCell ?? 0.008;
+    const swimMaxBuoy = cfg.swim?.maxBuoyancy ?? 0.06;
+    const swimUp = cfg.swim?.upAccel ?? 0.05;
+    const swimDown = cfg.swim?.downAccel ?? 0.05;
+    const swimDamp = cfg.swim?.damping ?? 0.92;
+    const clingDamp = cfg.climb?.clingDamp ?? 0.5;
+    const jumpDismount = cfg.climb?.jumpDismount ?? true;
+    const isSolid = (world, x, y) => world.isSolid(x, y);
+    const isHard = (world, x, y) => world.isHardSolid ? world.isHardSolid(x, y) : world.isSolid(x, y);
+    /** AABB overlap test against the solid predicate. */
+    function boxHits(world, px, py, test) {
+        const x0 = Math.floor(px - W2), x1 = Math.floor(px + W2);
+        const y0 = Math.floor(py), y1 = Math.floor(py + H - 1);
+        for (let y = y0; y <= y1; y++)
+            for (let x = x0; x <= x1; x++)
+                if (test(x, y))
+                    return true;
+        return false;
+    }
+    const hitsSolid = (world, px, py) => boxHits(world, px, py, (x, y) => isSolid(world, x, y));
+    function countCells(world, px, py, test) {
+        const x0 = Math.floor(px - W2), x1 = Math.floor(px + W2);
+        const y0 = Math.floor(py), y1 = Math.floor(py + H - 1);
+        let n = 0, total = 0;
+        for (let y = y0; y <= y1; y++) {
+            for (let x = x0; x <= x1; x++) {
+                total++;
+                if (test(x, y))
+                    n++;
+            }
+        }
+        return { n, total };
+    }
+    function countLiquid(world, px, py) {
+        if (!world.isLiquid)
+            return 0;
+        return countCells(world, px, py, (x, y) => world.isLiquid(x, y)).n;
+    }
+    function isHeadInLiquid(world, px, py) {
+        if (!world.isLiquid)
+            return false;
+        const x0 = Math.floor(px - W2), x1 = Math.floor(px + W2);
+        const y = Math.floor(py);
+        for (let x = x0; x <= x1; x++) {
+            if (world.isLiquid(x, y))
+                return true;
+        }
+        return false;
+    }
+    function countClimbable(world, px, py) {
+        if (!world.isClimbable)
+            return 0;
+        return countCells(world, px, py, (x, y) => world.isClimbable(x, y)).n;
+    }
+    /** Clear solid cells overlapping the body so the player can wiggle out. */
+    function wiggleClear(world, px, py, dirX, maxClear) {
+        const canClear = world.canWiggleClear ?? ((x, y) => world.isSolid(x, y));
+        const clearCell = world.clearCell;
+        if (!clearCell)
+            return 0;
+        const x0 = Math.floor(px - W2), x1 = Math.floor(px + W2);
+        const y0 = Math.floor(py), y1 = Math.floor(py + H - 1);
+        let cleared = 0;
+        const xs = dirX > 0 ? [x1, x1 - 1, x0] : dirX < 0 ? [x0, x0 + 1, x1] : [x0, x1];
+        for (let _i = 0, _it = xs, _n = _it.length; _i < _n; _i++) {
+            const x = _it[_i];
+            if (cleared >= maxClear)
+                break;
+            for (let y = y0; y <= y1; y++) {
+                if (cleared >= maxClear)
+                    break;
+                if (x < 0 || !canClear(x, y))
+                    continue;
+                clearCell(x, y);
+                cleared++;
+            }
+        }
+        return cleared;
+    }
+    function damage(p, amount, kind, cause) {
+        if (amount <= 0)
+            return;
+        if (cfg.applyDamage)
+            cfg.applyDamage(p, amount, kind, cause);
+        else
+            p.health = Math.max(0, p.health - amount);
+        cfg.onDamage?.(p, amount, kind, cause);
+    }
+    function update(p, input, world, mods) {
+        let px = p.x;
+        let py = p.y;
+        const gravityMul = mods?.gravityMul ?? 1;
+        // --- Noclip (development cheat): free flight, no collision/damage ---
+        if (cfg.noclip && input.noclip) {
+            let vx = 0, vy = 0;
+            if (input.left) {
+                vx -= 1;
+                p.facing = -1;
+            }
+            if (input.right) {
+                vx += 1;
+                p.facing = 1;
+            }
+            if (input.up || input.jump)
+                vy -= 1;
+            if (input.down)
+                vy += 1;
+            const len = Math.hypot(vx, vy);
+            if (len > 0) {
+                vx = (vx / len) * cfg.noclip.speed;
+                vy = (vy / len) * cfg.noclip.speed;
+            }
+            px += vx;
+            py += vy;
+            px = Math.max(W2, Math.min(world.w - W2 - 1, px));
+            py = Math.max(0, Math.min(world.h - H, py));
+            p.vx = vx;
+            p.vy = vy;
+            p.onGround = false;
+            p.animFrame++;
+            cfg.noclip.onNoclipTick?.(p);
+            p.x = px;
+            p.y = py;
+            return;
+        }
+        const liquidCount = cfg.swim ? countLiquid(world, px, py) : 0;
+        const inLiquid = cfg.swim ? liquidCount >= swimMin : false;
+        const buoyancy = inLiquid ? Math.min(swimMaxBuoy, liquidCount * swimBuoyPerCell) : 0;
+        const onClimb = cfg.climb ? countClimbable(world, px, py) > 0 : false;
+        // --- Buried state ---
+        let partiallyBuried = false;
+        if (cfg.bury) {
+            const overlap = countCells(world, px, py, (x, y) => isSolid(world, x, y));
+            const hard = countCells(world, px, py, (x, y) => isHard(world, x, y));
+            const fullyBuried = hard.n >= hard.total;
+            partiallyBuried = overlap.n > 0 && !fullyBuried;
+            if (fullyBuried)
+                damage(p, cfg.bury.crushDamage, "crush", cfg.bury.cause);
+        }
+        // --- Horizontal movement ---
+        const accel = (mods?.accelMul ?? 1) * cfg.moveAccel;
+        if (input.left) {
+            p.vx -= accel;
+            p.facing = -1;
+        }
+        if (input.right) {
+            p.vx += accel;
+            p.facing = 1;
+        }
+        if (!input.left && !input.right)
+            p.vx *= cfg.friction;
+        const speedCap = (partiallyBuried ? cfg.bury.wiggleSpeed : cfg.maxSpeed) * (mods?.speedMul ?? 1);
+        p.vx = Math.max(-speedCap, Math.min(speedCap, p.vx));
+        // --- Jump / climb / swim / gravity ---
+        if (input.jump && (p.onGround || (onClimb && jumpDismount))) {
+            p.vy = -cfg.jumpForce;
+            p.onGround = false;
+        }
+        if (onClimb) {
+            if (input.up)
+                p.vy = -cfg.climb.speed;
+            else if (input.down)
+                p.vy = cfg.climb.speed;
+            else
+                p.vy *= clingDamp;
+        }
+        if (inLiquid) {
+            if (input.up)
+                p.vy -= swimUp;
+            if (input.down)
+                p.vy += swimDown;
+        }
+        if (onClimb && !input.down) {
+            // gravity suspended while clinging/climbing up
+        }
+        else if (restOnGround && p.onGround) {
+            p.vy = 0;
+        }
+        else {
+            p.vy += (cfg.gravity - buoyancy) * gravityMul;
+        }
+        if (inLiquid)
+            p.vy *= swimDamp;
+        p.vy = Math.min(cfg.maxFall, p.vy);
+        // --- Move X with collision ---
+        const newX = px + p.vx;
+        if (!hitsSolid(world, newX, py)) {
+            px = newX;
+        }
+        else if (partiallyBuried && Math.abs(p.vx) > 0.01) {
+            const cleared = wiggleClear(world, px, py, p.vx > 0 ? 1 : -1, cfg.bury.maxClearPerTick);
+            if (cleared > 0 && !hitsSolid(world, newX, py))
+                px = newX;
+            else
+                p.vx = 0;
+        }
+        else {
+            // Step up N cells while grounded
+            let stepped = false;
+            if (stepUp > 0 && p.onGround) {
+                for (let s = 1; s <= stepUp; s++) {
+                    if (!hitsSolid(world, newX, py - s)) {
+                        px = newX;
+                        py -= s;
+                        stepped = true;
+                        break;
+                    }
+                }
+            }
+            if (!stepped)
+                p.vx = 0;
+        }
+        // Clamp X to world bounds
+        if (px < W2) {
+            px = W2;
+            p.vx = 0;
+        }
+        if (px > world.w - W2 - 1) {
+            px = world.w - W2 - 1;
+            p.vx = 0;
+        }
+        // --- Move Y with collision ---
+        const totalDy = p.vy;
+        if (totalDy === 0) {
+            // If we were on ground, verify the ground is still there.
+            if (restOnGround && p.onGround) {
+                const feetY = Math.floor(py + H);
+                const fx0 = Math.floor(px - W2), fx1 = Math.floor(px + W2);
+                let groundBelow = false;
+                for (let x = fx0; x <= fx1; x++) {
+                    if (isSolid(world, x, feetY)) {
+                        groundBelow = true;
+                        break;
+                    }
+                }
+                p.onGround = groundBelow;
+            }
+            else if (!restOnGround) {
+                p.onGround = false;
+            }
+        }
+        else {
+            const steps = Math.max(1, Math.ceil(Math.abs(totalDy) / collisionStep));
+            const stepDy = totalDy / steps;
+            p.onGround = false;
+            for (let s = 0; s < steps; s++) {
+                const newY = py + stepDy;
+                if (!hitsSolid(world, px, newY)) {
+                    py = newY;
+                }
+                else {
+                    if (stepDy > 0) {
+                        p.onGround = true;
+                        const fallSpeed = p.vy;
+                        if (fineSnap) {
+                            // Binary-search the closest resting position.
+                            let lo = py, hi = newY;
+                            for (let i = 0; i < 5; i++) {
+                                const mid = (lo + hi) * 0.5;
+                                if (hitsSolid(world, px, mid))
+                                    hi = mid;
+                                else
+                                    lo = mid;
+                            }
+                            py = lo;
+                        }
+                        if (cfg.fallDamage && fallSpeed > cfg.fallDamage.threshold) {
+                            const feetY = Math.floor(py + H);
+                            const fx0 = Math.floor(px - W2), fx1 = Math.floor(px + W2);
+                            let landedOnHard = false;
+                            for (let x = fx0; x <= fx1; x++) {
+                                if (isHard(world, x, feetY)) {
+                                    landedOnHard = true;
+                                    break;
+                                }
+                            }
+                            if (landedOnHard) {
+                                const excess = fallSpeed - cfg.fallDamage.threshold;
+                                damage(p, Math.round(excess * excess * cfg.fallDamage.scale), "fall", cfg.fallDamage.cause);
+                            }
+                        }
+                    }
+                    p.vy = 0;
+                    break;
+                }
+            }
+        }
+        // Clamp Y
+        if (py < 0) {
+            py = 0;
+            p.vy = 0;
+        }
+        if (py > world.h - H) {
+            py = world.h - H;
+            p.vy = 0;
+            p.onGround = true;
+        }
+        // Animation
+        if (Math.abs(p.vx) > 0.01 || !p.onGround)
+            p.animFrame++;
+        else
+            p.animFrame = 0;
+        // --- Contact damage ---
+        if (world.damageAt) {
+            const cx = Math.floor(px);
+            for (let dy = 0; dy < H; dy++) {
+                for (let dx = -1; dx <= 1; dx++) {
+                    const gx = cx + dx;
+                    const gy = Math.floor(py) + dy;
+                    const d = world.damageAt(gx, gy);
+                    if (typeof d === "number") {
+                        if (d > 0)
+                            damage(p, d, "contact", undefined);
+                    }
+                    else if (d && d.damage > 0) {
+                        damage(p, d.damage, "contact", d.cause);
+                    }
+                }
+            }
+        }
+        p.x = px;
+        p.y = py;
+    }
+    return { update, countLiquid, isHeadInLiquid, countClimbable };
+}

package/dist/modules/movement-2d/src/index.js

@@ -0,0 +1,27 @@
+// ============================================================================
+// @downdraft/engine/modules/movement-2d — 2D side-scrolling grid character movement
+//
+// Provides a configurable AABB-vs-grid character controller
+// (createGridCharacterController): platformer physics with collision,
+// step-up, swimming, ladder climbing, noclip, fall damage, bury/crush, and
+// contact hazards. The game supplies cell predicates via GridCharacterWorld.
+//
+// The module wraps the factory in a DI token for module-host games; games
+// with hand-rolled sims can import createGridCharacterController directly.
+// ============================================================================
+import { resourceToken } from "@downdraft/engine";
+import { createGridCharacterController } from "./grid-character.js";
+export { createGridCharacterController } from "./grid-character.js";
+export const GridCharacterControllerTok = resourceToken("movement-2d:grid-character");
+/** @deprecated Use GridCharacterControllerTok. */
+export const Movement2DStateTok = resourceToken("movement-2d:state");
+export function createMovement2DModule(config) {
+    return {
+        name: "movement-2d",
+        version: "1.0.0",
+        provides: [GridCharacterControllerTok],
+        register(ctx) {
+            ctx.provide(GridCharacterControllerTok, createGridCharacterController(config));
+        },
+    };
+}