@datamoc/mw_games 0.1.1

package/dist/roguelike/Scheduler.js

@@ -0,0 +1,82 @@
+/**
+ * Whose turn it is.
+ *
+ * Not "everyone moves once per turn": each actor has a *speed*, and an action costs time
+ * scaled by it. A hasted creature gets two moves to your one, a heavy weapon costs more
+ * than a dagger, and a slowed one loses turns — all of which fall out of one number rather
+ * than needing special cases.
+ *
+ * The queue is ordered by the time at which each actor next acts. `now` only ever moves
+ * forward, so effects that expire can be timestamped against it.
+ */
+export class Scheduler {
+    constructor() {
+        this.entries = [];
+        this.sequence = 0;
+        /** the current time; advances to each actor's turn as it comes up */
+        this.now = 0;
+    }
+    get size() {
+        return this.entries.length;
+    }
+    get actors() {
+        return this.entries.map((entry) => entry.actor);
+    }
+    has(actor) {
+        return this.entries.some((entry) => entry.actor === actor);
+    }
+    /**
+     * Puts an actor in the queue.
+     *
+     * @param delay time before its first turn. Spawning a monster with a small random delay
+     * stops a room full of them from acting in lockstep.
+     */
+    add(actor, delay = 0) {
+        this.entries.push({ actor, time: this.now + delay, sequence: this.sequence++ });
+        this.sort();
+    }
+    remove(actor) {
+        const index = this.entries.findIndex((entry) => entry.actor === actor);
+        if (index !== -1)
+            this.entries.splice(index, 1);
+    }
+    clear() {
+        this.entries.length = 0;
+        this.now = 0;
+        this.sequence = 0;
+    }
+    /** whoever acts next, without removing them; time advances to their turn */
+    peek() {
+        const next = this.entries[0];
+        if (!next)
+            return null;
+        //time only moves forward, never back to an entry scheduled in the past
+        this.now = Math.max(this.now, next.time);
+        return next.actor;
+    }
+    /**
+     * Charges the current actor for what it did, and hands the turn on.
+     *
+     * @param cost time the action took at speed 1; divided by the actor's speed
+     */
+    spend(cost) {
+        const entry = this.entries[0];
+        if (!entry)
+            return;
+        const speed = entry.actor.speed ?? 1;
+        entry.time = this.now + cost / (speed > 0 ? speed : 1);
+        //a fresh sequence number, so an actor that just acted goes behind anyone tied with it
+        entry.sequence = this.sequence++;
+        this.sort();
+    }
+    /** the time at which an actor next acts, for a debug view or an interface */
+    timeOf(actor) {
+        return this.entries.find((entry) => entry.actor === actor)?.time ?? null;
+    }
+    sort() {
+        //few actors are ever queued, so a sort per action is cheaper than a heap and far
+        //easier to reason about; swap it out if a level ever holds thousands
+        this.entries.sort((a, b) => a.time - b.time || a.sequence - b.sequence);
+    }
+}
+//# sourceMappingURL=Scheduler.js.map

package/dist/roguelike/Scheduler.js.map

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

package/dist/roguelike/Secrets.d.ts

@@ -0,0 +1,44 @@
+import type { Level } from './Level.ts';
+/**
+ * A cell that renders and blocks like its surroundings until revealed.
+ *
+ * The concealment itself is just terrain: `conceal` writes the disguise kind straight into
+ * the `Level`, so a secret door already passes every `passable`/`transparent` check as
+ * whatever it is disguised as - a wall that cannot be walked through or seen past, a floor
+ * that can. Nothing in `FieldOfView` or `Pathfinder` needs to know secrets exist. What this
+ * class remembers is the other half: which cells have a secret at all, and what they turn
+ * into once discovered - a secret door swapping to a passable, transparent kind; a trap
+ * staying passable but becoming *visibly* a trap.
+ *
+ * Discovery itself is a game's call, not this class's: a search action rolling against a
+ * distance, a trap firing the moment a creature steps onto it, a wand of revealing. This
+ * only does the bookkeeping once that decision has been made.
+ */
+export declare class Secrets {
+    private level;
+    private revealedKind;
+    private discovered;
+    constructor(level: Level);
+    /** hides a cell as `disguise`, remembering that it becomes `revealed` once discovered */
+    conceal(x: number, y: number, disguise: number, revealed: number): void;
+    /** a cell with a secret, still hidden - what a search action should be rolling against */
+    isSecret(x: number, y: number): boolean;
+    isDiscovered(x: number, y: number): boolean;
+    /**
+     * Swaps a concealed cell to its revealed kind.
+     *
+     * @returns whether there was anything to discover - false for a cell with no secret, or
+     * one already found, so a caller can tell a real discovery from a wasted search
+     */
+    discover(x: number, y: number): boolean;
+    toJSON(): {
+        revealed: [number, number][];
+        discovered: number[];
+    };
+    /** rebuilds secrets from save data onto a (separately restored) level */
+    static fromJSON(level: Level, data: {
+        revealed: [number, number][];
+        discovered: number[];
+    }): Secrets;
+}
+//# sourceMappingURL=Secrets.d.ts.map

