@datamoc/mw_games 0.1.1

package/dist/roguelike/Level.js

@@ -0,0 +1,137 @@
+import { hexNeighbors } from '../core/Hex.js';
+/** the four or eight cell offsets around a point, shared by every square-grid algorithm here */
+export function neighbourOffsets(topology) {
+    return topology === 4
+        ? [
+            [0, -1],
+            [1, 0],
+            [0, 1],
+            [-1, 0],
+        ]
+        : [
+            [0, -1],
+            [1, -1],
+            [1, 0],
+            [1, 1],
+            [0, 1],
+            [-1, 1],
+            [-1, 0],
+            [-1, -1],
+        ];
+}
+/** the two that every map needs; a game adds its own alongside */
+export const WALL = { passable: false, transparent: false };
+export const FLOOR = { passable: true, transparent: true };
+export class Level {
+    constructor(width, height, kinds, fill = 0, shape = 'square') {
+        /** rooms the generator carved, for placing stairs, monsters and treasure */
+        this.rooms = [];
+        this.width = width;
+        this.shape = shape;
+        this.height = height;
+        this.kinds = kinds;
+        this.terrain = new Uint8Array(width * height).fill(fill);
+    }
+    get cellCount() {
+        return this.width * this.height;
+    }
+    index(x, y) {
+        return y * this.width + x;
+    }
+    xOf(cell) {
+        return cell % this.width;
+    }
+    yOf(cell) {
+        return Math.floor(cell / this.width);
+    }
+    inside(x, y) {
+        return x >= 0 && y >= 0 && x < this.width && y < this.height;
+    }
+    /**
+     * The cells adjacent to `(x, y)` - six of them on a hex `Level`, four or eight on a
+     * square one, regardless of which. This is the seam that lets `Pathfinder` and
+     * `FieldOfView` work over either shape unchanged: they walk neighbours, and only this
+     * method knows what a neighbour is.
+     *
+     * @param topology ignored on a hex `Level` - it only has the one neighbourhood shape
+     */
+    neighbors(x, y, topology = 8) {
+        if (this.shape === 'hex')
+            return hexNeighbors(x, y);
+        return neighbourOffsets(topology).map(([dx, dy]) => ({ x: x + dx, y: y + dy }));
+    }
+    /**
+     * True only for cells with a full ring of neighbours.
+     *
+     * Anything that inspects a cell's surroundings should use this rather than `inside`,
+     * because a cell on the very edge has no neighbour on one side and every such check
+     * then needs its own bounds test. Generators keep the border solid for the same reason.
+     */
+    insideWithBorder(x, y) {
+        return x > 0 && y > 0 && x < this.width - 1 && y < this.height - 1;
+    }
+    get(x, y) {
+        return this.inside(x, y) ? this.terrain[this.index(x, y)] : 0;
+    }
+    set(x, y, kind) {
+        if (this.inside(x, y))
+            this.terrain[this.index(x, y)] = kind;
+    }
+    kindAt(x, y) {
+        return this.kinds[this.get(x, y)] ?? WALL;
+    }
+    passable(x, y) {
+        return this.inside(x, y) && this.kindAt(x, y).passable;
+    }
+    transparent(x, y) {
+        return this.inside(x, y) && this.kindAt(x, y).transparent;
+    }
+    fillRect(rect, kind) {
+        for (let y = rect.top; y <= rect.bottom; y++) {
+            for (let x = rect.left; x <= rect.right; x++)
+                this.set(x, y, kind);
+        }
+    }
+    /** every passable cell, as indices — the pool to place things in */
+    passableCells() {
+        const out = [];
+        for (let i = 0; i < this.terrain.length; i++) {
+            if (this.kinds[this.terrain[i]]?.passable)
+                out.push(i);
+        }
+        return out;
+    }
+    toJSON() {
+        return {
+            width: this.width,
+            height: this.height,
+            shape: this.shape,
+            terrain: [...this.terrain],
+            rooms: this.rooms.map((room) => ({ ...room })),
+        };
+    }
+    /**
+     * Rebuilds a level from save data - the `kinds` table is supplied fresh (it holds a
+     * game's own terrain meanings, the same way `QuestLog` takes its definitions fresh),
+     * so only the terrain ids and rooms are ever save data.
+     */
+    static fromJSON(kinds, data) {
+        const level = new Level(data.width, data.height, kinds, 0, data.shape);
+        level.terrain.set(data.terrain.slice(0, level.terrain.length));
+        level.rooms = data.rooms.map((room) => ({ ...room }));
+        return level;
+    }
+}
+export function rectCenter(rect) {
+    return {
+        x: Math.floor((rect.left + rect.right) / 2),
+        y: Math.floor((rect.top + rect.bottom) / 2),
+    };
+}
+export function rectsOverlap(a, b, margin = 0) {
+    return !(a.right + margin < b.left ||
+        b.right + margin < a.left ||
+        a.bottom + margin < b.top ||
+        b.bottom + margin < a.top);
+}
+//# sourceMappingURL=Level.js.map

