@datamoc/mw_games 0.43.0 → 0.45.0

package/dist/roguelike/Features.js

@@ -1,76 +0,0 @@
-/**
- * @example
- * ```ts
- * import { FeatureLayer } from '@datamoc/mw_games/roguelike';
- *
- * const features = new FeatureLayer<{ hp: number }>();
- * features.define('trap', {
- *   interact: () => true,
- *   consequence: (_cell, ctx) => { ctx.hp -= 5; },
- *   persistent: false, // sprung once, then gone
- * });
- *
- * features.place(42, 'trap');
- * const hero = { hp: 20 };
- * features.interact(42, hero); // hero.hp is now 15, and the trap is gone
- * ```
- */
-export class FeatureLayer {
-    constructor() {
-        this.defs = new Map();
-        this.placed = new Map();
-    }
-    /** registers what a named kind does; call again to replace it, e.g. after loading a save */
-    define(kind, def) {
-        this.defs.set(kind, def);
-    }
-    /** places a defined kind onto a cell, replacing whatever was there */
-    place(cell, kind) {
-        if (!this.defs.has(kind))
-            throw new Error(`FeatureLayer.place: no definition for kind "${kind}"`);
-        this.placed.set(cell, kind);
-    }
-    has(cell) {
-        return this.placed.has(cell);
-    }
-    kindAt(cell) {
-        return this.placed.get(cell);
-    }
-    remove(cell) {
-        this.placed.delete(cell);
-    }
-    /** looking at or searching the cell; a no-op on a cell with no feature or no `inspect` rule */
-    inspect(cell, ctx) {
-        const def = this.defAt(cell);
-        def?.inspect?.(cell, ctx);
-    }
-    /** using or stepping on the cell; runs `interact` then, unless refused, `consequence` */
-    interact(cell, ctx) {
-        const def = this.defAt(cell);
-        if (!def)
-            return;
-        const allowed = def.interact ? def.interact(cell, ctx) !== false : true;
-        if (!allowed)
-            return;
-        def.consequence?.(cell, ctx);
-        if (def.persistent === false)
-            this.remove(cell);
-    }
-    defAt(cell) {
-        const kind = this.placed.get(cell);
-        return kind === undefined ? undefined : this.defs.get(kind);
-    }
-    /** only which cell has which kind is save data; definitions are supplied fresh on load */
-    toJSON() {
-        return { cells: [...this.placed.entries()] };
-    }
-    static fromJSON(defs, data) {
-        const layer = new FeatureLayer();
-        for (const [kind, def] of defs)
-            layer.define(kind, def);
-        for (const [cell, kind] of data.cells)
-            layer.place(cell, kind);
-        return layer;
-    }
-}
-//# sourceMappingURL=Features.js.map

