lantern-engine 0.0.0-stage → 0.4.0

package/dist/types/rig/RigView.d.ts

@@ -0,0 +1,68 @@
+import { Container } from 'pixi.js';
+import type { TextureRegistry } from '../core/TextureRegistry.js';
+import type { Joints, Point, RigDef, RigPose } from './rigTypes.js';
+/** The parts a humanoid rig is drawn with, back to front in this order. */
+export declare const RIG_PARTS: readonly ["upperArmB", "forearmB", "thighB", "shinB", "torso", "thighF", "shinF", "head", "upperArmF", "forearmF"];
+export type RigPart = (typeof RIG_PARTS)[number];
+/**
+ * How one part looks. A textured part is an image drawn with its top-centre on the bone's root joint and turned to
+ * follow the bone (cut-out animation, any art style); a vector part is a capsule (limbs), a rounded box (torso) or a
+ * circle (head) in `color`.
+ */
+export interface PartSkin {
+    /** Texture key (and frame) in the stage's registry; leave out for a vector part. */
+    texture?: string;
+    frame?: string | number;
+    /** Stretch the image along the bone to the next joint instead of drawing it at its own size. */
+    stretch?: boolean;
+    /** Where on the image the root joint sits, as a share of its size (default 0.5, 0). */
+    anchorX?: number;
+    anchorY?: number;
+    /** Vector fill (default by part). */
+    color?: number;
+    /** Vector thickness in grid px (default the rig's `limbWidth`; the torso's width; the head's diameter). */
+    width?: number;
+    /** Vector outline colour, or null for none (default a dark outline). */
+    outline?: number | null;
+}
+export type RigSkin = Partial<Record<RigPart, PartSkin>>;
+export interface RigViewOptions {
+    /** World px per grid px (default 1). */
+    scale?: number;
+    /** Head radius in grid px (default 5) and how far above the chest point its centre sits (default 5.5). */
+    headRadius?: number;
+    headRise?: number;
+    /** A broader build: shoulders set wider. */
+    bulky?: boolean;
+}
+/**
+ * A character drawn from a rig pose: give it a pose each frame (`setPose`, from a `PosePlayer`) and it places every
+ * part. The container's origin is the character's feet (bottom centre of the rig's frame); `facing` mirrors it.
+ */
+export declare class RigView extends Container {
+    private readonly def;
+    private readonly skin;
+    private readonly skeleton;
+    private readonly sprites;
+    private readonly layers;
+    private joints;
+    private curl;
+    private readonly scaleGrid;
+    private readonly headRadius;
+    private readonly headRise;
+    private readonly bulky;
+    constructor(def: RigDef, skin?: RigSkin, textures?: TextureRegistry, options?: RigViewOptions);
+    /** 1 faces right, -1 faces left. */
+    set facing(dir: 1 | -1);
+    get facing(): 1 | -1;
+    /** The joints of the last pose, in grid px of the rig's frame (for attaching a held item, an effect). */
+    get lastJoints(): Joints | null;
+    /** Where a joint of the last pose is in this view's parent, in world px. */
+    jointInParent(name: keyof Omit<Joints, 'forearm'>): Point | null;
+    setPose(pose: RigPose): this;
+    destroy(options?: Parameters<Container['destroy']>[0]): void;
+    private place;
+    /** The two points a part spans: a limb's joints, the torso from chest to hips, the head's centre (twice). */
+    private ends;
+}
+//# sourceMappingURL=RigView.d.ts.map