package/dist/roguelike/Level.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Level.js","sourceRoot":"","sources":["../../src/roguelike/Level.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAc9C,gGAAgG;AAChG,MAAM,UAAU,gBAAgB,CAAC,QAAe;IAC/C,OAAO,QAAQ,KAAK,CAAC;QACpB,CAAC,CAAC;YACA,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;YACP,CAAC,CAAC,EAAE,CAAC,CAAC;YACN,CAAC,CAAC,EAAE,CAAC,CAAC;YACN,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;SACP;QACF,CAAC,CAAC;YACA,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;YACP,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;YACP,CAAC,CAAC,EAAE,CAAC,CAAC;YACN,CAAC,CAAC,EAAE,CAAC,CAAC;YACN,CAAC,CAAC,EAAE,CAAC,CAAC;YACN,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;YACP,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;YACP,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;SACR,CAAC;AACL,CAAC;AAUD,kEAAkE;AAClE,MAAM,CAAC,MAAM,IAAI,GAAgB,EAAE,QAAQ,EAAE,KAAK,EAAE,WAAW,EAAE,KAAK,EAAE,CAAC;AACzE,MAAM,CAAC,MAAM,KAAK,GAAgB,EAAE,QAAQ,EAAE,IAAI,EAAE,WAAW,EAAE,IAAI,EAAE,CAAC;AASxE,MAAM,OAAO,KAAK;IAajB,YAAY,KAAa,EAAE,MAAc,EAAE,KAAoB,EAAE,IAAI,GAAG,CAAC,EAAE,KAAK,GAAe,QAAQ;QAHvG,4EAA4E;QAC5E,UAAK,GAAW,EAAE,CAAC;QAGlB,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;QACnB,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;QACnB,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;QACrB,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;QACnB,IAAI,CAAC,OAAO,GAAG,IAAI,UAAU,CAAC,KAAK,GAAG,MAAM,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IAC1D,CAAC;IAED,IAAI,SAAS;QACZ,OAAO,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC;IACjC,CAAC;IAED,KAAK,CAAC,CAAS,EAAE,CAAS;QACzB,OAAO,CAAC,GAAG,IAAI,CAAC,KAAK,GAAG,CAAC,CAAC;IAC3B,CAAC;IAED,GAAG,CAAC,IAAY;QACf,OAAO,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC;IAC1B,CAAC;IAED,GAAG,CAAC,IAAY;QACf,OAAO,IAAI,CAAC,KAAK,CAAC,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC;IACtC,CAAC;IAED,MAAM,CAAC,CAAS,EAAE,CAAS;QAC1B,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,KAAK,IAAI,CAAC,GAAG,IAAI,CAAC,MAAM,CAAC;IAC9D,CAAC;IAED;;;;;;;OAOG;IACH,SAAS,CAAC,CAAS,EAAE,CAAS,EAAE,QAAQ,GAAU,CAAC;QAClD,IAAI,IAAI,CAAC,KAAK,KAAK,KAAK;YAAE,OAAO,YAAY,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;QACpD,OAAO,gBAAgB,CAAC,QAAQ,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC,CAAC;IACjF,CAAC;IAED;;;;;;OAMG;IACH,gBAAgB,CAAC,CAAS,EAAE,CAAS;QACpC,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,KAAK,GAAG,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC;IACpE,CAAC;IAED,GAAG,CAAC,CAAS,EAAE,CAAS;QACvB,OAAO,IAAI,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IAC/D,CAAC;IAED,GAAG,CAAC,CAAS,EAAE,CAAS,EAAE,IAAY;QACrC,IAAI,IAAI,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC;YAAE,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;IAC9D,CAAC;IAED,MAAM,CAAC,CAAS,EAAE,CAAS;QAC1B,OAAO,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,IAAI,CAAC;IAC3C,CAAC;IAED,QAAQ,CAAC,CAAS,EAAE,CAAS;QAC5B,OAAO,IAAI,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,IAAI,IAAI,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC;IACxD,CAAC;IAED,WAAW,CAAC,CAAS,EAAE,CAAS;QAC/B,OAAO,IAAI,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,IAAI,IAAI,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,WAAW,CAAC;IAC3D,CAAC;IAED,QAAQ,CAAC,IAAU,EAAE,IAAY;QAChC,KAAK,IAAI,CAAC,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC,IAAI,IAAI,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;YAC9C,KAAK,IAAI,CAAC,GAAG,IAAI,CAAC,IAAI,EAAE,CAAC,IAAI,IAAI,CAAC,KAAK,EAAE,CAAC,EAAE;gBAAE,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,IAAI,CAAC,CAAC;QACpE,CAAC;IACF,CAAC;IAED,oEAAoE;IACpE,aAAa;QACZ,MAAM,GAAG,GAAa,EAAE,CAAC;QACzB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;YAC9C,IAAI,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,EAAE,QAAQ;gBAAE,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QACxD,CAAC;QACD,OAAO,GAAG,CAAC;IACZ,CAAC;IAED,MAAM;QACL,OAAO;YACN,KAAK,EAAE,IAAI,CAAC,KAAK;YACjB,MAAM,EAAE,IAAI,CAAC,MAAM;YACnB,KAAK,EAAE,IAAI,CAAC,KAAK;YACjB,OAAO,EAAE,CAAC,GAAG,IAAI,CAAC,OAAO,CAAC;YAC1B,KAAK,EAAE,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,EAAE,GAAG,IAAI,EAAE,CAAC,CAAC;SAC9C,CAAC;IACH,CAAC;IAED;;;;OAIG;IACH,MAAM,CAAC,QAAQ,CACd,KAAoB,EACpB,IAA4F;QAE5F,MAAM,KAAK,GAAG,IAAI,KAAK,CAAC,IAAI,CAAC,KAAK,EAAE,IAAI,CAAC,MAAM,EAAE,KAAK,EAAE,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC;QACvE,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,EAAE,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC;QAC/D,KAAK,CAAC,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,EAAE,GAAG,IAAI,EAAE,CAAC,CAAC,CAAC;QACtD,OAAO,KAAK,CAAC;IACd,CAAC;CACD;AAED,MAAM,UAAU,UAAU,CAAC,IAAU;IACpC,OAAO;QACN,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;QAC3C,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC,GAAG,GAAG,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;KAC3C,CAAC;AACH,CAAC;AAED,MAAM,UAAU,YAAY,CAAC,CAAO,EAAE,CAAO,EAAE,MAAM,GAAG,CAAC;IACxD,OAAO,CAAC,CACP,CAAC,CAAC,KAAK,GAAG,MAAM,GAAG,CAAC,CAAC,IAAI;QACzB,CAAC,CAAC,KAAK,GAAG,MAAM,GAAG,CAAC,CAAC,IAAI;QACzB,CAAC,CAAC,MAAM,GAAG,MAAM,GAAG,CAAC,CAAC,GAAG;QACzB,CAAC,CAAC,MAAM,GAAG,MAAM,GAAG,CAAC,CAAC,GAAG,CACzB,CAAC;AACH,CAAC"}

