@waica/engine 0.18.0 → 0.19.1

package/dist/collision-shape.js

@@ -74,34 +74,57 @@ export function collisionOverlap(a, b) {
     }
     const verticesA = collisionVertices(a);
     const verticesB = collisionVertices(b);
-    for (let ai = 0; ai < verticesA.length; ai++) {
-        const a1 = verticesA[ai];
-        const a2 = verticesA[(ai + 1) % verticesA.length];
-        for (let bi = 0; bi < verticesB.length; bi++) {
-            const b1 = verticesB[bi];
-            const b2 = verticesB[(bi + 1) % verticesB.length];
-            if (segmentsCross(a1, a2, b1, b2))
-                return true;
-        }
-    }
+    if (polygonEdgesCross(verticesA, verticesB))
+        return true;
     return hasInteriorPoint(verticesA, verticesB) || hasInteriorPoint(verticesB, verticesA);
 }
-function hasInteriorPoint(points, polygon) {
-    for (let index = 0; index < points.length; index++) {
-        const point = points[index];
-        if (pointInPolygon(point, polygon))
+/** Whether any closed-polygon edge of `polygonA` properly crosses one of `polygonB`. */
+function polygonEdgesCross(polygonA, polygonB) {
+    let a1 = polygonA.at(-1);
+    if (a1 === undefined)
+        return false;
+    for (const a2 of polygonA) {
+        if (edgeCrossesPolygon(a1, a2, polygonB))
             return true;
-        const next = points[(index + 1) % points.length];
-        if (pointInPolygon([(point[0] + next[0]) / 2, (point[1] + next[1]) / 2], polygon)) {
+        a1 = a2;
+    }
+    return false;
+}
+function edgeCrossesPolygon(a1, a2, polygon) {
+    let b1 = polygon.at(-1);
+    if (b1 === undefined)
+        return false;
+    for (const b2 of polygon) {
+        if (segmentsCross(a1, a2, b1, b2))
             return true;
-        }
+        b1 = b2;
     }
+    return false;
+}
+function hasInteriorPoint(points, polygon) {
+    if (hasVertexOrMidpointInside(points, polygon))
+        return true;
     const center = [
         points.reduce((sum, [x]) => sum + x, 0) / points.length,
         points.reduce((sum, [, y]) => sum + y, 0) / points.length,
     ];
     return pointInPolygon(center, polygon);
 }
+/** Whether any vertex of `points`, or the midpoint of any of its closed-polygon edges, lies inside `polygon`. */
+function hasVertexOrMidpointInside(points, polygon) {
+    let previous = points.at(-1);
+    if (previous === undefined)
+        return false;
+    for (const point of points) {
+        if (pointInPolygon(point, polygon))
+            return true;
+        if (pointInPolygon([(previous[0] + point[0]) / 2, (previous[1] + point[1]) / 2], polygon)) {
+            return true;
+        }
+        previous = point;
+    }
+    return false;
+}
 function segmentsCross(a1, a2, b1, b2) {
     const ab1 = cross(a1, a2, b1);
     const ab2 = cross(a1, a2, b2);
@@ -114,15 +137,17 @@ function cross(a, b, point) {
 }
 function pointInPolygon(point, polygon) {
     let inside = false;
-    for (let index = 0, previous = polygon.length - 1; index < polygon.length; previous = index++) {
-        const a = polygon[index];
-        const b = polygon[previous];
+    let b = polygon.at(-1);
+    if (b === undefined)
+        return inside;
+    for (const a of polygon) {
         if (pointOnSegment(point, a, b))
             return false;
         const crosses = (a[1] > point[1]) !== (b[1] > point[1]) &&
             point[0] < ((b[0] - a[0]) * (point[1] - a[1])) / (b[1] - a[1]) + a[0];
         if (crosses)
             inside = !inside;
+        b = a;
     }
     return inside;
 }

package/dist/component-registry.d.ts

@@ -1,7 +1,17 @@
-import { type ComponentClass } from './component.js';
+import { Component, type ComponentClass } from './component.js';
 import type { SceneRegistry } from './scene.js';
 /** The namespace returned by importing one project code module. */
 export type ComponentModule = Readonly<Record<string, unknown>>;
+/** Whether `value` is a class that extends Component (the abstract base itself is not). */
+export declare function isComponentClass(value: unknown): value is ComponentClass;
+/**
+ * The class a live component was constructed from. TypeScript types
+ * `constructor` as Function; this narrows it for real instead of asserting.
+ * It checks the shape (a constructor with a static componentName), not
+ * `instanceof Component`, so a project that resolves a second copy of
+ * @waica/engine keeps working. Internal: not re-exported from the package entry.
+ */
+export declare function componentClassOf(component: Component): ComponentClass;
 /**
  * Finds exported Component subclasses in project modules. Classes are keyed by
  * their stable componentName, not by the export name, so minification and

package/dist/component-registry.js

@@ -1,4 +1,29 @@
 import { Component } from './component.js';
+/** Whether `value` is a class that extends Component (the abstract base itself is not). */
+export function isComponentClass(value) {
+    if (typeof value !== 'function')
+        return false;
+    const prototype = Reflect.get(value, 'prototype');
+    return prototype instanceof Component;
+}
+/**
+ * The class a live component was constructed from. TypeScript types
+ * `constructor` as Function; this narrows it for real instead of asserting.
+ * It checks the shape (a constructor with a static componentName), not
+ * `instanceof Component`, so a project that resolves a second copy of
+ * @waica/engine keeps working. Internal: not re-exported from the package entry.
+ */
+export function componentClassOf(component) {
+    const Class = component.constructor;
+    if (!hasComponentName(Class)) {
+        throw new TypeError('a component was not constructed from a Component class');
+    }
+    return Class;
+}
+/** A constructor carrying the static componentName every Component class declares. */
+function hasComponentName(value) {
+    return typeof value === 'function' && typeof Reflect.get(value, 'componentName') === 'string';
+}
 /**
  * Finds exported Component subclasses in project modules. Classes are keyed by
  * their stable componentName, not by the export name, so minification and
@@ -8,11 +33,9 @@ export function collectModuleComponents(modules, warn = console.warn) {
     const components = {};
     for (const module of modules) {
         for (const value of Object.values(module)) {
-            if (typeof value !== 'function')
+            if (!isComponentClass(value))
                 continue;
             const Class = value;
-            if (!(Class.prototype instanceof Component))
-                continue;
             // Without its own componentName a class inherits the base's, so nothing
             // could reference it from scene JSON. Silently skipping it looks like
             // the editor lost the file: say so instead.

package/dist/component-update-schedule.d.ts

@@ -32,6 +32,8 @@ export interface InvalidComponentUpdateSchedule {
 }
 export type ComponentUpdateScheduleResult = ValidComponentUpdateSchedule | InvalidComponentUpdateSchedule;
 export type ComponentUpdateRegistry = Readonly<Record<string, ComponentClass | undefined>>;
+/** Whether instances of `Class` run each frame (its prototype defines onUpdate). */
+export declare function implementsOnUpdate(Class: ComponentClass | undefined): boolean;
 /**
  * Resolves one entity's deterministic component update schedule without
  * constructing components or mutating either input.

package/dist/component-update-schedule.js

@@ -4,8 +4,26 @@ function codeUnitCompare(left, right) {
 function registeredClass(registry, componentName) {
     return Object.hasOwn(registry, componentName) ? registry[componentName] : undefined;
 }
-function updates(Class) {
-    return typeof Class?.prototype.onUpdate === 'function';
+/** Whether instances of `Class` run each frame (its prototype defines onUpdate). */
+export function implementsOnUpdate(Class) {
+    if (!Class)
+        return false;
+    const prototype = Reflect.get(Class, 'prototype');
+    return typeof prototype === 'object' && prototype !== null && typeof Reflect.get(prototype, 'onUpdate') === 'function';
+}
+/** Reads a Tarjan bookkeeping entry that the traversal has already recorded. */
+function recorded(map, node, what) {
+    const value = map.get(node);
+    if (value === undefined)
+        throw new Error(`Component update cycle search has no ${what} for "${node}"`);
+    return value;
+}
+/** The first member of a strongly connected group, which always has at least two members. */
+function firstMember(group) {
+    const [first] = group;
+    if (first === undefined)
+        throw new Error('Component update cycle group is empty');
+    return first;
 }
 function updateCycles(nodes, outgoing) {
     let nextIndex = 0;
@@ -23,21 +41,22 @@ function updateCycles(nodes, outgoing) {
         for (const dependent of [...(outgoing.get(node) ?? [])].sort(codeUnitCompare)) {
             if (!indices.has(dependent)) {
                 visit(dependent);
-                lowLinks.set(node, Math.min(lowLinks.get(node), lowLinks.get(dependent)));
+                lowLinks.set(node, Math.min(recorded(lowLinks, node, 'low link'), recorded(lowLinks, dependent, 'low link')));
             }
             else if (onStack.has(dependent)) {
-                lowLinks.set(node, Math.min(lowLinks.get(node), indices.get(dependent)));
+                lowLinks.set(node, Math.min(recorded(lowLinks, node, 'low link'), recorded(indices, dependent, 'index')));
             }
         }
         if (lowLinks.get(node) !== indices.get(node))
             return;
         const group = [];
-        while (stack.length > 0) {
-            const member = stack.pop();
+        let member = stack.pop();
+        while (member !== undefined) {
             onStack.delete(member);
             group.push(member);
             if (member === node)
                 break;
+            member = stack.pop();
         }
         if (group.length > 1)
             cycles.push(group.sort(codeUnitCompare));
@@ -46,19 +65,9 @@ function updateCycles(nodes, outgoing) {
         if (!indices.has(node))
             visit(node);
     }
-    return cycles.sort((left, right) => codeUnitCompare(left[0], right[0]));
+    return cycles.sort((left, right) => codeUnitCompare(firstMember(left), firstMember(right)));
 }
-/**
- * Resolves one entity's deterministic component update schedule without
- * constructing components or mutating either input.
- */
-export function resolveComponentUpdateSchedule(componentNames, registry) {
-    const present = new Set(componentNames);
-    const nodes = [...present]
-        .filter((name) => updates(registeredClass(registry, name)))
-        .sort(codeUnitCompare);
-    const outgoing = new Map(nodes.map((name) => [name, new Set()]));
-    const indegree = new Map(nodes.map((name) => [name, 0]));
+function duplicateComponentIssues(componentNames) {
     const issues = [];
     const counts = new Map();
     for (const name of componentNames)
@@ -74,9 +83,13 @@ export function resolveComponentUpdateSchedule(componentNames, registry) {
             cause: `Component "${componentName}" appears ${count} times on the same entity; component identity must be unique.`,
         });
     }
+    return issues;
+}
+function passiveDeclarerIssues({ present, registry }) {
+    const issues = [];
     for (const declarer of [...present].sort(codeUnitCompare)) {
         const Class = registeredClass(registry, declarer);
-        if (Class?.updateAfter !== undefined && !updates(Class)) {
+        if (Class?.updateAfter !== undefined && !implementsOnUpdate(Class)) {
             issues.push({
                 code: 'invalid-update-constraint',
                 reason: 'passive-declarer',
@@ -86,65 +99,75 @@ export function resolveComponentUpdateSchedule(componentNames, registry) {
             });
         }
     }
-    for (const declarer of nodes) {
-        const Class = registeredClass(registry, declarer);
+    return issues;
+}
+/** Adds every valid updateAfter edge to the graph and returns the constraints that are not. */
+function linkUpdateConstraints(graph, scope) {
+    const issues = [];
+    for (const declarer of graph.nodes) {
+        const Class = registeredClass(scope.registry, declarer);
         for (const target of new Set(Class?.updateAfter ?? [])) {
-            if (!present.has(target)) {
-                if (!registeredClass(registry, target)) {
-                    issues.push({
-                        code: 'invalid-update-constraint',
-                        reason: 'unknown-target',
-                        declarer,
-                        target,
-                        componentNames: [declarer, target],
-                        cause: `Component "${declarer}" declares updateAfter target "${target}", which is neither present nor registered.`,
-                    });
-                }
+            const verdict = constraintVerdict({ declarer, target }, graph, scope);
+            if (verdict === 'ignore')
                 continue;
-            }
-            if (target === declarer) {
-                issues.push({
-                    code: 'invalid-update-constraint',
-                    reason: 'self-edge',
-                    declarer,
-                    target,
-                    componentNames: [declarer],
-                    cause: `Component "${declarer}" cannot declare itself in updateAfter.`,
-                });
-                continue;
-            }
-            if (!outgoing.has(target)) {
-                issues.push({
-                    code: 'invalid-update-constraint',
-                    reason: 'passive-target',
-                    declarer,
-                    target,
-                    componentNames: [declarer, target],
-                    cause: `Component "${declarer}" declares updateAfter target "${target}", but "${target}" does not implement onUpdate.`,
-                });
+            if (verdict !== 'link') {
+                issues.push(verdict);
                 continue;
             }
-            const readers = outgoing.get(target);
-            if (readers.has(declarer))
+            const readers = graph.outgoing.get(target);
+            if (!readers || readers.has(declarer))
                 continue;
             readers.add(declarer);
-            indegree.set(declarer, (indegree.get(declarer) ?? 0) + 1);
+            graph.indegree.set(declarer, (graph.indegree.get(declarer) ?? 0) + 1);
         }
     }
-    for (const componentNames of updateCycles(nodes, outgoing)) {
-        issues.push({
-            code: 'component-update-cycle',
-            componentNames,
-            cause: `Component update cycle among ${componentNames.map((name) => `"${name}"`).join(', ')}.`,
-        });
+    return issues;
+}
+/**
+ * Whether `declarer` may update after `target`: an edge to link, a
+ * registered-but-absent target to ignore, or the invalid-constraint issue.
+ */
+function constraintVerdict({ declarer, target }, graph, { present, registry }) {
+    if (!present.has(target)) {
+        if (registeredClass(registry, target))
+            return 'ignore';
+        return {
+            code: 'invalid-update-constraint',
+            reason: 'unknown-target',
+            declarer,
+            target,
+            componentNames: [declarer, target],
+            cause: `Component "${declarer}" declares updateAfter target "${target}", which is neither present nor registered.`,
+        };
     }
-    if (issues.length > 0)
-        return { ok: false, issues };
+    if (target === declarer) {
+        return {
+            code: 'invalid-update-constraint',
+            reason: 'self-edge',
+            declarer,
+            target,
+            componentNames: [declarer],
+            cause: `Component "${declarer}" cannot declare itself in updateAfter.`,
+        };
+    }
+    if (graph.outgoing.has(target))
+        return 'link';
+    return {
+        code: 'invalid-update-constraint',
+        reason: 'passive-target',
+        declarer,
+        target,
+        componentNames: [declarer, target],
+        cause: `Component "${declarer}" declares updateAfter target "${target}", but "${target}" does not implement onUpdate.`,
+    };
+}
+/** Kahn's order over the graph, always taking the code-unit-smallest ready component first. */
+function updateOrder({ nodes, outgoing, indegree }) {
     const ready = nodes.filter((name) => indegree.get(name) === 0);
     const order = [];
-    while (ready.length > 0) {
-        ready.sort(codeUnitCompare);
-        const next = ready.shift();
+    ready.sort(codeUnitCompare);
+    let next = ready.shift();
+    while (next !== undefined) {
         order.push(next);
         for (const dependent of [...(outgoing.get(next) ?? [])].sort(codeUnitCompare)) {
             const remaining = (indegree.get(dependent) ?? 0) - 1;
@@ -152,6 +175,39 @@ export function resolveComponentUpdateSchedule(componentNames, registry) {
             if (remaining === 0)
                 ready.push(dependent);
         }
+        ready.sort(codeUnitCompare);
+        next = ready.shift();
     }
-    return { ok: true, order, issues: [] };
+    return order;
+}
+/**
+ * Resolves one entity's deterministic component update schedule without
+ * constructing components or mutating either input.
+ */
+export function resolveComponentUpdateSchedule(componentNames, registry) {
+    const present = new Set(componentNames);
+    const scope = { present, registry };
+    const nodes = [...present]
+        .filter((name) => implementsOnUpdate(registeredClass(registry, name)))
+        .sort(codeUnitCompare);
+    const graph = {
+        nodes,
+        outgoing: new Map(nodes.map((name) => [name, new Set()])),
+        indegree: new Map(nodes.map((name) => [name, 0])),
+    };
+    const issues = [
+        ...duplicateComponentIssues(componentNames),
+        ...passiveDeclarerIssues(scope),
+        ...linkUpdateConstraints(graph, scope),
+    ];
+    for (const cycle of updateCycles(nodes, graph.outgoing)) {
+        issues.push({
+            code: 'component-update-cycle',
+            componentNames: cycle,
+            cause: `Component update cycle among ${cycle.map((name) => `"${name}"`).join(', ')}.`,
+        });
+    }
+    if (issues.length > 0)
+        return { ok: false, issues };
+    return { ok: true, order: updateOrder(graph), issues: [] };
 }

package/dist/components/animated-sprite.js

@@ -3,6 +3,7 @@ import { Component } from '../component.js';
 import { ClipPlayer } from '../animation/clip-player.js';
 import { locateFrame, sheetCell } from '../animation/sheet.js';
 import { spritePlacement } from '../sprite-placement.js';
+import { reportRejection } from '../report-rejection.js';
 const clampAnchor = (value) => Math.min(1, Math.max(0, value));
 /**
  * Sprite animated from one or more spritesheets. The main sheet is the
@@ -215,13 +216,13 @@ export class AnimatedSprite extends Component {
         if (!url)
             return new THREE.Texture();
         const { texture, settled } = this.game.assets.texture(url);
-        void settled.then((outcome) => {
+        reportRejection(settled.then((outcome) => {
             if (!this.texs.includes(texture))
                 return;
             if (outcome === 'failed')
                 this.failedSheets.add(texture);
             this.applyFrame();
-        });
+        }), 'sheet texture settle');
         return texture;
     }
     showFrame(index) {

package/dist/components/sprite.js

@@ -1,6 +1,7 @@
 import * as THREE from 'three';
 import { Component } from '../component.js';
 import { spritePlacement } from '../sprite-placement.js';
+import { reportRejection } from '../report-rejection.js';
 const clampAnchor = (value) => Math.min(1, Math.max(0, value));
 /**
  * Textured or flat-color quad. In the unified pipeline, a 2D sprite is a
@@ -118,10 +119,10 @@ export class Sprite extends Component {
             }
             material.map = texture;
             material.color.set(0xffffff);
-            void settled.then((outcome) => {
+            reportRejection(settled.then((outcome) => {
                 if (outcome === 'failed')
                     this.dropFailedTexture(texture);
-            });
+            }), 'sprite texture settle');
         }
         this.mesh = new THREE.Mesh(this.createGeometry(), material);
         this.mesh.position.z = this.layer * 0.01;

package/dist/components/tilemap.d.ts

@@ -115,5 +115,11 @@ export declare class Tilemap extends Component implements SolidSource {
     private dropFailedTexture;
     private makeMaterial;
     private rebuildGeometry;
+    /** The loaded sheet image's size, or one pixel per sheet cell until it arrives. */
+    private sheetSize;
+    /** The four corners of a cell's quad, projected for the Game, on this layer's depth. */
+    private pushTileQuad;
+    /** The UVs of a tile's sheet cell, in the quad's corner order. */
+    private tileUvs;
     private rebuildSolids;
 }

package/dist/components/tilemap.js

@@ -5,6 +5,7 @@ import { projectIsometric } from '../projection.js';
 import { SOLID_SOURCE_SYMBOL } from '../scene-solids.js';
 import { cellAt as gridCellAt, cellBounds as gridCellBounds, cellIndex as gridCellIndex, } from '../tilemap-grid.js';
 import { Solid } from './solid.js';
+import { reportRejection } from '../report-rejection.js';
 /** One authorable cell map rendered as a single merged geometry. */
 export class Tilemap extends Component {
     static componentName = 'Tilemap';
@@ -218,14 +219,14 @@ export class Tilemap extends Component {
         // happens if the texture was replaced or the component destroyed
         // meanwhile.
         const { texture, settled } = this.game.assets.texture(requested);
-        void settled.then((outcome) => {
+        reportRejection(settled.then((outcome) => {
             if (this.loadedTexture !== texture || this.texture !== requested)
                 return;
             if (outcome === 'loaded')
                 this.rebuildGeometry();
             else
                 this.dropFailedTexture();
-        });
+        }), 'tilemap texture settle');
         if (this.pixelArt) {
             texture.magFilter = THREE.NearestFilter;
             texture.minFilter = THREE.NearestFilter;
@@ -260,56 +261,66 @@ export class Tilemap extends Component {
         const mesh = this.mesh;
         if (!mesh)
             return;
-        const positions = [];
-        const uvs = [];
-        const indices = [];
+        const buffers = { positions: [], uvs: [], indices: [] };
         const width = Math.max(0, Math.floor(this.mapWidth));
         const height = Math.max(0, Math.floor(this.mapHeight));
         const size = this.cellSize;
         if (Number.isFinite(size) && size > 0) {
-            const image = this.loadedTexture?.image;
-            const imageWidth = image?.width && image.width > 0 ? image.width : Math.max(1, this.cols);
-            const imageHeight = image?.height && image.height > 0 ? image.height : Math.max(1, this.rows);
-            const frameParams = {
-                gridOffsetX: this.gridOffsetX,
-                gridOffsetY: this.gridOffsetY,
-                spacingX: this.spacingX,
-                spacingY: this.spacingY,
-                cellWidth: this.cellWidth,
-                cellHeight: this.cellHeight,
-            };
+            const sheet = this.sheetSize();
             for (let index = 0; index < width * height; index++) {
                 const tile = this.cells[index] ?? -1;
                 if (!Number.isFinite(tile) || tile < 0)
                     continue;
-                const column = index % width;
-                const row = Math.floor(index / width);
-                const logicalCenterX = (column + 0.5) * size;
-                const logicalCenterY = (row + 0.5) * size;
-                const center = this.game.projection === 'isometric'
-                    ? projectIsometric(logicalCenterX, logicalCenterY)
-                    : { x: logicalCenterX, y: logicalCenterY };
-                const halfWidth = this.game.projection === 'isometric' ? size : size / 2;
-                const halfHeight = size / 2;
-                const z = this.layer * 0.01;
-                positions.push(center.x - halfWidth, center.y - halfHeight, z, center.x + halfWidth, center.y - halfHeight, z, center.x + halfWidth, center.y + halfHeight, z, center.x - halfWidth, center.y + halfHeight, z);
-                const frame = sheetCell(imageWidth, imageHeight, this.cols, this.rows, tile, frameParams);
-                const left = frame.x / imageWidth;
-                const right = (frame.x + frame.width) / imageWidth;
-                const bottom = 1 - (frame.y + frame.height) / imageHeight;
-                const top = 1 - frame.y / imageHeight;
-                uvs.push(left, bottom, right, bottom, right, top, left, top);
-                const vertex = positions.length / 3 - 4;
-                indices.push(vertex, vertex + 1, vertex + 2, vertex, vertex + 2, vertex + 3);
+                this.pushTileQuad(buffers.positions, index % width, Math.floor(index / width));
+                buffers.uvs.push(...this.tileUvs(tile, sheet));
+                const vertex = buffers.positions.length / 3 - 4;
+                buffers.indices.push(vertex, vertex + 1, vertex + 2, vertex, vertex + 2, vertex + 3);
             }
         }
         const geometry = new THREE.BufferGeometry();
-        geometry.setAttribute('position', new THREE.Float32BufferAttribute(positions, 3));
-        geometry.setAttribute('uv', new THREE.Float32BufferAttribute(uvs, 2));
-        geometry.setIndex(new THREE.BufferAttribute(new Uint32Array(indices), 1));
+        geometry.setAttribute('position', new THREE.Float32BufferAttribute(buffers.positions, 3));
+        geometry.setAttribute('uv', new THREE.Float32BufferAttribute(buffers.uvs, 2));
+        geometry.setIndex(new THREE.BufferAttribute(new Uint32Array(buffers.indices), 1));
         mesh.geometry.dispose();
         mesh.geometry = geometry;
     }
+    /** The loaded sheet image's size, or one pixel per sheet cell until it arrives. */
+    sheetSize() {
+        const image = this.loadedTexture?.image;
+        return {
+            width: image?.width && image.width > 0 ? image.width : Math.max(1, this.cols),
+            height: image?.height && image.height > 0 ? image.height : Math.max(1, this.rows),
+        };
+    }
+    /** The four corners of a cell's quad, projected for the Game, on this layer's depth. */
+    pushTileQuad(positions, column, row) {
+        const size = this.cellSize;
+        const logicalCenterX = (column + 0.5) * size;
+        const logicalCenterY = (row + 0.5) * size;
+        const center = this.game.projection === 'isometric'
+            ? projectIsometric(logicalCenterX, logicalCenterY)
+            : { x: logicalCenterX, y: logicalCenterY };
+        const halfWidth = this.game.projection === 'isometric' ? size : size / 2;
+        const halfHeight = size / 2;
+        const z = this.layer * 0.01;
+        positions.push(center.x - halfWidth, center.y - halfHeight, z, center.x + halfWidth, center.y - halfHeight, z, center.x + halfWidth, center.y + halfHeight, z, center.x - halfWidth, center.y + halfHeight, z);
+    }
+    /** The UVs of a tile's sheet cell, in the quad's corner order. */
+    tileUvs(tile, sheet) {
+        const frame = sheetCell(sheet.width, sheet.height, this.cols, this.rows, tile, {
+            gridOffsetX: this.gridOffsetX,
+            gridOffsetY: this.gridOffsetY,
+            spacingX: this.spacingX,
+            spacingY: this.spacingY,
+            cellWidth: this.cellWidth,
+            cellHeight: this.cellHeight,
+        });
+        const left = frame.x / sheet.width;
+        const right = (frame.x + frame.width) / sheet.width;
+        const bottom = 1 - (frame.y + frame.height) / sheet.height;
+        const top = 1 - frame.y / sheet.height;
+        return [left, bottom, right, bottom, right, top, left, top];
+    }
     rebuildSolids() {
         if (!this.entity || !this.game)
             return;

package/dist/entity.js

@@ -22,13 +22,15 @@ export class Entity {
     }
     /** Keeps identity scenes zero-copy while projected scenes own a logical transform. */
     setProjected(projected) {
-        if (projected === (this.logicalPosition !== null))
-            return;
+        const logical = this.logicalPosition;
         if (projected) {
-            this.logicalPosition = this.node.position.clone();
+            if (logical === null)
+                this.logicalPosition = this.node.position.clone();
             return;
         }
-        this.node.position.copy(this.logicalPosition);
+        if (logical === null)
+            return;
+        this.node.position.copy(logical);
         this.logicalPosition = null;
     }
     get scale() {

package/dist/game-time.d.ts

@@ -1,5 +1,7 @@
 /** The closed set of named Penner curves a Tween can ease through. */
 export type EasingName = 'linear' | 'quadIn' | 'quadOut' | 'quadInOut' | 'cubicIn' | 'cubicOut' | 'cubicInOut' | 'sineInOut';
+/** A resolved easing: normalized progress in, eased progress out. */
+type EasingFn = (t: number) => number;
 /** What `after`/`every`/`tween` hand back: see CA-6. */
 export interface TimerHandle {
     /** Idempotent and silent, even on an already-inactive handle. */
@@ -59,6 +61,8 @@ export interface TweenOptions {
     /** Same as `TimerOptions.scope`: `'session'` survives a scene change, anything else means scene. */
     scope?: 'scene' | 'session';
 }
+/** Engine-internal (not re-exported from the package entry): also resolves Camera Effect easings. */
+export declare function resolveEasing(easing: EasingName | ((t: number) => number) | undefined): EasingFn | null;
 /**
  * Module-private key for the per-step advance pass. Not exported, so
  * `time[ADVANCE]()` cannot be spelled outside this file — `advanceGameTime`

package/dist/game-time.js

@@ -15,7 +15,8 @@ const EASINGS = {
     cubicInOut: (t) => (t < 0.5 ? 4 * t * t * t : 1 - ((-2 * t + 2) ** 3) / 2),
     sineInOut: (t) => -(Math.cos(Math.PI * t) - 1) / 2,
 };
-function resolveEasing(easing) {
+/** Engine-internal (not re-exported from the package entry): also resolves Camera Effect easings. */
+export function resolveEasing(easing) {
     if (easing === undefined)
         return EASINGS.linear;
     if (typeof easing === 'function')