package/dist/types/rig/RigView.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RigView.d.ts","sourceRoot":"","sources":["../../../src/rig/RigView.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAoB,MAAM,SAAS,CAAC;AACtD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAE/D,OAAO,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAEjE,2EAA2E;AAC3E,eAAO,MAAM,SAAS,oHAAqH,CAAC;AAC5I,MAAM,MAAM,OAAO,GAAG,CAAC,OAAO,SAAS,CAAC,CAAC,MAAM,CAAC,CAAC;AAEjD;;;;GAIG;AACH,MAAM,WAAW,QAAQ;IACvB,oFAAoF;IACpF,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACxB,gGAAgG;IAChG,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,uFAAuF;IACvF,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,qCAAqC;IACrC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,2GAA2G;IAC3G,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,wEAAwE;IACxE,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CACzB;AAED,MAAM,MAAM,OAAO,GAAG,OAAO,CAAC,MAAM,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAC,CAAC;AAEzD,MAAM,WAAW,cAAc;IAC7B,wCAAwC;IACxC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,0GAA0G;IAC1G,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,4CAA4C;IAC5C,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAoCD;;;GAGG;AACH,qBAAa,OAAQ,SAAQ,SAAS;IAYlC,OAAO,CAAC,QAAQ,CAAC,GAAG;IACpB,OAAO,CAAC,QAAQ,CAAC,IAAI;IAZvB,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAW;IACpC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA8B;IACtD,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAiC;IACxD,OAAO,CAAC,MAAM,CAAuB;IACrC,OAAO,CAAC,IAAI,CAA+B;IAC3C,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;IACnC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAS;IACpC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAS;IAClC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAU;gBAGb,GAAG,EAAE,MAAM,EACX,IAAI,GAAE,OAAY,EACnC,QAAQ,CAAC,EAAE,eAAe,EAC1B,OAAO,GAAE,cAAmB;IA8B9B,oCAAoC;IACpC,IAAI,MAAM,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,CAAC,EAErB;IAED,IAAI,MAAM,IAAI,CAAC,GAAG,CAAC,CAAC,CAEnB;IAED,yGAAyG;IACzG,IAAI,UAAU,IAAI,MAAM,GAAG,IAAI,CAE9B;IAED,4EAA4E;IAC5E,aAAa,CAAC,IAAI,EAAE,MAAM,IAAI,CAAC,MAAM,EAAE,SAAS,CAAC,GAAG,KAAK,GAAG,IAAI;IAMhE,OAAO,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI;IAQnB,OAAO,CAAC,OAAO,CAAC,EAAE,UAAU,CAAC,SAAS,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI;IAIrE,OAAO,CAAC,KAAK;IAqDb,6GAA6G;IAC7G,OAAO,CAAC,IAAI;CASb"}

package/dist/types/rig/Skeleton.d.ts

@@ -0,0 +1,14 @@
+import type { Joints, Limb, Point, RigDef, RigPose } from './rigTypes.js';
+/** Turns a pose (bone angles and lengths) into joint positions on the character's 20x24 grid. */
+export declare class Skeleton {
+    private readonly def;
+    constructor(def: RigDef);
+    solve(pose: RigPose, bulky?: boolean): Joints;
+    /**
+     * Elbow, wrist and forearm direction of the front arm (or of its motion smear) hung from `shoulder`. The fist keeps
+     * the frame's last column for its outline: an arm reaching past that (a swing, a thrust, a draw on a bulky body) is
+     * pulled back whole, so the forearm — and the weapon laid along it — keeps its angle.
+     */
+    frontArm(shoulder: Point, limb: Limb): [Point, Point, number];
+}
+//# sourceMappingURL=Skeleton.d.ts.map

package/dist/types/rig/Skeleton.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Skeleton.d.ts","sourceRoot":"","sources":["../../../src/rig/Skeleton.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAkBvE,iGAAiG;AACjG,qBAAa,QAAQ;IACnB,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAS;gBAEjB,GAAG,EAAE,MAAM;IAIvB,KAAK,CAAC,IAAI,EAAE,OAAO,EAAE,KAAK,UAAQ,GAAG,MAAM;IAkB3C;;;;OAIG;IACH,QAAQ,CAAC,QAAQ,EAAE,KAAK,EAAE,IAAI,EAAE,IAAI,GAAG,CAAC,KAAK,EAAE,KAAK,EAAE,MAAM,CAAC;CAM9D"}

package/dist/types/rig/humanoid.d.ts

@@ -0,0 +1,4 @@
+import type { RigDef } from './rigTypes.js';
+/** The proportions of the built-in 20×24 humanoid: chest, shoulders, hips and limb width. */
+export declare const HUMANOID_RIG: RigDef;
+//# sourceMappingURL=humanoid.d.ts.map

package/dist/types/rig/humanoid.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"humanoid.d.ts","sourceRoot":"","sources":["../../../src/rig/humanoid.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AAGzC,6FAA6F;AAC7F,eAAO,MAAM,YAAY,EAAE,MAAsB,CAAC"}

package/dist/types/rig/humanoidPoses.d.ts