package/dist/roguelike/MonsterAI.d.ts

@@ -0,0 +1,40 @@
+import type { Level } from './Level.ts';
+import { type PathOptions, type Pathfinder, type Step } from './Pathfinder.ts';
+export type AIState = 'wander' | 'hunt' | 'flee';
+/** hostile hunts on sight, same as ever; neutral/peaceful only wander until `provoked` */
+export type Disposition = 'hostile' | 'neutral' | 'peaceful';
+export interface AIDecision {
+    state: AIState;
+    /** where to move this turn; null when there is nowhere sensible to go */
+    step: Step | null;
+}
+export interface MonsterAIOptions extends PathOptions {
+    /** how far the monster can see, in cells - its own sight range, not the player's */
+    sightRadius?: number;
+    /** HP fraction (0 to 1) at or below which a visible target is fled rather than hunted */
+    fleeBelow?: number;
+    /** defaults to 'hostile' - always hunts on sight, exactly like every monster used to */
+    disposition?: Disposition;
+    /**
+     * true once this monster has been attacked (or otherwise provoked) - overrides a
+     * neutral/peaceful disposition back to hunting, permanently, the same as `hostile`. A
+     * game tracks this per monster and sets it the moment it lands the provoking hit; this
+     * function stores no state of its own between calls, same as `hpFraction`.
+     */
+    provoked?: boolean;
+}
+/**
+ * One monster's turn: wander when the target is outside its own sight, hunt when it can see
+ * the target and is healthy, flee when it can see the target and its own HP has dropped to
+ * `fleeBelow` or lower. Built entirely from `FieldOfView` and `Pathfinder` - both already
+ * shipped - so this is what turns them into an actual decision, rather than a game
+ * hand-rolling the same wander/hunt/flee branch on its own.
+ *
+ * A fresh `FieldOfView` per call is deliberate: a monster's sight is its own, not the
+ * player's, and computing a small-radius shadowcast once per monster per turn is cheap at
+ * the monster counts a level actually has. `mwg` does not decide what a monster does with
+ * the result - a game's own turn loop calls this once per monster and acts on the `step`
+ * (or doesn't, for wander's "nowhere in particular").
+ */
+export declare function decideMonsterAI(level: Level, pathfinder: Pathfinder, self: Step, hpFraction: number, target: Step, options?: MonsterAIOptions): AIDecision;
+//# sourceMappingURL=MonsterAI.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"MonsterAI.d.ts","sourceRoot":"","sources":["../../src/roguelike/MonsterAI.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAExC,OAAO,EAAoB,KAAK,WAAW,EAAE,KAAK,UAAU,EAAE,KAAK,IAAI,EAAE,MAAM,iBAAiB,CAAC;AAEjG,MAAM,MAAM,OAAO,GAAG,QAAQ,GAAG,MAAM,GAAG,MAAM,CAAC;AAEjD,0FAA0F;AAC1F,MAAM,MAAM,WAAW,GAAG,SAAS,GAAG,SAAS,GAAG,UAAU,CAAC;AAE7D,MAAM,WAAW,UAAU;IAC1B,KAAK,EAAE,OAAO,CAAC;IACf,yEAAyE;IACzE,IAAI,EAAE,IAAI,GAAG,IAAI,CAAC;CAClB;AAED,MAAM,WAAW,gBAAiB,SAAQ,WAAW;IACpD,oFAAoF;IACpF,WAAW,CAAC,EAAE,MAAM,CAAC;IAErB,yFAAyF;IACzF,SAAS,CAAC,EAAE,MAAM,CAAC;IAEnB,wFAAwF;IACxF,WAAW,CAAC,EAAE,WAAW,CAAC;IAE1B;;;;;OAKG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;CACnB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,eAAe,CAC9B,KAAK,EAAE,KAAK,EACZ,UAAU,EAAE,UAAU,EACtB,IAAI,EAAE,IAAI,EACV,UAAU,EAAE,MAAM,EAClB,MAAM,EAAE,IAAI,EACZ,OAAO,GAAE,gBAAqB,GAC5B,UAAU,CAqBZ"}

package/dist/roguelike/MonsterAI.js