package/dist/roguelike/Secrets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Secrets.d.ts","sourceRoot":"","sources":["../../src/roguelike/Secrets.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAExC;;;;;;;;;;;;;;GAcG;AACH,qBAAa,OAAO;IACnB,OAAO,CAAC,KAAK,CAAQ;IACrB,OAAO,CAAC,YAAY,CAA6B;IACjD,OAAO,CAAC,UAAU,CAAqB;IAEvC,YAAY,KAAK,EAAE,KAAK,EAEvB;IAED,yFAAyF;IACzF,OAAO,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI,CAKtE;IAED,0FAA0F;IAC1F,QAAQ,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,OAAO,CAGtC;IAED,YAAY,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,OAAO,CAE1C;IAED;;;;;OAKG;IACH,QAAQ,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,OAAO,CAOtC;IAED,MAAM,IAAI;QAAE,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,CAAC;QAAC,UAAU,EAAE,MAAM,EAAE,CAAA;KAAE,CAE/D;IAED,yEAAyE;IACzE,MAAM,CAAC,QAAQ,CAAC,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE;QAAE,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,CAAC;QAAC,UAAU,EAAE,MAAM,EAAE,CAAA;KAAE,GAAG,OAAO,CAKnG;CACD"}

package/dist/roguelike/Secrets.js

@@ -0,0 +1,64 @@
+/**
+ * A cell that renders and blocks like its surroundings until revealed.
+ *
+ * The concealment itself is just terrain: `conceal` writes the disguise kind straight into
+ * the `Level`, so a secret door already passes every `passable`/`transparent` check as
+ * whatever it is disguised as - a wall that cannot be walked through or seen past, a floor
+ * that can. Nothing in `FieldOfView` or `Pathfinder` needs to know secrets exist. What this
+ * class remembers is the other half: which cells have a secret at all, and what they turn
+ * into once discovered - a secret door swapping to a passable, transparent kind; a trap
+ * staying passable but becoming *visibly* a trap.
+ *
+ * Discovery itself is a game's call, not this class's: a search action rolling against a
+ * distance, a trap firing the moment a creature steps onto it, a wand of revealing. This
+ * only does the bookkeeping once that decision has been made.
+ */
+export class Secrets {
+    constructor(level) {
+        this.revealedKind = new Map();
+        this.discovered = new Set();
+        this.level = level;
+    }
+    /** hides a cell as `disguise`, remembering that it becomes `revealed` once discovered */
+    conceal(x, y, disguise, revealed) {
+        const cell = this.level.index(x, y);
+        this.revealedKind.set(cell, revealed);
+        this.discovered.delete(cell);
+        this.level.set(x, y, disguise);
+    }
+    /** a cell with a secret, still hidden - what a search action should be rolling against */
+    isSecret(x, y) {
+        const cell = this.level.index(x, y);
+        return this.revealedKind.has(cell) && !this.discovered.has(cell);
+    }
+    isDiscovered(x, y) {
+        return this.discovered.has(this.level.index(x, y));
+    }
+    /**
+     * Swaps a concealed cell to its revealed kind.
+     *
+     * @returns whether there was anything to discover - false for a cell with no secret, or
+     * one already found, so a caller can tell a real discovery from a wasted search
+     */
+    discover(x, y) {
+        if (!this.isSecret(x, y))
+            return false;
+        const cell = this.level.index(x, y);
+        this.discovered.add(cell);
+        this.level.set(x, y, this.revealedKind.get(cell));
+        return true;
+    }
+    toJSON() {
+        return { revealed: [...this.revealedKind], discovered: [...this.discovered] };
+    }
+    /** rebuilds secrets from save data onto a (separately restored) level */
+    static fromJSON(level, data) {
+        const secrets = new Secrets(level);
+        for (const [cell, revealed] of data.revealed)
+            secrets.revealedKind.set(cell, revealed);
+        for (const cell of data.discovered)
+            secrets.discovered.add(cell);
+        return secrets;
+    }
+}
+//# sourceMappingURL=Secrets.js.map