package/dist/roguelike/Features.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"Features.js","sourceRoot":"","sources":["../../src/roguelike/Features.ts"],"names":[],"mappings":"AAsBA;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,OAAO,YAAY;IAAzB;QACS,SAAI,GAAG,IAAI,GAAG,EAAoC,CAAC;QACnD,WAAM,GAAG,IAAI,GAAG,EAAkB,CAAC;IA8D5C,CAAC;IA5DA,4FAA4F;IAC5F,MAAM,CAAC,IAAY,EAAE,GAA6B;QACjD,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC;IAC1B,CAAC;IAED,sEAAsE;IACtE,KAAK,CAAC,IAAY,EAAE,IAAY;QAC/B,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC;YAAE,MAAM,IAAI,KAAK,CAAC,+CAA+C,IAAI,GAAG,CAAC,CAAC;QAClG,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;IAC7B,CAAC;IAED,GAAG,CAAC,IAAY;QACf,OAAO,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;IAC9B,CAAC;IAED,MAAM,CAAC,IAAY;QAClB,OAAO,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;IAC9B,CAAC;IAED,MAAM,CAAC,IAAY;QAClB,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;IAC1B,CAAC;IAED,+FAA+F;IAC/F,OAAO,CAAC,IAAY,EAAE,GAAa;QAClC,MAAM,GAAG,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;QAC7B,GAAG,EAAE,OAAO,EAAE,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC;IAC3B,CAAC;IAED,yFAAyF;IACzF,QAAQ,CAAC,IAAY,EAAE,GAAa;QACnC,MAAM,GAAG,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;QAC7B,IAAI,CAAC,GAAG;YAAE,OAAO;QAEjB,MAAM,OAAO,GAAG,GAAG,CAAC,QAAQ,CAAC,CAAC,CAAC,GAAG,CAAC,QAAQ,CAAC,IAAI,EAAE,GAAG,CAAC,KAAK,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC;QACxE,IAAI,CAAC,OAAO;YAAE,OAAO;QAErB,GAAG,CAAC,WAAW,EAAE,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC;QAC7B,IAAI,GAAG,CAAC,UAAU,KAAK,KAAK;YAAE,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;IACjD,CAAC;IAEO,KAAK,CAAC,IAAY;QACzB,MAAM,IAAI,GAAG,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QACnC,OAAO,IAAI,KAAK,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;IAC7D,CAAC;IAED,0FAA0F;IAC1F,MAAM;QACL,OAAO,EAAE,KAAK,EAAE,CAAC,GAAG,IAAI,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC,EAAE,CAAC;IAC9C,CAAC;IAED,MAAM,CAAC,QAAQ,CACd,IAA4C,EAC5C,IAAmC;QAEnC,MAAM,KAAK,GAAG,IAAI,YAAY,EAAK,CAAC;QACpC,KAAK,MAAM,CAAC,IAAI,EAAE,GAAG,CAAC,IAAI,IAAI;YAAE,KAAK,CAAC,MAAM,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC;QACxD,KAAK,MAAM,CAAC,IAAI,EAAE,IAAI,CAAC,IAAI,IAAI,CAAC,KAAK;YAAE,KAAK,CAAC,KAAK,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;QAC/D,OAAO,KAAK,CAAC;IACd,CAAC;CACD"}

package/dist/roguelike/FieldOfView.d.ts