@@ -0,0 +1,69 @@
+import * as Random from '../core/Random.js';
+import { FieldOfView } from './FieldOfView.js';
+import { neighbourOffsets } from './Pathfinder.js';
+/**
+ * One monster's turn: wander when the target is outside its own sight, hunt when it can see
+ * the target and is healthy, flee when it can see the target and its own HP has dropped to
+ * `fleeBelow` or lower. Built entirely from `FieldOfView` and `Pathfinder` - both already
+ * shipped - so this is what turns them into an actual decision, rather than a game
+ * hand-rolling the same wander/hunt/flee branch on its own.
+ *
+ * A fresh `FieldOfView` per call is deliberate: a monster's sight is its own, not the
+ * player's, and computing a small-radius shadowcast once per monster per turn is cheap at
+ * the monster counts a level actually has. `mwg` does not decide what a monster does with
+ * the result - a game's own turn loop calls this once per monster and acts on the `step`
+ * (or doesn't, for wander's "nowhere in particular").
+ */
+export function decideMonsterAI(level, pathfinder, self, hpFraction, target, options = {}) {
+    const sightRadius = options.sightRadius ?? 6;
+    const fleeBelow = options.fleeBelow ?? 0;
+    const hunts = (options.disposition ?? 'hostile') === 'hostile' || options.provoked === true;
+    if (!hunts) {
+        return { state: 'wander', step: wanderStep(level, self, options) };
+    }
+    const fov = new FieldOfView(level);
+    fov.update(self.x, self.y, sightRadius);
+    if (!fov.isVisible(target.x, target.y)) {
+        return { state: 'wander', step: wanderStep(level, self, options) };
+    }
+    if (hpFraction <= fleeBelow) {
+        return { state: 'flee', step: fleeStep(level, self, target, options) };
+    }
+    return { state: 'hunt', step: pathfinder.step(self, target, options) };
+}
+/** a random open neighbour, or null when boxed in - wandering needs no path, just a step */
+function wanderStep(level, self, options) {
+    const open = openNeighbours(level, self, options);
+    return open.length > 0 ? Random.element(open) : null;
+}
+/** the open neighbour furthest from the target - moving away needs no path either */
+function fleeStep(level, self, target, options) {
+    const open = openNeighbours(level, self, options);
+    let best = null;
+    let bestDistance = distanceSquared(self, target);
+    for (const step of open) {
+        const distance = distanceSquared(step, target);
+        if (distance > bestDistance) {
+            bestDistance = distance;
+            best = step;
+        }
+    }
+    return best;
+}
+function openNeighbours(level, self, options) {
+    const blocked = options.blocked;
+    const out = [];
+    for (const [dx, dy] of neighbourOffsets(options.topology ?? 8)) {
+        const step = { x: self.x + dx, y: self.y + dy };
+        if (!level.passable(step.x, step.y))
+            continue;
+        if (blocked?.has(level.index(step.x, step.y)))
+            continue;
+        out.push(step);
+    }
+    return out;
+}
+function distanceSquared(a, b) {
+    return (a.x - b.x) ** 2 + (a.y - b.y) ** 2;
+}
+//# sourceMappingURL=MonsterAI.js.map

package/dist/roguelike/MonsterAI.js.map

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

package/dist/roguelike/Pathfinder.d.ts

@@ -0,0 +1,82 @@
+import { neighbourOffsets, type Level } from './Level.ts';
+import type { FieldOfView } from './FieldOfView.ts';
+import type { Elevation } from './Elevation.ts';
+/** re-exported here for anyone already importing it from `Pathfinder` - it now lives on
+ * `Level`, which is what needs it for a square level's own `neighbors()` */
+export { neighbourOffsets };
+export interface Step {
+    x: number;
+    y: number;
+}
+export interface PathOptions {
+    /** 4 for cardinal moves only, 8 to allow diagonals */
+    topology?: 4 | 8;
+    /**
+     * Cells to treat as blocked beyond the terrain — other creatures, usually.
+     *
+     * Passed per call rather than held, because who is standing where changes every turn
+     * and a cached path is a monster walking through its neighbour.
+     */
+    blocked?: ReadonlySet<number>;
+    /**
+     * The map's heights, when climbing matters. A step from one cell to the next is
+     * allowed when the destination rises no more than `climb` above the start;
+     * going down is always allowed, the way stepping off a ledge is. Needs `heights`
+     * to mean anything on its own.
+     */
+    heights?: Elevation;
+    /** how many levels up one step may climb; defaults to 1, the ordinary stair or ramp */
+    climb?: number;
+}
+/**
+ * Routes across the map.
+ *
+ * A* for "how do I get to that one place", which is what a monster chasing the player
+ * needs. A Dijkstra map for "which way is the player from anywhere", which is what a dozen
+ * monsters chasing the player need — computed once for the whole level rather than once
+ * per monster.
+ */
+export declare class Pathfinder {
+    private level;
+    constructor(level: Level);
+    private passable;
+    /**
+     * Whether one step is walkable: passable ground, unblocked, and no harder a
+     * climb than allowed. Without `heights` this is passability alone, so flat
+     * maps never pay for a notion they do not use.
+     */
+    private stepper;
+    /**
+     * The shortest route from one cell to another.
+     *
+     * @returns the cells to walk through, starting with the one after `from` and ending on
+     * `to`. Empty when there is no route — including when `to` is blocked, so a caller
+     * should exclude the target itself from `blocked` if it means to walk into it.
+     */
+    find(from: Step, to: Step, options?: PathOptions): Step[];
+    /** just the next step towards a target, which is all a chasing monster needs */
+    step(from: Step, to: Step, options?: PathOptions): Step | null;
+    /**
+     * Distance from every reachable cell to `to`, in steps.
+     *
+     * One pass gives every creature on the map its direction: each reads the value under
+     * itself and moves to whichever neighbour is lower. That is a Dijkstra map, and it is
+     * the difference between one flood fill per turn and one per monster per turn.
+     */
+    distanceMap(to: Step, options?: PathOptions): Int32Array;
+    /** the neighbour of `from` with the lowest value in a distance map */
+    descend(from: Step, distances: Int32Array, options?: PathOptions): Step | null;
+    /**
+     * Autoexplore: the path to the nearest passable, reachable cell not yet explored -
+     * "walk towards whatever is unseen" rather than a chosen destination. A breadth-first
+     * flood from `from` stops at the first unexplored cell it reaches, which is nearest by
+     * construction; a Dijkstra map from a single target cannot answer this, since there is
+     * no one target until the search itself finds one.
+     *
+     * @returns the steps to walk there, or `[]` when everything reachable is already explored
+     */
+    autoExplore(from: Step, explored: FieldOfView, options?: PathOptions): Step[];
+    /** walks a `cameFrom` chain back to (but excluding) its start, then reverses it */
+    private reconstruct;
+}
+//# sourceMappingURL=Pathfinder.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Pathfinder.d.ts","sourceRoot":"","sources":["../../src/roguelike/Pathfinder.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,gBAAgB,EAAE,KAAK,KAAK,EAAE,MAAM,YAAY,CAAC;AAC1D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AACpD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAEhD;4EAC4E;AAC5E,OAAO,EAAE,gBAAgB,EAAE,CAAC;AAE5B,MAAM,WAAW,IAAI;IACpB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACV;AAED,MAAM,WAAW,WAAW;IAC3B,sDAAsD;IACtD,QAAQ,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC;IAEjB;;;;;OAKG;IACH,OAAO,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IAE9B;;;;;OAKG;IACH,OAAO,CAAC,EAAE,SAAS,CAAC;IAEpB,uFAAuF;IACvF,KAAK,CAAC,EAAE,MAAM,CAAC;CACf;AAED;;;;;;;GAOG;AACH,qBAAa,UAAU;IACtB,OAAO,CAAC,KAAK,CAAQ;IAErB,YAAY,KAAK,EAAE,KAAK,EAEvB;IAED,OAAO,CAAC,QAAQ;IAQhB;;;;OAIG;IACH,OAAO,CAAC,OAAO;IAoBf;;;;;;OAMG;IACH,IAAI,CAAC,IAAI,EAAE,IAAI,EAAE,EAAE,EAAE,IAAI,EAAE,OAAO,GAAE,WAAgB,GAAG,IAAI,EAAE,CA8B5D;IAED,gFAAgF;IAChF,IAAI,CAAC,IAAI,EAAE,IAAI,EAAE,EAAE,EAAE,IAAI,EAAE,OAAO,GAAE,WAAgB,GAAG,IAAI,GAAG,IAAI,CAEjE;IAED;;;;;;OAMG;IACH,WAAW,CAAC,EAAE,EAAE,IAAI,EAAE,OAAO,GAAE,WAAgB,GAAG,UAAU,CAiC3D;IAED,sEAAsE;IACtE,OAAO,CAAC,IAAI,EAAE,IAAI,EAAE,SAAS,EAAE,UAAU,EAAE,OAAO,GAAE,WAAgB,GAAG,IAAI,GAAG,IAAI,CAmBjF;IAED;;;;;;;;OAQG;IACH,WAAW,CAAC,IAAI,EAAE,IAAI,EAAE,QAAQ,EAAE,WAAW,EAAE,OAAO,GAAE,WAAgB,GAAG,IAAI,EAAE,CA4BhF;IAED,mFAAmF;IACnF,OAAO,CAAC,WAAW;CAWnB"}