@@ -0,0 +1,117 @@
+import type { RigPose } from './rigTypes.js';
+/**
+ * The built-in humanoid's pose library: 72 poses for `HUMANOID_RIG`, made for a 20×24 character facing right, and
+ * clips that string them into motion. Use them as they are, mix them (`overlay`, `upperOver`), or as the starting
+ * point for your own.
+ */
+export declare const HUMANOID_POSES: Readonly<Record<string, RigPose>>;
+/** Ready-made clips over `HUMANOID_POSES`. Looping clips blend from their last pose back into the first. */
+export declare const HUMANOID_CLIPS: {
+    idle: {
+        poses: string[];
+        fps: number;
+    };
+    walk: {
+        poses: string[];
+        fps: number;
+    };
+    run: {
+        poses: string[];
+        fps: number;
+    };
+    roll: {
+        poses: string[];
+        fps: number;
+        loop: false;
+        blend: false;
+    };
+    dash: {
+        poses: string[];
+        fps: number;
+        loop: false;
+    };
+    hurt: {
+        poses: string[];
+        fps: number;
+        loop: false;
+    };
+    dizzy: {
+        poses: string[];
+        fps: number;
+    };
+    crouch: {
+        poses: string[];
+        fps: number;
+        loop: false;
+    };
+    kneel: {
+        poses: string[];
+        fps: number;
+        loop: false;
+    };
+    sit: {
+        poses: string[];
+        fps: number;
+        loop: false;
+    };
+    sitGround: {
+        poses: string[];
+        fps: number;
+        loop: false;
+    };
+    pick: {
+        poses: string[];
+        fps: number;
+        loop: false;
+    };
+    lookBack: {
+        poses: string[];
+        fps: number;
+        loop: false;
+    };
+    stretch: {
+        poses: string[];
+        fps: number;
+        loop: false;
+    };
+    cheer: {
+        poses: string[];
+        fps: number;
+        loop: false;
+    };
+    wave: {
+        poses: string[];
+        fps: number;
+    };
+    dance: {
+        poses: string[];
+        fps: number;
+    };
+    slash: {
+        poses: string[];
+        durations: number[];
+        loop: false;
+    };
+    thrust: {
+        poses: string[];
+        durations: number[];
+        loop: false;
+    };
+    overhead: {
+        poses: string[];
+        durations: number[];
+        loop: false;
+    };
+    cast: {
+        poses: string[];
+        durations: number[];
+        loop: false;
+    };
+    throw: {
+        poses: string[];
+        durations: number[];
+        loop: false;
+    };
+};
+export type HumanoidClip = keyof typeof HUMANOID_CLIPS;
+//# sourceMappingURL=humanoidPoses.d.ts.map

package/dist/types/rig/humanoidPoses.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"humanoidPoses.d.ts","sourceRoot":"","sources":["../../../src/rig/humanoidPoses.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAI1C;;;;GAIG;AACH,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAA+C,CAAC;AAI7G,4GAA4G;AAC5G,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuBS,CAAC;AAErC,MAAM,MAAM,YAAY,GAAG,MAAM,OAAO,cAAc,CAAC"}

package/dist/types/rig/poseMath.d.ts

@@ -0,0 +1,14 @@
+import type { RigPose } from './rigTypes.js';
+/**
+ * The in-between of two poses at `k` (0 = a, 1 = b): bones turn along the shortest way and stretch, offsets slide.
+ * What cannot be in between (face, cape trail, the curled torso) stays `a`'s until `b` is reached.
+ */
+export declare function blendPose(a: RigPose, b: RigPose, k: number): RigPose;
+/** `top` laid over `base`: every field `top` sets wins. */
+export declare function overlay(base: RigPose, top: RigPose): RigPose;
+/**
+ * An action's upper body over a moving (or seated) body: the arms, head and face act while the legs keep the gait.
+ * The chest takes both bobs, but rises at most a pixel so a tall hat keeps its headroom.
+ */
+export declare function upperOver(action: RigPose, legs: RigPose): RigPose;
+//# sourceMappingURL=poseMath.d.ts.map