package/dist/roguelike/Secrets.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Secrets.js","sourceRoot":"","sources":["../../src/roguelike/Secrets.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;GAcG;AACH,MAAM,OAAO,OAAO;IAKnB,YAAY,KAAY;QAHhB,iBAAY,GAAG,IAAI,GAAG,EAAkB,CAAC;QACzC,eAAU,GAAG,IAAI,GAAG,EAAU,CAAC;QAGtC,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;IACpB,CAAC;IAED,yFAAyF;IACzF,OAAO,CAAC,CAAS,EAAE,CAAS,EAAE,QAAgB,EAAE,QAAgB;QAC/D,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;QACpC,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC;QACtC,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;QAC7B,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,QAAQ,CAAC,CAAC;IAChC,CAAC;IAED,0FAA0F;IAC1F,QAAQ,CAAC,CAAS,EAAE,CAAS;QAC5B,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;QACpC,OAAO,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;IAClE,CAAC;IAED,YAAY,CAAC,CAAS,EAAE,CAAS;QAChC,OAAO,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;IACpD,CAAC;IAED;;;;;OAKG;IACH,QAAQ,CAAC,CAAS,EAAE,CAAS;QAC5B,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC;YAAE,OAAO,KAAK,CAAC;QAEvC,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;QACpC,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QAC1B,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,IAAI,CAAE,CAAC,CAAC;QACnD,OAAO,IAAI,CAAC;IACb,CAAC;IAED,MAAM;QACL,OAAO,EAAE,QAAQ,EAAE,CAAC,GAAG,IAAI,CAAC,YAAY,CAAC,EAAE,UAAU,EAAE,CAAC,GAAG,IAAI,CAAC,UAAU,CAAC,EAAE,CAAC;IAC/E,CAAC;IAED,yEAAyE;IACzE,MAAM,CAAC,QAAQ,CAAC,KAAY,EAAE,IAA4D;QACzF,MAAM,OAAO,GAAG,IAAI,OAAO,CAAC,KAAK,CAAC,CAAC;QACnC,KAAK,MAAM,CAAC,IAAI,EAAE,QAAQ,CAAC,IAAI,IAAI,CAAC,QAAQ;YAAE,OAAO,CAAC,YAAY,CAAC,GAAG,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC;QACvF,KAAK,MAAM,IAAI,IAAI,IAAI,CAAC,UAAU;YAAE,OAAO,CAAC,UAAU,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QACjE,OAAO,OAAO,CAAC;IAChB,CAAC;CACD"}

package/dist/roguelike/Targeting.d.ts