package/dist/roguelike/Pathfinder.js

@@ -0,0 +1,192 @@
+import { Path } from 'rot-js';
+import { neighbourOffsets } from './Level.js';
+/** re-exported here for anyone already importing it from `Pathfinder` - it now lives on
+ * `Level`, which is what needs it for a square level's own `neighbors()` */
+export { neighbourOffsets };
+/**
+ * Routes across the map.
+ *
+ * A* for "how do I get to that one place", which is what a monster chasing the player
+ * needs. A Dijkstra map for "which way is the player from anywhere", which is what a dozen
+ * monsters chasing the player need — computed once for the whole level rather than once
+ * per monster.
+ */
+export class Pathfinder {
+    constructor(level) {
+        this.level = level;
+    }
+    passable(options) {
+        const blocked = options.blocked;
+        return (x, y) => {
+            if (!this.level.passable(x, y))
+                return false;
+            return !blocked?.has(this.level.index(x, y));
+        };
+    }
+    /**
+     * Whether one step is walkable: passable ground, unblocked, and no harder a
+     * climb than allowed. Without `heights` this is passability alone, so flat
+     * maps never pay for a notion they do not use.
+     */
+    stepper(options) {
+        const passable = this.passable(options);
+        const heights = options.heights;
+        //a step with either end off the map is never walkable. Said out loud it is
+        //obvious; it is stated because Level.index does not bounds-check, so an
+        //off-map cell aliases a real one and must never reach an index call.
+        if (!heights) {
+            return (fx, fy, tx, ty) => this.level.inside(fx, fy) && this.level.inside(tx, ty) && passable(tx, ty);
+        }
+        const climb = options.climb ?? 1;
+        if (!Number.isInteger(climb) || climb < 0) {
+            throw new Error(`a climb limit must be a non-negative whole number, got ${options.climb}`);
+        }
+        return (fx, fy, tx, ty) => this.level.inside(fx, fy) &&
+            this.level.inside(tx, ty) &&
+            passable(tx, ty) &&
+            heights.heightAt(tx, ty) - heights.heightAt(fx, fy) <= climb;
+    }
+    /**
+     * The shortest route from one cell to another.
+     *
+     * @returns the cells to walk through, starting with the one after `from` and ending on
+     * `to`. Empty when there is no route — including when `to` is blocked, so a caller
+     * should exclude the target itself from `blocked` if it means to walk into it.
+     */
+    find(from, to, options = {}) {
+        //rot.js's own A* is square-grid only (its topology option is the 4/8 offsets above,
+        //nothing hex-shaped); a hex Level instead walks a Dijkstra map one descend() at a
+        //time, which needs no topology-specific search of its own since distanceMap and
+        //descend already go through Level.neighbors. Heights join the hex path for the same
+        //reason: rot.js's passability callback sees one cell at a time, but a climb limit
+        //compares two, so a height-aware search descends a Dijkstra map whatever the shape.
+        if (this.level.shape === 'hex' || options.heights) {
+            const distances = this.distanceMap(to, options);
+            const steps = [];
+            let current = from;
+            for (let guard = 0; guard < this.level.cellCount; guard++) {
+                const next = this.descend(current, distances, options);
+                if (!next)
+                    break;
+                steps.push(next);
+                if (next.x === to.x && next.y === to.y)
+                    break;
+                current = next;
+            }
+            return steps;
+        }
+        const astar = new Path.AStar(to.x, to.y, this.passable(options), {
+            topology: options.topology ?? 8,
+        });
+        const steps = [];
+        astar.compute(from.x, from.y, (x, y) => steps.push({ x, y }));
+        //rot.js includes the starting cell; a caller wants where to go, not where it is
+        return steps.slice(1);
+    }
+    /** just the next step towards a target, which is all a chasing monster needs */
+    step(from, to, options = {}) {
+        return this.find(from, to, options)[0] ?? null;
+    }
+    /**
+     * Distance from every reachable cell to `to`, in steps.
+     *
+     * One pass gives every creature on the map its direction: each reads the value under
+     * itself and moves to whichever neighbour is lower. That is a Dijkstra map, and it is
+     * the difference between one flood fill per turn and one per monster per turn.
+     */
+    distanceMap(to, options = {}) {
+        const distances = new Int32Array(this.level.cellCount).fill(-1);
+        const passable = this.passable(options);
+        const canStep = this.stepper(options);
+        if (!passable(to.x, to.y))
+            return distances;
+        //a plain breadth-first flood, since every step costs the same
+        const queue = [this.level.index(to.x, to.y)];
+        distances[queue[0]] = 0;
+        for (let head = 0; head < queue.length; head++) {
+            const cell = queue[head];
+            const cx = this.level.xOf(cell);
+            const cy = this.level.yOf(cell);
+            const next = distances[cell] + 1;
+            for (const n of this.level.neighbors(cx, cy, options.topology ?? 8)) {
+                //reversed: the flood expands away from the target, but travel runs
+                //towards it, and a climb limit reads differently each way. Checking
+                //the travel direction keeps every distance exact, so descend() can
+                //never strand on a cell with no legal step downhill.
+                if (!canStep(n.x, n.y, cx, cy))
+                    continue;
+                const neighbour = this.level.index(n.x, n.y);
+                if (distances[neighbour] !== -1)
+                    continue;
+                distances[neighbour] = next;
+                queue.push(neighbour);
+            }
+        }
+        return distances;
+    }
+    /** the neighbour of `from` with the lowest value in a distance map */
+    descend(from, distances, options = {}) {
+        const canStep = this.stepper(options);
+        const here = distances[this.level.index(from.x, from.y)];
+        if (here <= 0)
+            return null;
+        let best = null;
+        let bestDistance = here;
+        for (const n of this.level.neighbors(from.x, from.y, options.topology ?? 8)) {
+            if (!canStep(from.x, from.y, n.x, n.y))
+                continue;
+            const distance = distances[this.level.index(n.x, n.y)];
+            if (distance !== -1 && distance < bestDistance) {
+                bestDistance = distance;
+                best = n;
+            }
+        }
+        return best;
+    }
+    /**
+     * Autoexplore: the path to the nearest passable, reachable cell not yet explored -
+     * "walk towards whatever is unseen" rather than a chosen destination. A breadth-first
+     * flood from `from` stops at the first unexplored cell it reaches, which is nearest by
+     * construction; a Dijkstra map from a single target cannot answer this, since there is
+     * no one target until the search itself finds one.
+     *
+     * @returns the steps to walk there, or `[]` when everything reachable is already explored
+     */
+    autoExplore(from, explored, options = {}) {
+        const passable = this.passable(options);
+        const canStep = this.stepper(options);
+        if (!passable(from.x, from.y))
+            return [];
+        const cameFrom = new Map();
+        const visited = new Set([this.level.index(from.x, from.y)]);
+        const queue = [from];
+        for (let head = 0; head < queue.length; head++) {
+            const current = queue[head];
+            if (head > 0 && !explored.isExplored(current.x, current.y)) {
+                return this.reconstruct(cameFrom, current);
+            }
+            for (const next of this.level.neighbors(current.x, current.y, options.topology ?? 8)) {
+                if (!canStep(current.x, current.y, next.x, next.y))
+                    continue;
+                const index = this.level.index(next.x, next.y);
+                if (visited.has(index))
+                    continue;
+                visited.add(index);
+                cameFrom.set(index, current);
+                queue.push(next);
+            }
+        }
+        return [];
+    }
+    /** walks a `cameFrom` chain back to (but excluding) its start, then reverses it */
+    reconstruct(cameFrom, to) {
+        const path = [to];
+        let step = cameFrom.get(this.level.index(to.x, to.y));
+        while (step) {
+            path.push(step);
+            step = cameFrom.get(this.level.index(step.x, step.y));
+        }
+        return path.reverse();
+    }
+}
+//# sourceMappingURL=Pathfinder.js.map