package/dist/types/rig/poseMath.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"poseMath.d.ts","sourceRoot":"","sources":["../../../src/rig/poseMath.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAQ,OAAO,EAAE,MAAM,YAAY,CAAC;AAwBhD;;;GAGG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,MAAM,GAAG,OAAO,CAkBpE;AAED,2DAA2D;AAC3D,wBAAgB,OAAO,CAAC,IAAI,EAAE,OAAO,EAAE,GAAG,EAAE,OAAO,GAAG,OAAO,CAI5D;AAED;;;GAGG;AACH,wBAAgB,SAAS,CAAC,MAAM,EAAE,OAAO,EAAE,IAAI,EAAE,OAAO,GAAG,OAAO,CAYjE"}

package/dist/types/rig/rigTypes.d.ts

@@ -0,0 +1,82 @@
+/**
+ * A limb of two bones: [upper angle, upper length, lower angle relative to the upper, lower length]. Angles in
+ * degrees in sprite space of a character facing right (0 = forward, 90 = down), lengths in grid pixels.
+ */
+export type Limb = [number, number, number, number];
+export type Face = 'blink' | 'happy' | 'tired' | 'dizzy';
+/**
+ * A pose of the humanoid rig (a JSON object of bone angles). Every field is optional: a pose that leaves one
+ * out takes it from the pose it is laid over (a guard only moves the weapon arm, an attack keeps the running legs).
+ */
+export interface RigPose {
+    /** Pixels the chest (torso, head, shoulders) sits below its rest height; negative rises. */
+    by?: number;
+    armF?: Limb;
+    armB?: Limb;
+    legF?: Limb;
+    legB?: Limb;
+    /** Offset of both hips from their rest place. */
+    hipDx?: number;
+    hipDy?: number;
+    /** Offset of the head from the chest. */
+    headDx?: number;
+    headDy?: number;
+    face?: Face;
+    /** The head faces backwards. */
+    lookBack?: boolean;
+    /** Pixels the cape and ponytail stream behind while running. */
+    trail?: number;
+    /** Chest expansion and delayed cloth sway of the breathing cycle. */
+    breathe?: boolean;
+    sway?: number;
+    /** The far arm crosses in front of the body (drawing a bow with both hands). */
+    armBFront?: boolean;
+    /** Arm the front arm just swept through, left as a translucent smear. */
+    smearArm?: Limb;
+    /** Tumbling: the torso is a curled ball centred here (grid pixels) instead of standing. */
+    curl?: [number, number];
+}
+/** The rig's proportions (`rig/humanoid.json`), in grid pixels of the 20x24 character frame. */
+export interface RigDef {
+    /** Art pixels per grid pixel of the rendered body. */
+    scale: number;
+    width: number;
+    height: number;
+    /** Top centre of the torso at rest. */
+    chest: [number, number];
+    shoulderF: [number, number];
+    shoulderB: [number, number];
+    /** How much further out both shoulders sit on a bulky body. */
+    bulkyShoulder: number;
+    hipF: [number, number];
+    hipB: [number, number];
+    /** Thickness of the arms and legs. */
+    limbWidth: number;
+    /** Brightness of the far leg and the far arm, which stand in the torso's shadow. */
+    backShade: number;
+    backArmShade: number;
+}
+export interface Point {
+    x: number;
+    y: number;
+}
+/** Joint positions of one solved pose, in grid pixels (fractional). */
+export interface Joints {
+    chest: Point;
+    head: Point;
+    shoulderF: Point;
+    elbowF: Point;
+    wristF: Point;
+    shoulderB: Point;
+    elbowB: Point;
+    wristB: Point;
+    hipF: Point;
+    kneeF: Point;
+    ankleF: Point;
+    hipB: Point;
+    kneeB: Point;
+    ankleB: Point;
+    /** Direction the front forearm points (radians, sprite space facing right): the line a held weapon follows. */
+    forearm: number;
+}
+//# sourceMappingURL=rigTypes.d.ts.map