@@ -1,86 +0,0 @@
-import type { Level } from './Level.ts';
-import type { Elevation } from './Elevation.ts';
-/**
- * What the player can see, and what they remember seeing.
- *
- * Two sets, because a roguelike map has three states and not two: lit and in view,
- * remembered but not currently seen, and never visited. The middle one is the whole reason
- * exploring a dungeon feels like exploring: the map you have built stays on screen while
- * what is happening on it does not.
- *
- * The shadowcasting itself comes from rot.js on a square `Level`, which has had these edge
- * cases beaten out of it over years - what is here around it is the memory. rot.js has
- * nothing hex-shaped, so a hex `Level` instead traces a straight line (`hexLine`) to every
- * cell in range and lights it if nothing along the way is opaque: simple line-of-sight,
- * deliberately not true shadowcasting, which is the v1 this roadmap item commits to.
- */
-/**
- * Sight from a height: the viewer's elevation, for maps with an `Elevation`.
- *
- * A cliff hides what is behind it from below but not from above - an intervening
- * cell blocks exactly when it rises above both ends of the gaze. `height`
- * defaults to the height of the cell stood on; a flying or perched viewer passes
- * its own.
- */
-export interface HeightSight {
-    heights: Elevation;
-    height?: number;
-}
-/**
- * @example
- * ```ts
- * import { FieldOfView, Level, WALL, FLOOR } from '@datamoc/mw_games/roguelike';
- *
- * const level = new Level(20, 20, [WALL, FLOOR], 1);
- * const fov = new FieldOfView(level);
- *
- * fov.update(5, 5, 8); // the hero's own sight, radius 8
- * console.log(fov.visible.has(level.index(6, 5))); // true - lit right now
- * console.log(fov.explored.has(level.index(6, 5))); // true - stays remembered after leaving
- * ```
- */
-export declare class FieldOfView {
-    private level;
-    private fov;
-    /** cells currently in view */
-    readonly visible: Set<number>;
-    /** cells ever seen, which is what gets drawn dim */
-    readonly explored: Set<number>;
-    /** how bright each visible cell is, 0 to 1, by cell index */
-    readonly light: Map<number, number>;
-    constructor(level: Level);
-    /**
-     * Recomputes what is visible from a point.
-     *
-     * @param radius how far light reaches, in cells. When omitted, the level's `viewDistance`
-     * is used, falling back to the larger level dimension.
-     * @param sight when given, sight is height-aware: every cell in range is
-     * tested along the straight line to it, blocked by opaque terrain or by a
-     * cell rising above viewer and target alike. That is line-of-sight per cell
-     * rather than shadowcasting, so its edges deliberately disagree with the
-     * flat computation in the same way targeting already does - rot.js's
-     * callback only ever sees the blocking cell, never the target, so the
-     * viewer-relative rule cannot live inside it.
-     */
-    update(x: number, y: number, radius?: number, sight?: HeightSight): void;
-    /** lights one visible cell with the usual distance falloff */
-    private lightCell;
-    /** height-aware sight for both shapes: one straight line per cell, one rule for cliffs */
-    private updateFromHeight;
-    /**
-     * Whether anything between the line's ends blocks a gaze from `viewer` height
-     * to `target` height: opaque terrain always does, and so does a cell rising
-     * above them both. Heights only ever add blocking - a wall still reads as a
-     * wall from above.
-     */
-    private heightBlocked;
-    isVisible(x: number, y: number): boolean;
-    isExplored(x: number, y: number): boolean;
-    /** how lit a cell is right now, 0 when out of view */
-    lightAt(x: number, y: number): number;
-    /** forgets everything, as a new floor should */
-    reset(): void;
-    /** reveals the whole map, for a magic mapping effect or a debug view */
-    revealAll(): void;
-}
-//# sourceMappingURL=FieldOfView.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"FieldOfView.d.ts","sourceRoot":"","sources":["../../src/roguelike/FieldOfView.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACxC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAIhD;;;;;;;;;;;;;GAaG;AACH;;;;;;;GAOG;AACH,MAAM,WAAW,WAAW;IAC3B,OAAO,EAAE,SAAS,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,CAAC;CAChB;AAED;;;;;;;;;;;;GAYG;AACH,qBAAa,WAAW;IACvB,OAAO,CAAC,KAAK,CAAQ;IAGrB,OAAO,CAAC,GAAG,CAAuD;IAElE,8BAA8B;IAC9B,QAAQ,CAAC,OAAO,cAAqB;IAErC,oDAAoD;IACpD,QAAQ,CAAC,QAAQ,cAAqB;IAEtC,6DAA6D;IAC7D,QAAQ,CAAC,KAAK,sBAA6B;IAE3C,YAAY,KAAK,EAAE,KAAK,EAGvB;IAED;;;;;;;;;;;;OAYG;IACH,MAAM,CACL,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,MAAM,SAA2E,EACjF,KAAK,CAAC,EAAE,WAAW,GACjB,IAAI,CAmCN;IAED,8DAA8D;IAC9D,OAAO,CAAC,SAAS;IAOjB,0FAA0F;IAC1F,OAAO,CAAC,gBAAgB;IA0BxB;;;;;OAKG;IACH,OAAO,CAAC,aAAa;IAerB,SAAS,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,OAAO,CAEvC;IAED,UAAU,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,OAAO,CAExC;IAED,sDAAsD;IACtD,OAAO,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAEpC;IAED,gDAAgD;IAChD,KAAK,IAAI,IAAI,CAIZ;IAED,wEAAwE;IACxE,SAAS,IAAI,IAAI,CAEhB;CACD"}

package/dist/roguelike/FieldOfView.js