package/dist/roguelike/Pathfinder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Pathfinder.js","sourceRoot":"","sources":["../../src/roguelike/Pathfinder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAC9B,OAAO,EAAE,gBAAgB,EAAc,MAAM,YAAY,CAAC;AAI1D;4EAC4E;AAC5E,OAAO,EAAE,gBAAgB,EAAE,CAAC;AA+B5B;;;;;;;GAOG;AACH,MAAM,OAAO,UAAU;IAGtB,YAAY,KAAY;QACvB,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;IACpB,CAAC;IAEO,QAAQ,CAAC,OAAoB;QACpC,MAAM,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC;QAChC,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE;YACf,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC;gBAAE,OAAO,KAAK,CAAC;YAC7C,OAAO,CAAC,OAAO,EAAE,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;QAC9C,CAAC,CAAC;IACH,CAAC;IAED;;;;OAIG;IACK,OAAO,CAAC,OAAoB;QACnC,MAAM,QAAQ,GAAG,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;QACxC,MAAM,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC;QAChC,2EAA2E;QAC3E,wEAAwE;QACxE,qEAAqE;QACrE,IAAI,CAAC,OAAO,EAAE,CAAC;YACd,OAAO,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,EAAE,EAAE,EAAE,CAAC,IAAI,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,EAAE,EAAE,EAAE,CAAC,IAAI,QAAQ,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC;QACvG,CAAC;QACD,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,IAAI,CAAC,CAAC;QACjC,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,KAAK,CAAC,IAAI,KAAK,GAAG,CAAC,EAAE,CAAC;YAC3C,MAAM,IAAI,KAAK,CAAC,0DAA0D,OAAO,CAAC,KAAK,EAAE,CAAC,CAAC;QAC5F,CAAC;QACD,OAAO,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,CACzB,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,EAAE,EAAE,EAAE,CAAC;YACzB,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,EAAE,EAAE,EAAE,CAAC;YACzB,QAAQ,CAAC,EAAE,EAAE,EAAE,CAAC;YAChB,OAAO,CAAC,QAAQ,CAAC,EAAE,EAAE,EAAE,CAAC,GAAG,OAAO,CAAC,QAAQ,CAAC,EAAE,EAAE,EAAE,CAAC,IAAI,KAAK,CAAC;IAC/D,CAAC;IAED;;;;;;OAMG;IACH,IAAI,CAAC,IAAU,EAAE,EAAQ,EAAE,OAAO,GAAgB,EAAE;QACnD,oFAAoF;QACpF,kFAAkF;QAClF,gFAAgF;QAChF,oFAAoF;QACpF,kFAAkF;QAClF,oFAAoF;QACpF,IAAI,IAAI,CAAC,KAAK,CAAC,KAAK,KAAK,KAAK,IAAI,OAAO,CAAC,OAAO,EAAE,CAAC;YACnD,MAAM,SAAS,GAAG,IAAI,CAAC,WAAW,CAAC,EAAE,EAAE,OAAO,CAAC,CAAC;YAChD,MAAM,KAAK,GAAW,EAAE,CAAC;YACzB,IAAI,OAAO,GAAG,IAAI,CAAC;YACnB,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,SAAS,EAAE,KAAK,EAAE,EAAE,CAAC;gBAC3D,MAAM,IAAI,GAAG,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE,SAAS,EAAE,OAAO,CAAC,CAAC;gBACvD,IAAI,CAAC,IAAI;oBAAE,MAAM;gBACjB,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;gBACjB,IAAI,IAAI,CAAC,CAAC,KAAK,EAAE,CAAC,CAAC,IAAI,IAAI,CAAC,CAAC,KAAK,EAAE,CAAC,CAAC;oBAAE,MAAM;gBAC9C,OAAO,GAAG,IAAI,CAAC;YAChB,CAAC;YACD,OAAO,KAAK,CAAC;QACd,CAAC;QAED,MAAM,KAAK,GAAG,IAAI,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,EAAE;YAChE,QAAQ,EAAE,OAAO,CAAC,QAAQ,IAAI,CAAC;SAC/B,CAAC,CAAC;QAEH,MAAM,KAAK,GAAW,EAAE,CAAC;QACzB,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;QAE9D,gFAAgF;QAChF,OAAO,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;IACvB,CAAC;IAED,gFAAgF;IAChF,IAAI,CAAC,IAAU,EAAE,EAAQ,EAAE,OAAO,GAAgB,EAAE;QACnD,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,EAAE,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC,IAAI,IAAI,CAAC;IAChD,CAAC;IAED;;;;;;OAMG;IACH,WAAW,CAAC,EAAQ,EAAE,OAAO,GAAgB,EAAE;QAC9C,MAAM,SAAS,GAAG,IAAI,UAAU,CAAC,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;QAChE,MAAM,QAAQ,GAAG,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;QACxC,MAAM,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;QAEtC,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC;YAAE,OAAO,SAAS,CAAC;QAE5C,8DAA8D;QAC9D,MAAM,KAAK,GAAa,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;QACvD,SAAS,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;QAExB,KAAK,IAAI,IAAI,GAAG,CAAC,EAAE,IAAI,GAAG,KAAK,CAAC,MAAM,EAAE,IAAI,EAAE,EAAE,CAAC;YAChD,MAAM,IAAI,GAAG,KAAK,CAAC,IAAI,CAAC,CAAC;YACzB,MAAM,EAAE,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;YAChC,MAAM,EAAE,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;YAChC,MAAM,IAAI,GAAG,SAAS,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;YAEjC,KAAK,MAAM,CAAC,IAAI,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,EAAE,EAAE,EAAE,EAAE,OAAO,CAAC,QAAQ,IAAI,CAAC,CAAC,EAAE,CAAC;gBACrE,mEAAmE;gBACnE,oEAAoE;gBACpE,mEAAmE;gBACnE,qDAAqD;gBACrD,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC;oBAAE,SAAS;gBAEzC,MAAM,SAAS,GAAG,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;gBAC7C,IAAI,SAAS,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;oBAAE,SAAS;gBAE1C,SAAS,CAAC,SAAS,CAAC,GAAG,IAAI,CAAC;gBAC5B,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;YACvB,CAAC;QACF,CAAC;QAED,OAAO,SAAS,CAAC;IAClB,CAAC;IAED,sEAAsE;IACtE,OAAO,CAAC,IAAU,EAAE,SAAqB,EAAE,OAAO,GAAgB,EAAE;QACnE,MAAM,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;QACtC,MAAM,IAAI,GAAG,SAAS,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;QACzD,IAAI,IAAI,IAAI,CAAC;YAAE,OAAO,IAAI,CAAC;QAE3B,IAAI,IAAI,GAAgB,IAAI,CAAC;QAC7B,IAAI,YAAY,GAAG,IAAI,CAAC;QAExB,KAAK,MAAM,CAAC,IAAI,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,EAAE,OAAO,CAAC,QAAQ,IAAI,CAAC,CAAC,EAAE,CAAC;YAC7E,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;gBAAE,SAAS;YAEjD,MAAM,QAAQ,GAAG,SAAS,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;YACvD,IAAI,QAAQ,KAAK,CAAC,CAAC,IAAI,QAAQ,GAAG,YAAY,EAAE,CAAC;gBAChD,YAAY,GAAG,QAAQ,CAAC;gBACxB,IAAI,GAAG,CAAC,CAAC;YACV,CAAC;QACF,CAAC;QAED,OAAO,IAAI,CAAC;IACb,CAAC;IAED;;;;;;;;OAQG;IACH,WAAW,CAAC,IAAU,EAAE,QAAqB,EAAE,OAAO,GAAgB,EAAE;QACvE,MAAM,QAAQ,GAAG,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;QACxC,MAAM,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;QACtC,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC;YAAE,OAAO,EAAE,CAAC;QAEzC,MAAM,QAAQ,GAAG,IAAI,GAAG,EAAgB,CAAC;QACzC,MAAM,OAAO,GAAG,IAAI,GAAG,CAAS,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QACpE,MAAM,KAAK,GAAW,CAAC,IAAI,CAAC,CAAC;QAE7B,KAAK,IAAI,IAAI,GAAG,CAAC,EAAE,IAAI,GAAG,KAAK,CAAC,MAAM,EAAE,IAAI,EAAE,EAAE,CAAC;YAChD,MAAM,OAAO,GAAG,KAAK,CAAC,IAAI,CAAC,CAAC;YAC5B,IAAI,IAAI,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC;gBAC5D,OAAO,IAAI,CAAC,WAAW,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAC;YAC5C,CAAC;YAED,KAAK,MAAM,IAAI,IAAI,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC,EAAE,OAAO,CAAC,QAAQ,IAAI,CAAC,CAAC,EAAE,CAAC;gBACtF,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC;oBAAE,SAAS;gBAE7D,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC;gBAC/C,IAAI,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC;oBAAE,SAAS;gBAEjC,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;gBACnB,QAAQ,CAAC,GAAG,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;gBAC7B,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YAClB,CAAC;QACF,CAAC;QAED,OAAO,EAAE,CAAC;IACX,CAAC;IAED,mFAAmF;IAC3E,WAAW,CAAC,QAA2B,EAAE,EAAQ;QACxD,MAAM,IAAI,GAAW,CAAC,EAAE,CAAC,CAAC;QAE1B,IAAI,IAAI,GAAG,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;QACtD,OAAO,IAAI,EAAE,CAAC;YACb,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YAChB,IAAI,GAAG,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;QACvD,CAAC;QAED,OAAO,IAAI,CAAC,OAAO,EAAE,CAAC;IACvB,CAAC;CACD"}