@@ -0,0 +1,66 @@
+import type { Level } from './Level.ts';
+import type { Step } from './Pathfinder.ts';
+/**
+ * How a target resolves into the cells it actually affects.
+ *
+ * `single` is a dagger throw or a bolt from a wand - only the cell aimed at. `burst` is an
+ * explosion or a cloud, centred on the target rather than the thrower. `line` is a beam or a
+ * spear thrust - everything between thrower and target, not just where it lands. `cone` is a
+ * breath or a spray - widening with distance along the aim direction, `width` counting how
+ * many cells wide the far end is.
+ */
+export type AreaShape = {
+    kind: 'single';
+} | {
+    kind: 'burst';
+    radius: number;
+} | {
+    kind: 'line';
+} | {
+    kind: 'cone';
+    width: number;
+};
+export interface TargetingOptions {
+    /** how far the aim can reach, in cells (Chebyshev distance - the usual roguelike ruler) */
+    range: number;
+    /** whether a wall in the way blocks the shot; on by default, since most things do not arc */
+    requireLineOfSight?: boolean;
+}
+/** the straight-line ruler distance a roguelike uses: diagonals cost the same as a step */
+export declare function chebyshevDistance(a: Step, b: Step): number;
+/**
+ * Every cell a straight line crosses from `from` to `to`, `from` included and `to` included.
+ *
+ * Bresenham's algorithm, not a shadowcast: this answers "what is on the way to this exact
+ * point", which is what aiming needs. `FieldOfView` answers "what can be seen from here at
+ * all", a different question with a different (and pricier) algorithm.
+ */
+export declare function traceLine(from: Step, to: Step): Step[];
+/** true when nothing between `from` and `to` (both cells themselves excepted) blocks sight */
+export declare function hasLineOfSight(level: Level, from: Step, to: Step): boolean;
+/** whether `target` is a legal aim point from `origin`: in range, and in sight unless waived */
+export declare function canTarget(level: Level, origin: Step, target: Step, options: TargetingOptions): boolean;
+/** the cells a shape actually affects, once aimed at `target` from `origin` */
+export declare function resolveArea(origin: Step, target: Step, shape: AreaShape): Step[];
+/**
+ * Every cell in a widening spray from `origin` towards `target`: the aim snaps to the
+ * nearest of the 8 directions, the length is the distance aimed, and step `i` of `length`
+ * spans `round(i / length * width)` cells to each side of the centre line. A width of 0
+ * is a single-file beam, the same cells `line` would trace along that snapped direction.
+ */
+export declare function coneCells(origin: Step, target: Step, width: number): Step[];
+/**
+ * An arcing chain across `candidates`: starting from `origin`, each link is the nearest
+ * not-yet-visited candidate within `range` of the previous one, up to `jumps` links. A
+ * lightning arc, a contagion, anything that hops from one victim to the next rather than
+ * travelling as a projectile - the game applies its own effect per link in order.
+ */
+export declare function chainTargets(candidates: readonly Step[], origin: Step, jumps: number, range: number): Step[];
+/**
+ * The cells something shoved from `from` along `direction` (a unit step, one of the 8)
+ * travels: every passable cell up to `distance`, stopping before the first impassable
+ * one. The game moves the shoved actor to the last cell returned - or nowhere, when the
+ * very first cell already blocks, in which case the shove lands against the wall instead.
+ */
+export declare function knockbackPath(level: Level, from: Step, direction: Step, distance: number): Step[];
+//# sourceMappingURL=Targeting.d.ts.map

package/dist/roguelike/Targeting.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Targeting.d.ts","sourceRoot":"","sources":["../../src/roguelike/Targeting.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACxC,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAC;AAE5C;;;;;;;;GAQG;AACH,MAAM,MAAM,SAAS,GAClB;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,GAClB;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GACjC;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,GAChB;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC;AAEnC,MAAM,WAAW,gBAAgB;IAChC,2FAA2F;IAC3F,KAAK,EAAE,MAAM,CAAC;IAEd,6FAA6F;IAC7F,kBAAkB,CAAC,EAAE,OAAO,CAAC;CAC7B;AAED,2FAA2F;AAC3F,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,GAAG,MAAM,CAE1D;AAED;;;;;;GAMG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,IAAI,EAAE,EAAE,EAAE,IAAI,GAAG,IAAI,EAAE,CA2BtD;AAED,8FAA8F;AAC9F,wBAAgB,cAAc,CAAC,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,IAAI,EAAE,EAAE,EAAE,IAAI,GAAG,OAAO,CAM1E;AAED,gGAAgG;AAChG,wBAAgB,SAAS,CAAC,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,gBAAgB,GAAG,OAAO,CAItG;AAED,+EAA+E;AAC/E,wBAAgB,WAAW,CAAC,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,KAAK,EAAE,SAAS,GAAG,IAAI,EAAE,CAuBhF;AAED;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,EAAE,CAoB3E;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,UAAU,EAAE,SAAS,IAAI,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,EAAE,CAsB5G;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,IAAI,EAAE,SAAS,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI,EAAE,CAQjG"}

package/dist/roguelike/Targeting.js