package/dist/types/rig/rigTypes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rigTypes.d.ts","sourceRoot":"","sources":["../../../src/rig/rigTypes.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,MAAM,MAAM,IAAI,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;AAEpD,MAAM,MAAM,IAAI,GAAG,OAAO,GAAG,OAAO,GAAG,OAAO,GAAG,OAAO,CAAC;AAEzD;;;GAGG;AACH,MAAM,WAAW,OAAO;IACtB,4FAA4F;IAC5F,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,IAAI,CAAC,EAAE,IAAI,CAAC;IACZ,IAAI,CAAC,EAAE,IAAI,CAAC;IACZ,IAAI,CAAC,EAAE,IAAI,CAAC;IACZ,IAAI,CAAC,EAAE,IAAI,CAAC;IACZ,iDAAiD;IACjD,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,yCAAyC;IACzC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,IAAI,CAAC;IACZ,gCAAgC;IAChC,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,gEAAgE;IAChE,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,qEAAqE;IACrE,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,gFAAgF;IAChF,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,yEAAyE;IACzE,QAAQ,CAAC,EAAE,IAAI,CAAC;IAChB,2FAA2F;IAC3F,IAAI,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACzB;AAED,gGAAgG;AAChG,MAAM,WAAW,MAAM;IACrB,sDAAsD;IACtD,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,uCAAuC;IACvC,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACxB,SAAS,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC5B,SAAS,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC5B,+DAA+D;IAC/D,aAAa,EAAE,MAAM,CAAC;IACtB,IAAI,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACvB,IAAI,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACvB,sCAAsC;IACtC,SAAS,EAAE,MAAM,CAAC;IAClB,oFAAoF;IACpF,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,KAAK;IACpB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX;AAED,uEAAuE;AACvE,MAAM,WAAW,MAAM;IACrB,KAAK,EAAE,KAAK,CAAC;IACb,IAAI,EAAE,KAAK,CAAC;IACZ,SAAS,EAAE,KAAK,CAAC;IACjB,MAAM,EAAE,KAAK,CAAC;IACd,MAAM,EAAE,KAAK,CAAC;IACd,SAAS,EAAE,KAAK,CAAC;IACjB,MAAM,EAAE,KAAK,CAAC;IACd,MAAM,EAAE,KAAK,CAAC;IACd,IAAI,EAAE,KAAK,CAAC;IACZ,KAAK,EAAE,KAAK,CAAC;IACb,MAAM,EAAE,KAAK,CAAC;IACd,IAAI,EAAE,KAAK,CAAC;IACZ,KAAK,EAAE,KAAK,CAAC;IACb,MAAM,EAAE,KAAK,CAAC;IACd,+GAA+G;IAC/G,OAAO,EAAE,MAAM,CAAC;CACjB"}

package/dist/types/settings.d.ts

@@ -0,0 +1,25 @@
+/**
+ * The few player settings the engine itself reads. A game keeps its own settings store and mirrors these fields
+ * into this one (`engineSettings.set`) whenever they change; the engine never reads the game's store.
+ */
+export interface EngineSettings {
+    /** Fewer particles and lighter effects. */
+    reducedFx: boolean;
+    /** Turns off everything that only costs battery: transient lights, heavy particles. */
+    batterySaver: boolean;
+    /** Short-lived lights a fight throws into the dark (`pixel/lights.ts`). */
+    combatLights: boolean;
+    /** 0–1, the combat sounds' volume (`audio/SoundEngine.ts`). */
+    sfxVolume: number;
+    /** 0–1, the music's volume. */
+    musicVolume: number;
+}
+export type SettingsListener = (s: EngineSettings) => void;
+/** Same shape as the zustand stores the game used (`getState`, `subscribe`), so moved code reads it unchanged. */
+export declare const engineSettings: {
+    getState(): EngineSettings;
+    set(patch: Partial<EngineSettings>): void;
+    subscribe(listener: SettingsListener): () => void;
+    reset(): void;
+};
+//# sourceMappingURL=settings.d.ts.map

package/dist/types/settings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"settings.d.ts","sourceRoot":"","sources":["../../src/settings.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,MAAM,WAAW,cAAc;IAC7B,2CAA2C;IAC3C,SAAS,EAAE,OAAO,CAAC;IACnB,uFAAuF;IACvF,YAAY,EAAE,OAAO,CAAC;IACtB,2EAA2E;IAC3E,YAAY,EAAE,OAAO,CAAC;IACtB,+DAA+D;IAC/D,SAAS,EAAE,MAAM,CAAC;IAClB,+BAA+B;IAC/B,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,EAAE,cAAc,KAAK,IAAI,CAAC;AAa3D,kHAAkH;AAClH,eAAO,MAAM,cAAc;gBACb,cAAc;eAGf,OAAO,CAAC,cAAc,CAAC,GAAG,IAAI;wBAIrB,gBAAgB,GAAG,MAAM,IAAI;aAIxC,IAAI;CAGd,CAAC"}