package/dist/roguelike/Scheduler.d.ts

@@ -0,0 +1,45 @@
+/**
+ * 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 interface Actor {
+    /** actions per unit of time; 2 acts twice as often as 1 */
+    speed?: number;
+}
+export declare class Scheduler<A extends Actor> {
+    private entries;
+    private sequence;
+    /** the current time; advances to each actor's turn as it comes up */
+    now: number;
+    get size(): number;
+    get actors(): A[];
+    has(actor: A): boolean;
+    /**
+     * 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: A, delay?: number): void;
+    remove(actor: A): void;
+    clear(): void;
+    /** whoever acts next, without removing them; time advances to their turn */
+    peek(): A | null;
+    /**
+     * 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: number): void;
+    /** the time at which an actor next acts, for a debug view or an interface */
+    timeOf(actor: A): number | null;
+    private sort;
+}
+//# sourceMappingURL=Scheduler.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Scheduler.d.ts","sourceRoot":"","sources":["../../src/roguelike/Scheduler.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,MAAM,WAAW,KAAK;IACrB,2DAA2D;IAC3D,KAAK,CAAC,EAAE,MAAM,CAAC;CACf;AAUD,qBAAa,SAAS,CAAC,CAAC,SAAS,KAAK;IACrC,OAAO,CAAC,OAAO,CAAkB;IACjC,OAAO,CAAC,QAAQ,CAAK;IAErB,qEAAqE;IACrE,GAAG,SAAK;IAER,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED,IAAI,MAAM,IAAI,CAAC,EAAE,CAEhB;IAED,GAAG,CAAC,KAAK,EAAE,CAAC,GAAG,OAAO,CAErB;IAED;;;;;OAKG;IACH,GAAG,CAAC,KAAK,EAAE,CAAC,EAAE,KAAK,SAAI,GAAG,IAAI,CAG7B;IAED,MAAM,CAAC,KAAK,EAAE,CAAC,GAAG,IAAI,CAGrB;IAED,KAAK,IAAI,IAAI,CAIZ;IAED,4EAA4E;IAC5E,IAAI,IAAI,CAAC,GAAG,IAAI,CAOf;IAED;;;;OAIG;IACH,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CASxB;IAED,6EAA6E;IAC7E,MAAM,CAAC,KAAK,EAAE,CAAC,GAAG,MAAM,GAAG,IAAI,CAE9B;IAED,OAAO,CAAC,IAAI;CAKZ"}