@@ -0,0 +1,150 @@
+/** the straight-line ruler distance a roguelike uses: diagonals cost the same as a step */
+export function chebyshevDistance(a, b) {
+    return Math.max(Math.abs(a.x - b.x), Math.abs(a.y - b.y));
+}
+/**
+ * Every cell a straight line crosses from `from` to `to`, `from` included and `to` included.
+ *
+ * Bresenham's algorithm, not a shadowcast: this answers "what is on the way to this exact
+ * point", which is what aiming needs. `FieldOfView` answers "what can be seen from here at
+ * all", a different question with a different (and pricier) algorithm.
+ */
+export function traceLine(from, to) {
+    const points = [];
+    let x = from.x;
+    let y = from.y;
+    const dx = Math.abs(to.x - from.x);
+    const dy = -Math.abs(to.y - from.y);
+    const sx = from.x < to.x ? 1 : -1;
+    const sy = from.y < to.y ? 1 : -1;
+    let error = dx + dy;
+    for (;;) {
+        points.push({ x, y });
+        if (x === to.x && y === to.y)
+            break;
+        const doubled = error * 2;
+        if (doubled >= dy) {
+            error += dy;
+            x += sx;
+        }
+        if (doubled <= dx) {
+            error += dx;
+            y += sy;
+        }
+    }
+    return points;
+}
+/** true when nothing between `from` and `to` (both cells themselves excepted) blocks sight */
+export function hasLineOfSight(level, from, to) {
+    const line = traceLine(from, to);
+    for (let i = 1; i < line.length - 1; i++) {
+        if (!level.transparent(line[i].x, line[i].y))
+            return false;
+    }
+    return true;
+}
+/** whether `target` is a legal aim point from `origin`: in range, and in sight unless waived */
+export function canTarget(level, origin, target, options) {
+    if (chebyshevDistance(origin, target) > options.range)
+        return false;
+    if ((options.requireLineOfSight ?? true) && !hasLineOfSight(level, origin, target))
+        return false;
+    return true;
+}
+/** the cells a shape actually affects, once aimed at `target` from `origin` */
+export function resolveArea(origin, target, shape) {
+    switch (shape.kind) {
+        case 'single':
+            return [target];
+        case 'line':
+            return traceLine(origin, target);
+        case 'cone':
+            return coneCells(origin, target, shape.width);
+        case 'burst': {
+            const cells = [];
+            const r = shape.radius;
+            for (let dy = -r; dy <= r; dy++) {
+                for (let dx = -r; dx <= r; dx++) {
+                    if (dx * dx + dy * dy > r * r)
+                        continue;
+                    cells.push({ x: target.x + dx, y: target.y + dy });
+                }
+            }
+            return cells;
+        }
+    }
+}
+/**
+ * Every cell in a widening spray from `origin` towards `target`: the aim snaps to the
+ * nearest of the 8 directions, the length is the distance aimed, and step `i` of `length`
+ * spans `round(i / length * width)` cells to each side of the centre line. A width of 0
+ * is a single-file beam, the same cells `line` would trace along that snapped direction.
+ */
+export function coneCells(origin, target, width) {
+    const dx = target.x - origin.x;
+    const dy = target.y - origin.y;
+    const length = Math.max(Math.abs(dx), Math.abs(dy));
+    if (length === 0)
+        return [{ ...origin }];
+    const stepX = Math.sign(dx);
+    const stepY = Math.sign(dy);
+    //perpendicular to the snapped direction: swapped for diagonals, single-axis otherwise
+    const perpX = dx !== 0 && dy !== 0 ? stepX : stepY;
+    const perpY = dx !== 0 && dy !== 0 ? -stepY : stepX;
+    const cells = [];
+    for (let i = 1; i <= length; i++) {
+        const cx = origin.x + stepX * i;
+        const cy = origin.y + stepY * i;
+        const half = Math.round((i / length) * width);
+        for (let o = -half; o <= half; o++)
+            cells.push({ x: cx + perpX * o, y: cy + perpY * o });
+    }
+    return cells;
+}
+/**
+ * An arcing chain across `candidates`: starting from `origin`, each link is the nearest
+ * not-yet-visited candidate within `range` of the previous one, up to `jumps` links. A
+ * lightning arc, a contagion, anything that hops from one victim to the next rather than
+ * travelling as a projectile - the game applies its own effect per link in order.
+ */
+export function chainTargets(candidates, origin, jumps, range) {
+    const visited = new Set();
+    const chain = [];
+    let from = origin;
+    for (let jump = 0; jump < jumps; jump++) {
+        let best = -1;
+        let bestDistance = range + 1;
+        for (let i = 0; i < candidates.length; i++) {
+            if (visited.has(i))
+                continue;
+            const distance = chebyshevDistance(from, candidates[i]);
+            if (distance <= range && distance < bestDistance) {
+                bestDistance = distance;
+                best = i;
+            }
+        }
+        if (best === -1)
+            break;
+        visited.add(best);
+        chain.push(candidates[best]);
+        from = candidates[best];
+    }
+    return chain;
+}
+/**
+ * The cells something shoved from `from` along `direction` (a unit step, one of the 8)
+ * travels: every passable cell up to `distance`, stopping before the first impassable
+ * one. The game moves the shoved actor to the last cell returned - or nowhere, when the
+ * very first cell already blocks, in which case the shove lands against the wall instead.
+ */
+export function knockbackPath(level, from, direction, distance) {
+    const cells = [];
+    for (let i = 1; i <= distance; i++) {
+        const at = { x: from.x + direction.x * i, y: from.y + direction.y * i };
+        if (!level.passable(at.x, at.y))
+            break;
+        cells.push(at);
+    }
+    return cells;
+}
+//# sourceMappingURL=Targeting.js.map