package/dist/types/tilemap/TilemapView.d.ts

@@ -0,0 +1,42 @@
+import { Container } from 'pixi.js';
+import type { Stage } from '../core/Stage.js';
+import { type TileMap, type Tileset } from './tiled.js';
+export interface TilemapViewOptions {
+    /** The texture key holding a tileset's image (loaded with `AssetLoader.image`, or painted). Default: `tileset.name`. */
+    textureFor?: (tileset: Tileset) => string;
+    /** Tiles per chunk side (default 32): each chunk is painted once into a texture of its own. */
+    chunkTiles?: number;
+    /** Only these tile layers, by name; default every visible tile layer. */
+    layers?: string[];
+    /**
+     * Depth of the first layer in the world layer; each layer after it one higher. Bodies are usually drawn at their y,
+     * so the default keeps the map under every one of them. A layer with a numeric `depth` property is drawn there
+     * instead (a roof layer over the bodies: `depth` = 1e6).
+     */
+    baseDepth?: number;
+    /** Where the layers go (default the stage's world layer); a scene passes its `root` so they leave with it. */
+    parent?: Container;
+}
+/**
+ * Draws a Tiled map's tile layers. Each layer is cut into chunks painted once into textures; a frame only toggles
+ * which chunks are in view (`update`), so a map of any size costs a handful of sprites a frame.
+ *
+ * Animated tiles are drawn on their first frame.
+ */
+export declare class TilemapView {
+    private readonly stage;
+    readonly map: TileMap;
+    /** One container per drawn tile layer, by name, each at its own depth among the bodies. */
+    readonly layers: Map<string, Container<import("pixi.js").ContainerChild>>;
+    private readonly chunks;
+    private readonly id;
+    constructor(stage: Stage, map: TileMap, options?: TilemapViewOptions);
+    /** Shows only the chunks in the camera's view (plus a margin in world px). Call once a frame. */
+    update(margin?: number): void;
+    /** World size of the map in px. */
+    get widthPx(): number;
+    get heightPx(): number;
+    destroy(): void;
+    private paintChunk;
+}
+//# sourceMappingURL=TilemapView.d.ts.map

package/dist/types/tilemap/TilemapView.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TilemapView.d.ts","sourceRoot":"","sources":["../../../src/tilemap/TilemapView.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAU,MAAM,SAAS,CAAC;AAC5C,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,EAA4D,KAAK,OAAO,EAAE,KAAK,OAAO,EAAE,MAAM,SAAS,CAAC;AAE/G,MAAM,WAAW,kBAAkB;IACjC,wHAAwH;IACxH,UAAU,CAAC,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,MAAM,CAAC;IAC1C,+FAA+F;IAC/F,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,yEAAyE;IACzE,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAClB;;;;OAIG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,8GAA8G;IAC9G,MAAM,CAAC,EAAE,SAAS,CAAC;CACpB;AAID;;;;;GAKG;AACH,qBAAa,WAAW;IAOpB,OAAO,CAAC,QAAQ,CAAC,KAAK;IACtB,QAAQ,CAAC,GAAG,EAAE,OAAO;IAPvB,2FAA2F;IAC3F,QAAQ,CAAC,MAAM,2DAAgC;IAC/C,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAqF;IAC5G,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAc;gBAGd,KAAK,EAAE,KAAK,EACpB,GAAG,EAAE,OAAO,EACrB,OAAO,GAAE,kBAAuB;IA0BlC,iGAAiG;IACjG,MAAM,CAAC,MAAM,SAAK,GAAG,IAAI;IAOzB,mCAAmC;IACnC,IAAI,OAAO,IAAI,MAAM,CAEpB;IAED,IAAI,QAAQ,IAAI,MAAM,CAErB;IAED,OAAO,IAAI,IAAI;IAOf,OAAO,CAAC,UAAU;CA0CnB"}

package/dist/types/tilemap/collision.d.ts