@@ -1,148 +0,0 @@
-import { FOV } from 'rot-js';
-import { hexRange, hexLine } from '../core/Hex.js';
-import { chebyshevDistance, traceLine } from './Targeting.js';
-/**
- * @example
- * ```ts
- * import { FieldOfView, Level, WALL, FLOOR } from '@datamoc/mw_games/roguelike';
- *
- * const level = new Level(20, 20, [WALL, FLOOR], 1);
- * const fov = new FieldOfView(level);
- *
- * fov.update(5, 5, 8); // the hero's own sight, radius 8
- * console.log(fov.visible.has(level.index(6, 5))); // true - lit right now
- * console.log(fov.explored.has(level.index(6, 5))); // true - stays remembered after leaving
- * ```
- */
-export class FieldOfView {
-    constructor(level) {
-        /** cells currently in view */
-        this.visible = new Set();
-        /** cells ever seen, which is what gets drawn dim */
-        this.explored = new Set();
-        /** how bright each visible cell is, 0 to 1, by cell index */
-        this.light = new Map();
-        this.level = level;
-        this.fov = level.shape === 'hex' ? null : new FOV.PreciseShadowcasting((x, y) => level.transparent(x, y));
-    }
-    /**
-     * Recomputes what is visible from a point.
-     *
-     * @param radius how far light reaches, in cells. When omitted, the level's `viewDistance`
-     * is used, falling back to the larger level dimension.
-     * @param sight when given, sight is height-aware: every cell in range is
-     * tested along the straight line to it, blocked by opaque terrain or by a
-     * cell rising above viewer and target alike. That is line-of-sight per cell
-     * rather than shadowcasting, so its edges deliberately disagree with the
-     * flat computation in the same way targeting already does - rot.js's
-     * callback only ever sees the blocking cell, never the target, so the
-     * viewer-relative rule cannot live inside it.
-     */
-    update(x, y, radius = this.level.viewDistance ?? Math.max(this.level.width, this.level.height), sight) {
-        this.visible.clear();
-        this.light.clear();
-        if (sight) {
-            this.updateFromHeight(x, y, radius, sight);
-            return;
-        }
-        if (this.fov) {
-            this.fov.compute(x, y, radius, (cx, cy, _r, visibility) => {
-                if (!this.level.inside(cx, cy))
-                    return;
-                const cell = this.level.index(cx, cy);
-                this.visible.add(cell);
-                this.explored.add(cell);
-                this.light.set(cell, visibility);
-            });
-            return;
-        }
-        const center = { x, y };
-        for (const target of hexRange(center, radius)) {
-            if (!this.level.inside(target.x, target.y))
-                continue;
-            const line = hexLine(center, target);
-            //every cell between the two ends must be transparent; the two ends themselves
-            //need not be, the same rule `hasLineOfSight` uses for a square grid
-            const blocked = line
-                .slice(1, -1)
-                .some((cell) => !this.level.inside(cell.x, cell.y) || !this.level.transparent(cell.x, cell.y));
-            if (blocked)
-                continue;
-            this.lightCell(target.x, target.y, line.length - 1, radius);
-        }
-    }
-    /** lights one visible cell with the usual distance falloff */
-    lightCell(x, y, distance, radius) {
-        const cell = this.level.index(x, y);
-        this.visible.add(cell);
-        this.explored.add(cell);
-        this.light.set(cell, radius === 0 ? 1 : Math.max(0, 1 - distance / (radius + 1)));
-    }
-    /** height-aware sight for both shapes: one straight line per cell, one rule for cliffs */
-    updateFromHeight(x, y, radius, sight) {
-        const viewer = sight.height ?? sight.heights.heightAt(x, y);
-        const center = { x, y };
-        if (this.level.shape === 'hex') {
-            for (const target of hexRange(center, radius)) {
-                if (!this.level.inside(target.x, target.y))
-                    continue;
-                const line = hexLine(center, target);
-                if (this.heightBlocked(line, sight.heights, viewer, sight.heights.heightAt(target.x, target.y)))
-                    continue;
-                this.lightCell(target.x, target.y, line.length - 1, radius);
-            }
-            return;
-        }
-        for (let ty = y - radius; ty <= y + radius; ty++) {
-            for (let tx = x - radius; tx <= x + radius; tx++) {
-                if (!this.level.inside(tx, ty))
-                    continue;
-                if (chebyshevDistance(center, { x: tx, y: ty }) > radius)
-                    continue;
-                const line = traceLine(center, { x: tx, y: ty });
-                if (this.heightBlocked(line, sight.heights, viewer, sight.heights.heightAt(tx, ty)))
-                    continue;
-                this.lightCell(tx, ty, line.length - 1, radius);
-            }
-        }
-    }
-    /**
-     * Whether anything between the line's ends blocks a gaze from `viewer` height
-     * to `target` height: opaque terrain always does, and so does a cell rising
-     * above them both. Heights only ever add blocking - a wall still reads as a
-     * wall from above.
-     */
-    heightBlocked(line, heights, viewer, target) {
-        const top = Math.max(viewer, target);
-        for (let i = 1; i < line.length - 1; i++) {
-            const cell = line[i];
-            if (!this.level.inside(cell.x, cell.y) || !this.level.transparent(cell.x, cell.y))
-                return true;
-            if (heights.heightAt(cell.x, cell.y) > top)
-                return true;
-        }
-        return false;
-    }
-    isVisible(x, y) {
-        return this.visible.has(this.level.index(x, y));
-    }
-    isExplored(x, y) {
-        return this.explored.has(this.level.index(x, y));
-    }
-    /** how lit a cell is right now, 0 when out of view */
-    lightAt(x, y) {
-        return this.light.get(this.level.index(x, y)) ?? 0;
-    }
-    /** forgets everything, as a new floor should */
-    reset() {
-        this.visible.clear();
-        this.explored.clear();
-        this.light.clear();
-    }
-    /** reveals the whole map, for a magic mapping effect or a debug view */
-    revealAll() {
-        for (let i = 0; i < this.level.cellCount; i++)
-            this.explored.add(i);
-    }
-}
-//# sourceMappingURL=FieldOfView.js.map