package/dist/roguelike/Targeting.js.map

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

package/dist/roguelike/generate.d.ts

@@ -0,0 +1,44 @@
+import { Level, type Rect, type TerrainKind } from './Level.ts';
+/**
+ * Rooms joined by corridors.
+ *
+ * Written here rather than taken from rot.js for one reason: the seed. `mwg`'s generator
+ * is the framework's own, so a seed produces the same dungeon on every machine and can be
+ * saved with the game. Borrowing a generator would mean borrowing its RNG too, and then
+ * two independent streams decide what the level looks like.
+ *
+ * The rooms are kept on the level afterwards, because everything else a game wants to do —
+ * put the stairs far from the entrance, spawn a monster where the player is not, place
+ * treasure in a dead end — is a question about rooms, not about cells.
+ */
+export interface DungeonOptions {
+    width: number;
+    height: number;
+    /** how many rooms to attempt; fewer will be placed if they do not fit */
+    rooms?: number;
+    minRoomSize?: number;
+    maxRoomSize?: number;
+    /**
+     * How often an extra corridor joins two rooms that are already connected.
+     *
+     * At 0 the dungeon is a tree: exactly one route between any two rooms, which reads as a
+     * maze and makes retreating impossible. A few loops is what makes a level feel like a
+     * place rather than a puzzle.
+     */
+    extraCorridors?: number;
+    /** the terrain ids to write; both must exist in the kinds passed to the Level */
+    wall?: number;
+    floor?: number;
+    /** extra terrain kinds beyond wall/floor, appended after them - a game's own trap or door ids */
+    kinds?: TerrainKind[];
+}
+export declare const DUNGEON_KINDS: TerrainKind[];
+export declare function generateDungeon(options: DungeonOptions): Level;
+/** a random passable cell, avoiding any listed as taken */
+export declare function findFreeCell(level: Level, taken?: ReadonlySet<number>): number | null;
+/** the room furthest from `from`, by straight-line distance between centres */
+export declare function furthestRoom(level: Level, from: {
+    x: number;
+    y: number;
+}): Rect | null;
+//# sourceMappingURL=generate.d.ts.map

package/dist/roguelike/generate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate.d.ts","sourceRoot":"","sources":["../../src/roguelike/generate.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,EAA4B,KAAK,IAAI,EAAE,KAAK,WAAW,EAAE,MAAM,YAAY,CAAC;AAE1F;;;;;;;;;;;GAWG;AAEH,MAAM,WAAW,cAAc;IAC9B,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IAEf,yEAAyE;IACzE,KAAK,CAAC,EAAE,MAAM,CAAC;IAEf,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,WAAW,CAAC,EAAE,MAAM,CAAC;IAErB;;;;;;OAMG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;IAExB,iFAAiF;IACjF,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,CAAC;IAEf,iGAAiG;IACjG,KAAK,CAAC,EAAE,WAAW,EAAE,CAAC;CACtB;AAED,eAAO,MAAM,aAAa,EAAE,WAAW,EAGtC,CAAC;AAEF,wBAAgB,eAAe,CAAC,OAAO,EAAE,cAAc,GAAG,KAAK,CAkD9D;AA0CD,2DAA2D;AAC3D,wBAAgB,YAAY,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,GAAE,WAAW,CAAC,MAAM,CAAa,GAAG,MAAM,GAAG,IAAI,CAGhG;AAED,+EAA+E;AAC/E,wBAAgB,YAAY,CAAC,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,GAAG,IAAI,CActF"}

