@datamoc/mw_games 0.43.0 → 0.45.0

package/dist/roguelike/Pathfinder.js

@@ -1,213 +0,0 @@
-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()`.
- *
- * @example
- * ```ts
- * import { neighbourOffsets } from '@datamoc/mw_games/roguelike';
- *
- * const offsets = neighbourOffsets(8); // the 8 (x, y) deltas around a cell, diagonals included
- * ```
- */
-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.
- *
- * @example
- * ```ts
- * import { Pathfinder, Level, WALL, FLOOR } from '@datamoc/mw_games/roguelike';
- *
- * const level = new Level(20, 20, [WALL, FLOOR], 1);
- * const pathfinder = new Pathfinder(level);
- *
- * const route = pathfinder.find({ x: 0, y: 0 }, { x: 10, y: 10 }); // one monster's own route
- *
- * const distances = pathfinder.distanceMap({ x: 10, y: 10 }); // every monster reads the same map
- * ```
- */
-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;
-            this.level.forEachNeighbor(cx, cy, options.topology ?? 8, (nx, ny) => {
-                //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(nx, ny, cx, cy))
-                    return;
-                const neighbour = this.level.index(nx, ny);
-                if (distances[neighbour] !== -1)
-                    return;
-                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;
-        this.level.forEachNeighbor(from.x, from.y, options.topology ?? 8, (nx, ny) => {
-            if (!canStep(from.x, from.y, nx, ny))
-                return;
-            const distance = distances[this.level.index(nx, ny)];
-            if (distance !== -1 && distance < bestDistance) {
-                bestDistance = distance;
-                best = { x: nx, y: ny };
-            }
-        });
-        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);
-            }
-            this.level.forEachNeighbor(current.x, current.y, options.topology ?? 8, (nx, ny) => {
-                if (!canStep(current.x, current.y, nx, ny))
-                    return;
-                const index = this.level.index(nx, ny);
-                if (visited.has(index))
-                    return;
-                visited.add(index);
-                cameFrom.set(index, current);
-                queue.push({ x: nx, y: ny });
-            });
-        }
-        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

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

package/dist/roguelike/Placement.d.ts

@@ -1,62 +0,0 @@
-import type { Level } from './Level.ts';
-/**
- * Filters over terrain and occupancy for a placement pool - the seam a dungeon's
- * feature/content hooks use to ask "which cells could this go on" without `FeatureLayer` or
- * a game's own item/monster classes ever entering the picture. Every field is optional and
- * narrows the pool further; omitting all of them is every cell on the level.
- */
-export interface PlacementFilter {
-    /** raw terrain kind ids eligible (indices into the `Level`'s own `kinds`); omit for any kind */
-    terrain?: ReadonlySet<number>;
-    /** cells to exclude - already taken by another feature, a monster, an item */
-    occupied?: ReadonlySet<number>;
-    /** restrict the search to these cells (a room's interior, a hand-picked region); omit for the whole level */
-    within?: Iterable<number>;
-}
-/** Every cell on `level` matching `filter` - the pool a placement selects from. */
-export declare function candidateCells(level: Level, filter?: PlacementFilter): number[];
-/** Cells within `radius` neighbour-steps of `center` (via `Level.forEachNeighbor`, so hex and square both work), never including `center` itself. */
-export declare function cellsNear(level: Level, center: number, radius: number): number[];
-export interface PlacementTraceEntry {
-    requested: number;
-    available: number;
-    selected: number[];
-}
-export interface PlacementResult {
-    cells: number[];
-    trace: PlacementTraceEntry;
-}
-/**
- * Picks `count` distinct cells out of `candidates` without replacement, falling back to
- * however many exist when fewer are available rather than throwing or looping forever - a
- * crowded region just gets fewer placements, the same "fail gracefully, place fewer" shape
- * `generateDungeonGraph`'s own room placement already uses. Pure: nothing is placed or
- * marked taken until the caller acts on `cells` itself (typically `FeatureLayer.place`, or
- * folding `cells` into the next call's own `occupied` set). `trace` is plain, JSON-safe data
- * a game can push straight into `DungeonArtifacts.content` for a parity check, or persist
- * across save/load the same way any other roll trace does.
- *
- * Composes with `candidateCells` and `cellsNear` for the three shapes a regional generator
- * needs: several neighbouring items (`cellsNear` around one anchor, intersected with a
- * terrain/occupancy pool, then selected from), scattered decorations across a whole region
- * (`candidateCells` with a large `within`, then selected from with a larger `count`), and a
- * single branch or room reward (`candidateCells` scoped to one room, `count: 1`).
- *
- * @example
- * ```ts
- * import { candidateCells, cellsNear, selectDistinctCells } from '@datamoc/mw_games/roguelike';
- *
- * declare const level: import('@datamoc/mw_games/roguelike').Level;
- * const FLOOR = new Set([1]);
- *
- * // scatter 3 decorations anywhere on the floor
- * const pool = candidateCells(level, { terrain: FLOOR });
- * const { cells: decorations, trace } = selectDistinctCells(pool, 3);
- *
- * // then release 2 more items clustered around one of those cells
- * const nearby = cellsNear(level, decorations[0], 2).filter((c) => pool.includes(c));
- * const { cells: cluster } = selectDistinctCells(nearby, 2);
- * ```
- */
-export declare function selectDistinctCells(candidates: readonly number[], count: number): PlacementResult;
-//# sourceMappingURL=Placement.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"Placement.d.ts","sourceRoot":"","sources":["../../src/roguelike/Placement.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAExC;;;;;GAKG;AACH,MAAM,WAAW,eAAe;IAC/B,gGAAgG;IAChG,OAAO,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IAE9B,8EAA8E;IAC9E,QAAQ,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IAE/B,6GAA6G;IAC7G,MAAM,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC;CAC1B;AAED,mFAAmF;AACnF,wBAAgB,cAAc,CAAC,KAAK,EAAE,KAAK,EAAE,MAAM,GAAE,eAAoB,GAAG,MAAM,EAAE,CAOnF;AAED,qJAAqJ;AACrJ,wBAAgB,SAAS,CAAC,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CAoBhF;AAED,MAAM,WAAW,mBAAmB;IACnC,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,EAAE,CAAC;CACnB;AAED,MAAM,WAAW,eAAe;IAC/B,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,KAAK,EAAE,mBAAmB,CAAC;CAC3B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAgB,mBAAmB,CAAC,UAAU,EAAE,SAAS,MAAM,EAAE,EAAE,KAAK,EAAE,MAAM,GAAG,eAAe,CAKjG"}

package/dist/roguelike/Placement.js

@@ -1,79 +0,0 @@
-import * as Random from '../core/Random.js';
-/** Every cell on `level` matching `filter` - the pool a placement selects from. */
-export function candidateCells(level, filter = {}) {
-    const source = filter.within ? [...filter.within] : range(level.cellCount);
-    return source.filter((cell) => {
-        if (filter.occupied?.has(cell))
-            return false;
-        if (filter.terrain && !filter.terrain.has(level.terrain[cell]))
-            return false;
-        return true;
-    });
-}
-/** Cells within `radius` neighbour-steps of `center` (via `Level.forEachNeighbor`, so hex and square both work), never including `center` itself. */
-export function cellsNear(level, center, radius) {
-    const seen = new Set([center]);
-    let frontier = [center];
-    for (let step = 0; step < Math.max(0, radius); step++) {
-        const next = [];
-        for (const cell of frontier) {
-            level.forEachNeighbor(level.xOf(cell), level.yOf(cell), 8, (x, y) => {
-                if (!level.inside(x, y))
-                    return;
-                const neighbor = level.index(x, y);
-                if (seen.has(neighbor))
-                    return;
-                seen.add(neighbor);
-                next.push(neighbor);
-            });
-        }
-        frontier = next;
-    }
-    seen.delete(center);
-    return [...seen];
-}
-/**
- * Picks `count` distinct cells out of `candidates` without replacement, falling back to
- * however many exist when fewer are available rather than throwing or looping forever - a
- * crowded region just gets fewer placements, the same "fail gracefully, place fewer" shape
- * `generateDungeonGraph`'s own room placement already uses. Pure: nothing is placed or
- * marked taken until the caller acts on `cells` itself (typically `FeatureLayer.place`, or
- * folding `cells` into the next call's own `occupied` set). `trace` is plain, JSON-safe data
- * a game can push straight into `DungeonArtifacts.content` for a parity check, or persist
- * across save/load the same way any other roll trace does.
- *
- * Composes with `candidateCells` and `cellsNear` for the three shapes a regional generator
- * needs: several neighbouring items (`cellsNear` around one anchor, intersected with a
- * terrain/occupancy pool, then selected from), scattered decorations across a whole region
- * (`candidateCells` with a large `within`, then selected from with a larger `count`), and a
- * single branch or room reward (`candidateCells` scoped to one room, `count: 1`).
- *
- * @example
- * ```ts
- * import { candidateCells, cellsNear, selectDistinctCells } from '@datamoc/mw_games/roguelike';
- *
- * declare const level: import('@datamoc/mw_games/roguelike').Level;
- * const FLOOR = new Set([1]);
- *
- * // scatter 3 decorations anywhere on the floor
- * const pool = candidateCells(level, { terrain: FLOOR });
- * const { cells: decorations, trace } = selectDistinctCells(pool, 3);
- *
- * // then release 2 more items clustered around one of those cells
- * const nearby = cellsNear(level, decorations[0], 2).filter((c) => pool.includes(c));
- * const { cells: cluster } = selectDistinctCells(nearby, 2);
- * ```
- */
-export function selectDistinctCells(candidates, count) {
-    const pool = [...new Set(candidates)];
-    Random.shuffle(pool);
-    const cells = pool.slice(0, Math.max(0, count));
-    return { cells, trace: { requested: count, available: pool.length, selected: cells } };
-}
-function range(n) {
-    const out = new Array(n);
-    for (let i = 0; i < n; i++)
-        out[i] = i;
-    return out;
-}
-//# sourceMappingURL=Placement.js.map

package/dist/roguelike/Placement.js.map

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

package/dist/roguelike/RoomBuilders.d.ts

@@ -1,60 +0,0 @@
-import { Level, type Rect } from './Level.ts';
-/**
- * How one room's interior gets carved.
- *
- * The generator decides *where* rooms go and what joins them; a builder decides what a room
- * actually looks like once it has a rectangle to fill. That split is what makes them
- * composable: a game registers a hall, a pillared chamber, a circular vault and a flooded
- * cistern, and any floor is some mixture of them without the generator knowing what a pillar
- * or a cistern is. `mwg` ships exactly one builder (`hallBuilder`, a plain filled rectangle,
- * which is what the generator did unconditionally before builders existed) and expects a
- * game to bring the rest, the same boundary every other module here draws around content.
- */
-export interface RoomBuilder {
-    /** recorded per room in the generation result, for a parity trace or a game's own bookkeeping */
-    id: string;
-    /** relative weight against the other eligible builders; defaults to 1 */
-    weight?: number;
-    /** smallest room this builder can fill, in cells, on either axis */
-    minSize?: number;
-    /** largest room it can fill; a builder wanting only small rooms sets this */
-    maxSize?: number;
-    /** carves the room into the level. The rectangle is still solid when this is called */
-    paint(level: Level, room: Rect, floor: number): void;
-}
-/**
- * A plain filled rectangle: the generator's own original behaviour, as a builder.
- *
- * @example
- * ```ts
- * import { generateDungeon, hallBuilder, pickBuilder, eligibleBuilders, type RoomBuilder } from '@datamoc/mw_games/roguelike';
- *
- * const pillaredHall: RoomBuilder = {
- *   id: 'pillared',
- *   minSize: 6,
- *   paint(level, room, floor) {
- *     level.fillRect(room, floor); // then carve pillars into the interior, game-side
- *   },
- * };
- *
- * const level = generateDungeon({ width: 60, height: 40, builders: [hallBuilder, pillaredHall] });
- * ```
- */
-export declare const hallBuilder: RoomBuilder;
-/**
- * Which builders could fill this room at all, by size.
- *
- * `minSize` is checked against the room's *shorter* side and `maxSize` against its *longer*
- * one, so a builder never gets a rectangle it cannot fit its shape into, in either direction.
- */
-export declare function eligibleBuilders(builders: readonly RoomBuilder[], room: Rect): RoomBuilder[];
-/**
- * Picks a builder for one room, weighted among those that fit it.
- *
- * Returns `null` when nothing fits, which the generator treats as "fall back to a plain
- * hall" rather than leaving the room solid rock: a room already placed and joined by a
- * corridor has to be walkable, so an over-constrained builder list degrades to a plain room
- * instead of a sealed one a player can path into and never enter.
- */
-export declare function pickBuilder(builders: readonly RoomBuilder[], room: Rect): RoomBuilder | null;
-//# sourceMappingURL=RoomBuilders.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"RoomBuilders.d.ts","sourceRoot":"","sources":["../../src/roguelike/RoomBuilders.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,EAAE,KAAK,IAAI,EAAE,MAAM,YAAY,CAAC;AAE9C;;;;;;;;;;GAUG;AACH,MAAM,WAAW,WAAW;IAC3B,iGAAiG;IACjG,EAAE,EAAE,MAAM,CAAC;IAEX,yEAAyE;IACzE,MAAM,CAAC,EAAE,MAAM,CAAC;IAEhB,oEAAoE;IACpE,OAAO,CAAC,EAAE,MAAM,CAAC;IAEjB,6EAA6E;IAC7E,OAAO,CAAC,EAAE,MAAM,CAAC;IAEjB,uFAAuF;IACvF,KAAK,CAAC,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;CACrD;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,WAAW,EAAE,WAGzB,CAAC;AAUF;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,SAAS,WAAW,EAAE,EAAE,IAAI,EAAE,IAAI,GAAG,WAAW,EAAE,CAI5F;AAED;;;;;;;GAOG;AACH,wBAAgB,WAAW,CAAC,QAAQ,EAAE,SAAS,WAAW,EAAE,EAAE,IAAI,EAAE,IAAI,GAAG,WAAW,GAAG,IAAI,CAM5F"}

package/dist/roguelike/RoomBuilders.js

@@ -1,57 +0,0 @@
-import * as Random from '../core/Random.js';
-import { Level } from './Level.js';
-/**
- * A plain filled rectangle: the generator's own original behaviour, as a builder.
- *
- * @example
- * ```ts
- * import { generateDungeon, hallBuilder, pickBuilder, eligibleBuilders, type RoomBuilder } from '@datamoc/mw_games/roguelike';
- *
- * const pillaredHall: RoomBuilder = {
- *   id: 'pillared',
- *   minSize: 6,
- *   paint(level, room, floor) {
- *     level.fillRect(room, floor); // then carve pillars into the interior, game-side
- *   },
- * };
- *
- * const level = generateDungeon({ width: 60, height: 40, builders: [hallBuilder, pillaredHall] });
- * ```
- */
-export const hallBuilder = {
-    id: 'hall',
-    paint: (level, room, floor) => level.fillRect(room, floor),
-};
-function shorterSide(room) {
-    return Math.min(room.right - room.left + 1, room.bottom - room.top + 1);
-}
-function longerSide(room) {
-    return Math.max(room.right - room.left + 1, room.bottom - room.top + 1);
-}
-/**
- * Which builders could fill this room at all, by size.
- *
- * `minSize` is checked against the room's *shorter* side and `maxSize` against its *longer*
- * one, so a builder never gets a rectangle it cannot fit its shape into, in either direction.
- */
-export function eligibleBuilders(builders, room) {
-    const short = shorterSide(room);
-    const long = longerSide(room);
-    return builders.filter((builder) => short >= (builder.minSize ?? 0) && long <= (builder.maxSize ?? Infinity));
-}
-/**
- * Picks a builder for one room, weighted among those that fit it.
- *
- * Returns `null` when nothing fits, which the generator treats as "fall back to a plain
- * hall" rather than leaving the room solid rock: a room already placed and joined by a
- * corridor has to be walkable, so an over-constrained builder list degrades to a plain room
- * instead of a sealed one a player can path into and never enter.
- */
-export function pickBuilder(builders, room) {
-    const eligible = eligibleBuilders(builders, room);
-    if (eligible.length === 0)
-        return null;
-    const index = Random.weighted(eligible.map((builder) => builder.weight ?? 1));
-    return index === null ? null : eligible[index];
-}
-//# sourceMappingURL=RoomBuilders.js.map

package/dist/roguelike/RoomBuilders.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"RoomBuilders.js","sourceRoot":"","sources":["../../src/roguelike/RoomBuilders.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,mBAAmB,CAAC;AAC5C,OAAO,EAAE,KAAK,EAAa,MAAM,YAAY,CAAC;AA8B9C;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,CAAC,MAAM,WAAW,GAAgB;IACvC,EAAE,EAAE,MAAM;IACV,KAAK,EAAE,CAAC,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,QAAQ,CAAC,IAAI,EAAE,KAAK,CAAC;CAC1D,CAAC;AAEF,SAAS,WAAW,CAAC,IAAU;IAC9B,OAAO,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,IAAI,GAAG,CAAC,EAAE,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC;AACzE,CAAC;AAED,SAAS,UAAU,CAAC,IAAU;IAC7B,OAAO,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,IAAI,GAAG,CAAC,EAAE,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC;AACzE,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,gBAAgB,CAAC,QAAgC,EAAE,IAAU;IAC5E,MAAM,KAAK,GAAG,WAAW,CAAC,IAAI,CAAC,CAAC;IAChC,MAAM,IAAI,GAAG,UAAU,CAAC,IAAI,CAAC,CAAC;IAC9B,OAAO,QAAQ,CAAC,MAAM,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,KAAK,IAAI,CAAC,OAAO,CAAC,OAAO,IAAI,CAAC,CAAC,IAAI,IAAI,IAAI,CAAC,OAAO,CAAC,OAAO,IAAI,QAAQ,CAAC,CAAC,CAAC;AAC/G,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,WAAW,CAAC,QAAgC,EAAE,IAAU;IACvE,MAAM,QAAQ,GAAG,gBAAgB,CAAC,QAAQ,EAAE,IAAI,CAAC,CAAC;IAClD,IAAI,QAAQ,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,IAAI,CAAC;IAEvC,MAAM,KAAK,GAAG,MAAM,CAAC,QAAQ,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,OAAO,CAAC,MAAM,IAAI,CAAC,CAAC,CAAC,CAAC;IAC9E,OAAO,KAAK,KAAK,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;AAChD,CAAC"}

package/dist/roguelike/Scheduler.d.ts

@@ -1,96 +0,0 @@
-/**
- * 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.
- *
- * @example
- * ```ts
- * import { Scheduler, type Actor } from '@datamoc/mw_games/roguelike';
- *
- * interface Monster extends Actor { name: string }
- *
- * const scheduler = new Scheduler<Monster>();
- * scheduler.add({ name: 'hero', speed: 1 });
- * scheduler.add({ name: 'fast rat', speed: 2 }); // acts twice as often
- *
- * const acting = scheduler.peek(); // whoever's turn it is
- * scheduler.spend(1); // charge them for a normal-speed action, hand the turn on
- * ```
- */
-export interface Actor {
-    /** actions per unit of time; 2 acts twice as often as 1 */
-    speed?: number;
-    /** higher-priority actors resolve first when their scheduled times tie */
-    priority?: number;
-}
-/** A serialisable record of a scheduler's queue, keyed by caller-supplied actor ids. */
-export interface SchedulerSnapshot {
-    now: number;
-    sequence: number;
-    entries: Array<{
-        id: string;
-        time: number;
-        sequence: number;
-        priority?: 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.
-     * @param priority higher-priority actors resolve first when scheduled at the same time.
-     */
-    add(actor: A, delay?: number, priority?: 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. A cost of 0
-     * is a free action: the actor keeps its place at `now` but still goes behind any other
-     * actor already tied with it, since its sequence number is refreshed like any other spend.
-     */
-    spend(cost: number): void;
-    /**
-     * Pushes a specific actor's next turn back, independent of whose turn it currently is -
-     * a stun or slow effect landing on someone other than the current actor, for instance.
-     *
-     * @param delay time added to that actor's next scheduled turn
-     */
-    postpone(actor: A, delay: number): void;
-    /** the time at which an actor next acts, for a debug view or an interface */
-    timeOf(actor: A): number | null;
-    /**
-     * Captures the queue as plain data, identifying each actor by whatever id the caller
-     * assigns it - the scheduler holds actor references, not ids, so it cannot invent one
-     * itself.
-     */
-    toJSON(actorId: (actor: A) => string): SchedulerSnapshot;
-    /**
-     * Rebuilds a scheduler from a snapshot taken by `toJSON`, restoring `now` and the
-     * sequence counter so that ties among actors added afterwards resolve exactly as they
-     * would have if the scheduler had never been serialised.
-     *
-     * @param actorOf resolves a snapshot id back to the live actor object it names
-     */
-    static restore<A extends Actor>(snapshot: SchedulerSnapshot, actorOf: (id: string) => A): Scheduler<A>;
-    private sort;
-}
-//# sourceMappingURL=Scheduler.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"Scheduler.d.ts","sourceRoot":"","sources":["../../src/roguelike/Scheduler.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,MAAM,WAAW,KAAK;IACrB,2DAA2D;IAC3D,KAAK,CAAC,EAAE,MAAM,CAAC;IAEf,0EAA0E;IAC1E,QAAQ,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,wFAAwF;AACxF,MAAM,WAAW,iBAAiB;IACjC,GAAG,EAAE,MAAM,CAAC;IACZ,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,KAAK,CAAC;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CAClF;AAYD,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;;;;;;OAMG;IACH,GAAG,CAAC,KAAK,EAAE,CAAC,EAAE,KAAK,SAAI,EAAE,QAAQ,SAAsB,GAAG,IAAI,CAK7D;IAED,MAAM,CAAC,KAAK,EAAE,CAAC,GAAG,IAAI,CAGrB;IAED,KAAK,IAAI,IAAI,CAIZ;IAED,4EAA4E;IAC5E,IAAI,IAAI,CAAC,GAAG,IAAI,CAOf;IAED;;;;;;OAMG;IACH,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CASxB;IAED;;;;;OAKG;IACH,QAAQ,CAAC,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAOtC;IAED,6EAA6E;IAC7E,MAAM,CAAC,KAAK,EAAE,CAAC,GAAG,MAAM,GAAG,IAAI,CAE9B;IAED;;;;OAIG;IACH,MAAM,CAAC,OAAO,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,MAAM,GAAG,iBAAiB,CAWvD;IAED;;;;;;OAMG;IACH,MAAM,CAAC,OAAO,CAAC,CAAC,SAAS,KAAK,EAAE,QAAQ,EAAE,iBAAiB,EAAE,OAAO,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,CAAC,GAAG,SAAS,CAAC,CAAC,CAAC,CAYrG;IAED,OAAO,CAAC,IAAI;CAKZ"}