package/dist/roguelike/FieldOfView.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"FieldOfView.js","sourceRoot":"","sources":["../../src/roguelike/FieldOfView.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,QAAQ,CAAC;AAG7B,OAAO,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAC;AACnD,OAAO,EAAE,iBAAiB,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AA6B9D;;;;;;;;;;;;GAYG;AACH,MAAM,OAAO,WAAW;IAevB,YAAY,KAAY;QATxB,8BAA8B;QACrB,YAAO,GAAG,IAAI,GAAG,EAAU,CAAC;QAErC,oDAAoD;QAC3C,aAAQ,GAAG,IAAI,GAAG,EAAU,CAAC;QAEtC,6DAA6D;QACpD,UAAK,GAAG,IAAI,GAAG,EAAkB,CAAC;QAG1C,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;QACnB,IAAI,CAAC,GAAG,GAAG,KAAK,CAAC,KAAK,KAAK,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,GAAG,CAAC,oBAAoB,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;IAC3G,CAAC;IAED;;;;;;;;;;;;OAYG;IACH,MAAM,CACL,CAAS,EACT,CAAS,EACT,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,YAAY,IAAI,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,EAAE,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,EACjF,KAAmB;QAEnB,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE,CAAC;QACrB,IAAI,CAAC,KAAK,CAAC,KAAK,EAAE,CAAC;QAEnB,IAAI,KAAK,EAAE,CAAC;YACX,IAAI,CAAC,gBAAgB,CAAC,CAAC,EAAE,CAAC,EAAE,MAAM,EAAE,KAAK,CAAC,CAAC;YAC3C,OAAO;QACR,CAAC;QAED,IAAI,IAAI,CAAC,GAAG,EAAE,CAAC;YACd,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAU,EAAE,EAAU,EAAE,EAAU,EAAE,UAAkB,EAAE,EAAE;gBACzF,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,EAAE,EAAE,EAAE,CAAC;oBAAE,OAAO;gBAEvC,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC;gBACtC,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;gBACvB,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;gBACxB,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,IAAI,EAAE,UAAU,CAAC,CAAC;YAClC,CAAC,CAAC,CAAC;YACH,OAAO;QACR,CAAC;QAED,MAAM,MAAM,GAAG,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC;QACxB,KAAK,MAAM,MAAM,IAAI,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,CAAC;YAC/C,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC,CAAC;gBAAE,SAAS;YAErD,MAAM,IAAI,GAAG,OAAO,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;YACrC,8EAA8E;YAC9E,oEAAoE;YACpE,MAAM,OAAO,GAAG,IAAI;iBAClB,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;iBACZ,IAAI,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;YAChG,IAAI,OAAO;gBAAE,SAAS;YAEtB,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC,EAAE,IAAI,CAAC,MAAM,GAAG,CAAC,EAAE,MAAM,CAAC,CAAC;QAC7D,CAAC;IACF,CAAC;IAED,8DAA8D;IACtD,SAAS,CAAC,CAAS,EAAE,CAAS,EAAE,QAAgB,EAAE,MAAc;QACvE,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;QACpC,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QACvB,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QACxB,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,IAAI,EAAE,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,GAAG,QAAQ,GAAG,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;IACnF,CAAC;IAED,0FAA0F;IAClF,gBAAgB,CAAC,CAAS,EAAE,CAAS,EAAE,MAAc,EAAE,KAAkB;QAChF,MAAM,MAAM,GAAG,KAAK,CAAC,MAAM,IAAI,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;QAC5D,MAAM,MAAM,GAAG,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC;QAExB,IAAI,IAAI,CAAC,KAAK,CAAC,KAAK,KAAK,KAAK,EAAE,CAAC;YAChC,KAAK,MAAM,MAAM,IAAI,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,CAAC;gBAC/C,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC,CAAC;oBAAE,SAAS;gBACrD,MAAM,IAAI,GAAG,OAAO,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;gBACrC,IAAI,IAAI,CAAC,aAAa,CAAC,IAAI,EAAE,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC;oBAC9F,SAAS;gBACV,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC,EAAE,IAAI,CAAC,MAAM,GAAG,CAAC,EAAE,MAAM,CAAC,CAAC;YAC7D,CAAC;YACD,OAAO;QACR,CAAC;QAED,KAAK,IAAI,EAAE,GAAG,CAAC,GAAG,MAAM,EAAE,EAAE,IAAI,CAAC,GAAG,MAAM,EAAE,EAAE,EAAE,EAAE,CAAC;YAClD,KAAK,IAAI,EAAE,GAAG,CAAC,GAAG,MAAM,EAAE,EAAE,IAAI,CAAC,GAAG,MAAM,EAAE,EAAE,EAAE,EAAE,CAAC;gBAClD,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,EAAE,EAAE,EAAE,CAAC;oBAAE,SAAS;gBACzC,IAAI,iBAAiB,CAAC,MAAM,EAAE,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,GAAG,MAAM;oBAAE,SAAS;gBACnE,MAAM,IAAI,GAAG,SAAS,CAAC,MAAM,EAAE,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC;gBACjD,IAAI,IAAI,CAAC,aAAa,CAAC,IAAI,EAAE,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC;oBAAE,SAAS;gBAC9F,IAAI,CAAC,SAAS,CAAC,EAAE,EAAE,EAAE,EAAE,IAAI,CAAC,MAAM,GAAG,CAAC,EAAE,MAAM,CAAC,CAAC;YACjD,CAAC;QACF,CAAC;IACF,CAAC;IAED;;;;;OAKG;IACK,aAAa,CACpB,IAAqC,EACrC,OAAkB,EAClB,MAAc,EACd,MAAc;QAEd,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;QACrC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;YAC1C,MAAM,IAAI,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC;YACrB,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC;gBAAE,OAAO,IAAI,CAAC;YAC/F,IAAI,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC,GAAG,GAAG;gBAAE,OAAO,IAAI,CAAC;QACzD,CAAC;QACD,OAAO,KAAK,CAAC;IACd,CAAC;IAED,SAAS,CAAC,CAAS,EAAE,CAAS;QAC7B,OAAO,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;IACjD,CAAC;IAED,UAAU,CAAC,CAAS,EAAE,CAAS;QAC9B,OAAO,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;IAClD,CAAC;IAED,sDAAsD;IACtD,OAAO,CAAC,CAAS,EAAE,CAAS;QAC3B,OAAO,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;IACpD,CAAC;IAED,gDAAgD;IAChD,KAAK;QACJ,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE,CAAC;QACrB,IAAI,CAAC,QAAQ,CAAC,KAAK,EAAE,CAAC;QACtB,IAAI,CAAC,KAAK,CAAC,KAAK,EAAE,CAAC;IACpB,CAAC;IAED,wEAAwE;IACxE,SAAS;QACR,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,SAAS,EAAE,CAAC,EAAE;YAAE,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;IACrE,CAAC;CACD"}