@@ -0,0 +1,16 @@
+import { type CollisionGrid, type CollisionGridOptions } from '../net/movement.js';
+import { type TileMap } from './tiled.js';
+export interface TiledCollisionOptions extends Omit<CollisionGridOptions, 'ground'> {
+    /**
+     * What makes a cell solid:
+     * - a layer name: every non-empty cell of that tile layer is solid (a hidden "collision" layer is the usual way);
+     * - `{ property }`: a cell is solid when its tile has that custom property set to true, on any tile layer.
+     * Default: the layer named "collision" if there is one, else tiles with a `solid` property.
+     */
+    solid?: string | {
+        property: string;
+    };
+}
+/** The `CollisionGrid` of a Tiled map, for `stepMover`; cells are the map's tiles. */
+export declare function collisionFromTiled(map: TileMap, options?: TiledCollisionOptions): CollisionGrid;
+//# sourceMappingURL=collision.d.ts.map

package/dist/types/tilemap/collision.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"collision.d.ts","sourceRoot":"","sources":["../../../src/tilemap/collision.ts"],"names":[],"mappings":"AAAA,OAAO,EAAuB,KAAK,aAAa,EAAE,KAAK,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AACrG,OAAO,EAAiB,KAAK,OAAO,EAAE,MAAM,SAAS,CAAC;AAEtD,MAAM,WAAW,qBAAsB,SAAQ,IAAI,CAAC,oBAAoB,EAAE,QAAQ,CAAC;IACjF;;;;;OAKG;IACH,KAAK,CAAC,EAAE,MAAM,GAAG;QAAE,QAAQ,EAAE,MAAM,CAAA;KAAE,CAAC;CACvC;AAED,sFAAsF;AACtF,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,OAAO,EAAE,OAAO,GAAE,qBAA0B,GAAG,aAAa,CAsBnG"}

package/dist/types/tilemap/tiled.d.ts

@@ -0,0 +1,104 @@
+/**
+ * Maps made in Tiled (https://www.mapeditor.org), read from its JSON format (`.tmj`, or `.json`). Supported:
+ * orthogonal, finite maps; tile layers as CSV arrays or uncompressed base64; object layers; group layers (flattened);
+ * custom properties; flipped tiles. Not supported (refused with a message saying so): infinite maps, compressed layer
+ * data, isometric and hexagonal maps, external `.tsj` tilesets (embed them: Map → Embed Tilesets).
+ *
+ * Pure: no Pixi, no DOM, so a server can read the same map for collision.
+ */
+/** The three flags Tiled keeps in a gid's high bits; the rest is the tile id. */
+export declare const FLIP_H = 2147483648;
+export declare const FLIP_V = 1073741824;
+export declare const FLIP_D = 536870912;
+export type TiledPropertyValue = string | number | boolean;
+export type Properties = Record<string, TiledPropertyValue>;
+export interface TileLayer {
+    kind: 'tiles';
+    name: string;
+    /** Row-major gids (0 = empty), flip flags kept. Read the tile id with `gidOf`. */
+    data: Uint32Array;
+    visible: boolean;
+    opacity: number;
+    offsetX: number;
+    offsetY: number;
+    properties: Properties;
+}
+export interface MapObject {
+    id: number;
+    name: string;
+    type: string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    rotation: number;
+    /** A tile object's gid, if it is one. */
+    gid?: number;
+    point: boolean;
+    ellipse: boolean;
+    polygon?: {
+        x: number;
+        y: number;
+    }[];
+    properties: Properties;
+}
+export interface ObjectLayer {
+    kind: 'objects';
+    name: string;
+    objects: MapObject[];
+    visible: boolean;
+    properties: Properties;
+}
+export type MapLayer = TileLayer | ObjectLayer;
+export interface Tileset {
+    name: string;
+    firstGid: number;
+    /** The image's path as written in the map, relative to the map file. */
+    image: string;
+    imageWidth: number;
+    imageHeight: number;
+    tileWidth: number;
+    tileHeight: number;
+    columns: number;
+    tileCount: number;
+    margin: number;
+    spacing: number;
+    /** Per local tile id: its custom properties. */
+    tileProperties: Map<number, Properties>;
+    /** Per local tile id: an animation (local tile ids and how long each shows, ms). */
+    animations: Map<number, {
+        tileId: number;
+        duration: number;
+    }[]>;
+    properties: Properties;
+}
+export interface TileMap {
+    width: number;
+    height: number;
+    tileWidth: number;
+    tileHeight: number;
+    layers: MapLayer[];
+    tilesets: Tileset[];
+    properties: Properties;
+    backgroundColor?: string;
+}
+/** The tile id of a gid, without its flip flags. */
+export declare const gidOf: (raw: number) => number;
+/** Which tileset a gid belongs to, and the tile's id inside it; null for an empty cell or an unknown gid. */
+export declare function tileAt(map: TileMap, raw: number): {
+    tileset: Tileset;
+    local: number;
+} | null;
+/** Where tile `local` sits in its tileset image. */
+export declare function tileRect(ts: Tileset, local: number): {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+};
+export declare function layerByName(map: TileMap, name: string): MapLayer | undefined;
+/** Every object of every object layer (optionally only those of one `type`/class). */
+export declare function objectsOf(map: TileMap, type?: string): MapObject[];
+/** Reads a Tiled JSON map (already parsed with `JSON.parse`). Throws a `Tiled map: …` error saying what is wrong. */
+export declare function parseTiled(json: unknown): TileMap;
+//# sourceMappingURL=tiled.d.ts.map