package/dist/roguelike/generate.js

@@ -0,0 +1,88 @@
+import * as Random from '../core/Random.js';
+import { Level, rectCenter, rectsOverlap } from './Level.js';
+export const DUNGEON_KINDS = [
+    { passable: false, transparent: false }, //0 wall
+    { passable: true, transparent: true }, //1 floor
+];
+export function generateDungeon(options) {
+    const { width, height, rooms: roomAttempts = 14, minRoomSize = 4, maxRoomSize = 10, extraCorridors = 3, wall = 0, floor = 1, kinds = [], } = options;
+    const level = new Level(width, height, [...DUNGEON_KINDS, ...kinds], wall);
+    const placed = [];
+    //rejection sampling: try a spot, keep it if it clears the others. simple, and it fails
+    //gracefully — a crowded level just ends up with fewer rooms rather than looping forever
+    for (let attempt = 0; attempt < roomAttempts * 6 && placed.length < roomAttempts; attempt++) {
+        const w = Random.range(minRoomSize, maxRoomSize);
+        const h = Random.range(minRoomSize, maxRoomSize);
+        //kept one cell clear of the border, so every room has a wall to carve a door through
+        const left = Random.int(1, Math.max(2, width - w - 1));
+        const top = Random.int(1, Math.max(2, height - h - 1));
+        const room = { left, top, right: left + w - 1, bottom: top + h - 1 };
+        if (room.right >= width - 1 || room.bottom >= height - 1)
+            continue;
+        //a two-cell margin, so rooms never share a wall and corridors have somewhere to run
+        if (placed.some((other) => rectsOverlap(room, other, 2)))
+            continue;
+        placed.push(room);
+        level.fillRect(room, floor);
+    }
+    //join each room to the previous one, which guarantees every room is reachable
+    for (let i = 1; i < placed.length; i++) {
+        carveCorridor(level, rectCenter(placed[i - 1]), rectCenter(placed[i]), floor);
+    }
+    //then a few extra links, so the map has loops instead of being a tree
+    for (let i = 0; i < extraCorridors && placed.length > 2; i++) {
+        const a = placed[Random.int(placed.length)];
+        const b = placed[Random.int(placed.length)];
+        if (a !== b)
+            carveCorridor(level, rectCenter(a), rectCenter(b), floor);
+    }
+    level.rooms = placed;
+    return level;
+}
+/**
+ * An L-shaped corridor between two points.
+ *
+ * The corner goes one way or the other at random; always turning the same way makes every
+ * corridor on the map lean in the same direction, which is instantly noticeable.
+ */
+function carveCorridor(level, from, to, floor) {
+    const horizontalFirst = Random.chance(0.5);
+    if (horizontalFirst) {
+        carveLine(level, from.x, to.x, from.y, true, floor);
+        carveLine(level, from.y, to.y, to.x, false, floor);
+    }
+    else {
+        carveLine(level, from.y, to.y, from.x, false, floor);
+        carveLine(level, from.x, to.x, to.y, true, floor);
+    }
+}
+function carveLine(level, fromCoord, toCoord, fixed, horizontal, floor) {
+    const step = fromCoord <= toCoord ? 1 : -1;
+    for (let c = fromCoord; c !== toCoord + step; c += step) {
+        const x = horizontal ? c : fixed;
+        const y = horizontal ? fixed : c;
+        //the outermost ring stays solid, so the map always has a wall around it
+        if (level.insideWithBorder(x, y))
+            level.set(x, y, floor);
+    }
+}
+/** a random passable cell, avoiding any listed as taken */
+export function findFreeCell(level, taken = new Set()) {
+    const free = level.passableCells().filter((cell) => !taken.has(cell));
+    return free.length > 0 ? free[Random.int(free.length)] : null;
+}
+/** the room furthest from `from`, by straight-line distance between centres */
+export function furthestRoom(level, from) {
+    let best = null;
+    let bestDistance = -1;
+    for (const room of level.rooms) {
+        const centre = rectCenter(room);
+        const distance = (centre.x - from.x) ** 2 + (centre.y - from.y) ** 2;
+        if (distance > bestDistance) {
+            bestDistance = distance;
+            best = room;
+        }
+    }
+    return best;
+}
+//# sourceMappingURL=generate.js.map