package/dist/roguelike/Level.d.ts

@@ -1,139 +0,0 @@
-/**
- * The map a roguelike reasons about.
- *
- * Deliberately separate from `TileMap`, which is how a map is *drawn*. This one holds what
- * the algorithms need (can something walk here, can light pass) and nothing about
- * appearance. A game maps its own terrain kinds onto these two flags, so it can invent
- * whatever terrain it likes without the framework knowing about lava or bookshelves.
- */
-/** the grid a `Level` reasons over - a parameter, not a forked class, per the roadmap */
-export type LevelShape = 'square' | 'hex';
-/** the four or eight cell offsets around a point: the shared `core` tables, returned as-is */
-export declare function neighbourOffsets(topology: 4 | 8): ReadonlyArray<readonly [number, number]>;
-export interface TerrainKind {
-    /** can a creature walk onto it */
-    passable: boolean;
-    /** can something be seen through it */
-    transparent: boolean;
-    /** optional game-defined bit flags, carried without interpretation by MWG */
-    flags?: number;
-    /** optional game-defined boolean properties, carried without interpretation by MWG */
-    extras?: Readonly<Record<string, boolean>>;
-}
-/**
- * The two terrain kinds every map needs; a game adds its own alongside.
- *
- * @example
- * ```ts
- * import { Level, WALL, FLOOR } from '@datamoc/mw_games/roguelike';
- *
- * const level = new Level(20, 15, [WALL, FLOOR], 0); // 0 = WALL, everything starts solid
- * level.set(5, 5, 1); // 1 = FLOOR
- * console.log(level.passable(5, 5)); // true
- * ```
- */
-export declare const WALL: TerrainKind;
-export declare const FLOOR: TerrainKind;
-export interface Rect {
-    left: number;
-    top: number;
-    right: number;
-    bottom: number;
-}
-export declare class Level {
-    readonly width: number;
-    readonly height: number;
-    readonly shape: LevelShape;
-    /** default sight radius for observers that do not provide one explicitly */
-    viewDistance?: number;
-    /** terrain id per cell, indexing into `kinds` */
-    readonly terrain: Uint8Array;
-    private kinds;
-    /** rooms the generator carved, for placing stairs, monsters and treasure */
-    rooms: Rect[];
-    constructor(width: number, height: number, kinds: TerrainKind[], fill?: number, shape?: LevelShape, viewDistance?: number);
-    get cellCount(): number;
-    index(x: number, y: number): number;
-    xOf(cell: number): number;
-    yOf(cell: number): number;
-    inside(x: number, y: number): boolean;
-    /**
-     * 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: number, y: number, topology?: 4 | 8): Array<{
-        x: number;
-        y: number;
-    }>;
-    /**
-     * The same neighbourhood as `neighbors`, but calling `visit(nx, ny)` per cell instead
-     * of building an array of them - the flood fills in `Pathfinder` call this per popped
-     * cell, where the array plus one object per neighbour was the hottest GC churn in the
-     * module (tens of thousands of short-lived objects per map). Anything that keeps a
-     * neighbour past the call still wants `neighbors`; this is for visit-and-forget loops.
-     *
-     * @param topology ignored on a hex `Level` - it only has the one neighbourhood shape
-     */
-    forEachNeighbor(x: number, y: number, topology: 4 | 8, visit: (nx: number, ny: number) => void): void;
-    /**
-     * 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: number, y: number): boolean;
-    get(x: number, y: number): number;
-    set(x: number, y: number, kind: number): void;
-    kindAt(x: number, y: number): TerrainKind;
-    passable(x: number, y: number): boolean;
-    transparent(x: number, y: number): boolean;
-    fillRect(rect: Rect, kind: number): void;
-    /** every passable cell, as indices: the pool to place things in */
-    passableCells(): number[];
-    toJSON(): {
-        width: number;
-        height: number;
-        shape: LevelShape;
-        terrain: number[];
-        rooms: Rect[];
-        viewDistance?: number;
-    };
-    /**
-     * 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: TerrainKind[], data: {
-        width: number;
-        height: number;
-        shape: LevelShape;
-        terrain: number[];
-        rooms: Rect[];
-        viewDistance?: number;
-    }): Level;
-}
-export declare function rectCenter(rect: Rect): {
-    x: number;
-    y: number;
-};
-/**
- * Whether two rectangles overlap, optionally requiring `margin` cells of clearance between
- * them - the check `generateDungeon` itself uses so rooms never end up sharing a wall.
- *
- * @example
- * ```ts
- * import { rectsOverlap } from '@datamoc/mw_games/roguelike';
- *
- * const roomA = { left: 0, top: 0, right: 4, bottom: 4 };
- * const roomB = { left: 5, top: 0, right: 9, bottom: 4 };
- * rectsOverlap(roomA, roomB); // false - adjacent, not overlapping
- * rectsOverlap(roomA, roomB, 2); // true - too close with a 2-cell margin required
- * ```
- */
-export declare function rectsOverlap(a: Rect, b: Rect, margin?: number): boolean;
-//# sourceMappingURL=Level.d.ts.map

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

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

package/dist/roguelike/Level.js

@@ -1,189 +0,0 @@
-import { hexNeighbors } from '../core/Hex.js';
-import { cellIndex, cellInside, cellX, cellY, CIRCLE8, NEIGHBOURS4 } from '../core/Grid.js';
-/**
- * The six hex offsets, split by column parity: the odd-q scheme pushes odd columns half a
- * row down, so "same direction, one row over" depends on which column starts the step.
- * Derived from the cube directions in `core/Hex.ts` (same order, so floods visit cells in
- * the same sequence `hexNeighbors` would), and locked to it by the parity test in
- * `tests/hex.test.ts` - if either table ever disagrees there, the table is wrong, not the
- * cube math.
- */
-const HEX_OFFSETS_EVEN = [
-    [1, 0],
-    [1, -1],
-    [0, -1],
-    [-1, -1],
-    [-1, 0],
-    [0, 1],
-];
-const HEX_OFFSETS_ODD = [
-    [1, 1],
-    [1, 0],
-    [0, -1],
-    [-1, 0],
-    [-1, 1],
-    [0, 1],
-];
-/** the four or eight cell offsets around a point: the shared `core` tables, returned as-is */
-export function neighbourOffsets(topology) {
-    return topology === 4 ? NEIGHBOURS4 : CIRCLE8;
-}
-/**
- * The two terrain kinds every map needs; a game adds its own alongside.
- *
- * @example
- * ```ts
- * import { Level, WALL, FLOOR } from '@datamoc/mw_games/roguelike';
- *
- * const level = new Level(20, 15, [WALL, FLOOR], 0); // 0 = WALL, everything starts solid
- * level.set(5, 5, 1); // 1 = FLOOR
- * console.log(level.passable(5, 5)); // true
- * ```
- */
-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', viewDistance) {
-        /** rooms the generator carved, for placing stairs, monsters and treasure */
-        this.rooms = [];
-        this.width = width;
-        this.shape = shape;
-        this.height = height;
-        if (viewDistance !== undefined && (!Number.isFinite(viewDistance) || viewDistance < 0))
-            throw new Error('viewDistance must be a finite non-negative number');
-        this.viewDistance = viewDistance;
-        this.kinds = kinds;
-        this.terrain = new Uint8Array(width * height).fill(fill);
-    }
-    get cellCount() {
-        return this.width * this.height;
-    }
-    index(x, y) {
-        return cellIndex(this.width, x, y);
-    }
-    xOf(cell) {
-        return cellX(this.width, cell);
-    }
-    yOf(cell) {
-        return cellY(this.width, cell);
-    }
-    inside(x, y) {
-        return cellInside(this.width, this.height, x, y);
-    }
-    /**
-     * 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 }));
-    }
-    /**
-     * The same neighbourhood as `neighbors`, but calling `visit(nx, ny)` per cell instead
-     * of building an array of them - the flood fills in `Pathfinder` call this per popped
-     * cell, where the array plus one object per neighbour was the hottest GC churn in the
-     * module (tens of thousands of short-lived objects per map). Anything that keeps a
-     * neighbour past the call still wants `neighbors`; this is for visit-and-forget loops.
-     *
-     * @param topology ignored on a hex `Level` - it only has the one neighbourhood shape
-     */
-    forEachNeighbor(x, y, topology, visit) {
-        const offsets = this.shape === 'hex' ? ((x & 1) === 0 ? HEX_OFFSETS_EVEN : HEX_OFFSETS_ODD) : neighbourOffsets(topology);
-        for (const [dx, dy] of offsets)
-            visit(x + dx, 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 })),
-            ...(this.viewDistance === undefined ? {} : { viewDistance: this.viewDistance }),
-        };
-    }
-    /**
-     * 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, data.viewDistance);
-        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),
-    };
-}
-/**
- * Whether two rectangles overlap, optionally requiring `margin` cells of clearance between
- * them - the check `generateDungeon` itself uses so rooms never end up sharing a wall.
- *
- * @example
- * ```ts
- * import { rectsOverlap } from '@datamoc/mw_games/roguelike';
- *
- * const roomA = { left: 0, top: 0, right: 4, bottom: 4 };
- * const roomB = { left: 5, top: 0, right: 9, bottom: 4 };
- * rectsOverlap(roomA, roomB); // false - adjacent, not overlapping
- * rectsOverlap(roomA, roomB, 2); // true - too close with a 2-cell margin required
- * ```
- */
-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