package/dist/types/tilemap/tiled.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tiled.d.ts","sourceRoot":"","sources":["../../../src/tilemap/tiled.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,84 @@
 {
   "name": "lantern-engine",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.4.0",
+  "description": "A 2D game engine on PixiJS 8 for any art style: scenes and a fast ECS, a fixed-step loop, asset loading, Tiled maps, sprite animation, input actions, camera follow, audio and deterministic, server-replayable movement, plus Dither, an optional pixel-art module (pixel-perfect effects, dithered lighting).",
+  "type": "module",
+  "types": "./dist/types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/types/index.d.ts",
+      "import": "./dist/lantern-engine.js"
+    },
+    "./pixel": {
+      "types": "./dist/types/pixel/index.d.ts",
+      "import": "./dist/pixel.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "scripts": {
+    "dev": "vite",
+    "build": "npm run clean && vite build && tsc -p tsconfig.build.json && node scripts/fix-dts-extensions.mjs",
+    "clean": "node -e \"require('fs').rmSync('dist',{recursive:true,force:true})\"",
+    "typecheck": "tsc --noEmit && tsc -p tsconfig.test.json",
+    "test": "node scripts/test.mjs",
+    "check": "npm run typecheck && npm test && npm run build",
+    "prepublishOnly": "npm run check",
+    "bench": "node --expose-gc --import tsx bench/ecs.bench.ts",
+    "example:server": "tsx examples/multiplayer/server.ts",
+    "docs:examples": "node scripts/build-examples.mjs",
+    "docs:dev": "npm run docs:prepare && vitepress dev docs",
+    "docs:build": "npm run docs:prepare && npm run docs:examples && vitepress build docs",
+    "docs:preview": "vitepress preview docs",
+    "docs:prepare": "typedoc && node -e \"require('fs').copyFileSync('CHANGELOG.md','docs/changelog.md')\""
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "@types/ws": "^8.18.2",
+    "pixi.js": "^8.21.0",
+    "tsx": "^4.20.5",
+    "typedoc": "^0.28.20",
+    "typedoc-plugin-markdown": "^4.13.1",
+    "typedoc-vitepress-theme": "^1.1.4",
+    "typescript": "^5.9.2",
+    "vite": "^7.1.4",
+    "vitepress": "^1.6.4",
+    "ws": "^8.22.0"
+  },
+  "license": "MIT",
+  "keywords": [
+    "game-engine",
+    "2d",
+    "pixijs",
+    "ecs",
+    "tiled",
+    "pixel-art",
+    "gamedev",
+    "multiplayer",
+    "typescript"
+  ],
+  "sideEffects": [
+    "./dist/*.js"
+  ],
+  "module": "./dist/lantern-engine.js",
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE",
+    "CHANGELOG.md"
+  ],
+  "engines": {
+    "node": ">=22"
+  },
+  "peerDependencies": {
+    "pixi.js": "^8.6.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Phadec/lantern-engine.git"
+  },
+  "homepage": "https://phadec.github.io/lantern-engine/",
+  "bugs": {
+    "url": "https://github.com/Phadec/lantern-engine/issues"
+  },
+  "author": "Phadec"
+}