package/dist/roguelike/generate.js.map

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

package/dist/roguelike/index.d.ts

@@ -0,0 +1,23 @@
+export { Level, WALL, FLOOR, rectCenter, rectsOverlap } from './Level.ts';
+export type { TerrainKind, Rect } from './Level.ts';
+export { generateDungeon, findFreeCell, furthestRoom, DUNGEON_KINDS } from './generate.ts';
+export type { DungeonOptions } from './generate.ts';
+export { FieldOfView } from './FieldOfView.ts';
+export type { HeightSight } from './FieldOfView.ts';
+export { Elevation } from './Elevation.ts';
+export { Pathfinder, neighbourOffsets } from './Pathfinder.ts';
+export type { Step, PathOptions } from './Pathfinder.ts';
+export { Scheduler } from './Scheduler.ts';
+export type { Actor } from './Scheduler.ts';
+export { decideMonsterAI } from './MonsterAI.ts';
+export type { AIState, AIDecision, MonsterAIOptions, Disposition } from './MonsterAI.ts';
+export { Secrets } from './Secrets.ts';
+export { Doors } from './Doors.ts';
+export { chebyshevDistance, traceLine, hasLineOfSight, canTarget, resolveArea } from './Targeting.ts';
+export type { AreaShape, TargetingOptions } from './Targeting.ts';
+export { coneCells, chainTargets, knockbackPath } from './Targeting.ts';
+export { BossPhases, AbilityCycle } from './Boss.ts';
+export { Blob } from './Blob.ts';
+export { CombatHooks } from './Combat.ts';
+export type { CombatEvent, CombatHook, DamageContext } from './Combat.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/roguelike/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/roguelike/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAC1E,YAAY,EAAE,WAAW,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AAEpD,OAAO,EAAE,eAAe,EAAE,YAAY,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAC3F,YAAY,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAEpD,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAC/C,YAAY,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAEpD,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAE3C,OAAO,EAAE,UAAU,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAC/D,YAAY,EAAE,IAAI,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAEzD,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAC3C,YAAY,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAC;AAE5C,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AACjD,YAAY,EAAE,OAAO,EAAE,UAAU,EAAE,gBAAgB,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAEzF,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAEvC,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAEnC,OAAO,EAAE,iBAAiB,EAAE,SAAS,EAAE,cAAc,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AACtG,YAAY,EAAE,SAAS,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAClE,OAAO,EAAE,SAAS,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAExE,OAAO,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAErD,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACjC,OAAO,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC1C,YAAY,EAAE,WAAW,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC"}

package/dist/roguelike/index.js

@@ -0,0 +1,15 @@
+export { Level, WALL, FLOOR, rectCenter, rectsOverlap } from './Level.js';
+export { generateDungeon, findFreeCell, furthestRoom, DUNGEON_KINDS } from './generate.js';
+export { FieldOfView } from './FieldOfView.js';
+export { Elevation } from './Elevation.js';
+export { Pathfinder, neighbourOffsets } from './Pathfinder.js';
+export { Scheduler } from './Scheduler.js';
+export { decideMonsterAI } from './MonsterAI.js';
+export { Secrets } from './Secrets.js';
+export { Doors } from './Doors.js';
+export { chebyshevDistance, traceLine, hasLineOfSight, canTarget, resolveArea } from './Targeting.js';
+export { coneCells, chainTargets, knockbackPath } from './Targeting.js';
+export { BossPhases, AbilityCycle } from './Boss.js';
+export { Blob } from './Blob.js';
+export { CombatHooks } from './Combat.js';
+//# sourceMappingURL=index.js.map

package/dist/roguelike/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/roguelike/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAG1E,OAAO,EAAE,eAAe,EAAE,YAAY,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAG3F,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAG/C,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAE3C,OAAO,EAAE,UAAU,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAG/D,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAG3C,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAGjD,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAEvC,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAEnC,OAAO,EAAE,iBAAiB,EAAE,SAAS,EAAE,cAAc,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAEtG,OAAO,EAAE,SAAS,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAExE,OAAO,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAErD,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACjC,OAAO,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC"}