@datamoc/mw_games 0.1.1

package/dist/core/Hex.js

@@ -0,0 +1,120 @@
+/**
+ * Flat-top hexagon geometry, addressed the same way a square grid is: `x` the column, `y`
+ * the row, both integers - which is what lets `mwg/roguelike`'s `Level` (grid logic) and
+ * `mwg/render`'s `TileMap` (pixel positions) each reuse it without depending on the other.
+ * It lives in `mwg/core` for exactly that reason: neither of those two modules is allowed
+ * to depend on the other, and this needs to sit below both.
+ *
+ * Internally this converts to and from cube coordinates (`x + y + z = 0`) for every
+ * calculation, because the six neighbour directions are then a fixed, orientation-agnostic
+ * list rather than a column-parity-dependent table someone has to get right twice. The
+ * offset "odd-q" scheme below - odd columns pushed half a row down - is what makes that
+ * cube math round-trip back to integers; nothing about it is rot.js's, which is deliberate
+ * (see the roadmap: rot.js's own hex `Path` topology is doubled-width coordinates built for
+ * *pointy-top* hexagons, and does not match this orientation).
+ */
+function toCube(x, y) {
+    const cx = x;
+    const cz = y - (x - (x & 1)) / 2;
+    return { x: cx, y: -cx - cz, z: cz };
+}
+function fromCube(cube) {
+    const x = cube.x;
+    const y = cube.z + (cube.x - (cube.x & 1)) / 2;
+    return { x, y };
+}
+//the six cube directions - orientation-agnostic, and each other's negation in pairs, which
+//is what makes the neighbour relation below symmetric by construction
+const CUBE_DIRECTIONS = [
+    { x: 1, y: -1, z: 0 },
+    { x: 1, y: 0, z: -1 },
+    { x: 0, y: 1, z: -1 },
+    { x: -1, y: 1, z: 0 },
+    { x: -1, y: 0, z: 1 },
+    { x: 0, y: -1, z: 1 },
+];
+/** the six cells sharing an edge with `(x, y)` */
+export function hexNeighbors(x, y) {
+    const cube = toCube(x, y);
+    return CUBE_DIRECTIONS.map((d) => fromCube({ x: cube.x + d.x, y: cube.y + d.y, z: cube.z + d.z }));
+}
+/** the number of hex steps between two cells */
+export function hexDistance(a, b) {
+    const ca = toCube(a.x, a.y);
+    const cb = toCube(b.x, b.y);
+    return Math.max(Math.abs(ca.x - cb.x), Math.abs(ca.y - cb.y), Math.abs(ca.z - cb.z));
+}
+function cubeRound(cube) {
+    let rx = Math.round(cube.x);
+    let ry = Math.round(cube.y);
+    let rz = Math.round(cube.z);
+    const dx = Math.abs(rx - cube.x);
+    const dy = Math.abs(ry - cube.y);
+    const dz = Math.abs(rz - cube.z);
+    //whichever coordinate drifted furthest from its rounded value is reconstructed from the
+    //other two, so x + y + z = 0 still holds exactly
+    if (dx > dy && dx > dz)
+        rx = -ry - rz;
+    else if (dy > dz)
+        ry = -rx - rz;
+    else
+        rz = -rx - ry;
+    return { x: rx, y: ry, z: rz };
+}
+/**
+ * Every cell a straight line crosses from `a` to `b`, both included - the hex-grid analogue
+ * of `mwg/roguelike`'s `traceLine`, and what a simple (non-shadowcast) hex field of view is
+ * built from: walk the line to a candidate cell and see whether anything on it is opaque.
+ */
+export function hexLine(a, b) {
+    const distance = hexDistance(a, b);
+    if (distance === 0)
+        return [{ x: a.x, y: a.y }];
+    const ca = toCube(a.x, a.y);
+    const cb = toCube(b.x, b.y);
+    const points = [];
+    for (let step = 0; step <= distance; step++) {
+        const t = step / distance;
+        points.push(fromCube(cubeRound({
+            x: ca.x + (cb.x - ca.x) * t,
+            y: ca.y + (cb.y - ca.y) * t,
+            z: ca.z + (cb.z - ca.z) * t,
+        })));
+    }
+    return points;
+}
+/** every cell within `radius` hex steps of `center`, `center` itself included */
+export function hexRange(center, radius) {
+    const cc = toCube(center.x, center.y);
+    const out = [];
+    for (let dx = -radius; dx <= radius; dx++) {
+        for (let dy = Math.max(-radius, -dx - radius); dy <= Math.min(radius, -dx + radius); dy++) {
+            const dz = -dx - dy;
+            out.push(fromCube({ x: cc.x + dx, y: cc.y + dy, z: cc.z + dz }));
+        }
+    }
+    return out;
+}
+/** the pixel position of a hex cell's centre, for a flat-top tile of the given size */
+export function hexToPixel(x, y, tileWidth, tileHeight) {
+    return {
+        x: x * tileWidth * 0.75 + tileWidth / 2,
+        y: y * tileHeight + (x & 1) * (tileHeight / 2) + tileHeight / 2,
+    };
+}
+/**
+ * The hex cell under a pixel position - the inverse of `hexToPixel`.
+ *
+ * Fractional cube coordinates first, rounded only at the end (`cubeRound`), the same way
+ * `hexLine` resolves a fractional step to a cell - rounding column and row independently
+ * would round to the wrong cell right at a hex's edge.
+ */
+export function pixelToHex(px, py, tileWidth, tileHeight) {
+    const relativeX = px - tileWidth / 2;
+    const relativeY = py - tileHeight / 2;
+    const cx = relativeX / (tileWidth * 0.75);
+    const cz = relativeY / tileHeight - 0.5 * cx;
+    const cy = -cx - cz;
+    return fromCube(cubeRound({ x: cx, y: cy, z: cz }));
+}
+//# sourceMappingURL=Hex.js.map

package/dist/core/Hex.js.map

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

package/dist/core/Input.d.ts

@@ -0,0 +1,41 @@
+import { Signal } from './Signal.ts';
+/**
+ * Keyboard input, bound to named actions.
+ *
+ * Game code asks about `'confirm'`, never about `'Enter'`. That indirection is what makes
+ * rebinding possible at all, and it is far easier to put in from the start than to retrofit
+ * once a hundred call sites know about key codes.
+ *
+ * Keys are identified by `KeyboardEvent.code` — the physical key — so a binding to `KeyZ`
+ * lands on the same place under AZERTY as under QWERTY, which is what a player actually
+ * wants from a movement key.
+ */
+export type Action = string;
+/** fires when an action starts; a listener returning true stops it reaching anything else */
+export declare const onAction: Signal<string>;
+/** fires for every keydown, for the rare case that needs the raw key */
+export declare const onKey: Signal<KeyboardEvent>;
+/** the bindings a game starts with; every one can be replaced */
+export declare const DEFAULT_BINDINGS: Readonly<Record<Action, readonly string[]>>;
+export declare function bind(action: Action, keys: readonly string[]): void;
+export declare function unbind(action: Action): void;
+export declare function keysFor(action: Action): string[];
+/** every binding, in a shape that can be written to a settings file and read back */
+export declare function exportBindings(): Record<Action, string[]>;
+export declare function importBindings(saved: Readonly<Record<Action, readonly string[]>>): void;
+export declare function resetBindings(): void;
+/** true for as long as the key is held */
+export declare function isDown(action: Action): boolean;
+/** true only on the frame the action began, for menus and single steps */
+export declare function justPressed(action: Action): boolean;
+export declare function justReleased(action: Action): boolean;
+/**
+ * Clears the one-frame state.
+ *
+ * Called by `Game` at the end of every frame. It has to run after the scene's update, or
+ * a `justPressed` would be missed by whatever polls it later in the same frame.
+ */
+export declare function endFrame(): void;
+export declare function attach(target?: EventTarget): void;
+export declare function detach(target?: EventTarget): void;
+//# sourceMappingURL=Input.d.ts.map

package/dist/core/Input.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Input.d.ts","sourceRoot":"","sources":["../../src/core/Input.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAErC;;;;;;;;;;GAUG;AAEH,MAAM,MAAM,MAAM,GAAG,MAAM,CAAC;AAO5B,6FAA6F;AAC7F,eAAO,MAAM,QAAQ,gBAA2B,CAAC;AAEjD,wEAAwE;AACxE,eAAO,MAAM,KAAK,uBAAkC,CAAC;AAIrD,iEAAiE;AACjE,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC,CAaxE,CAAC;AAEF,wBAAgB,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,SAAS,MAAM,EAAE,GAAG,IAAI,CAElE;AAED,wBAAgB,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAE3C;AAED,wBAAgB,OAAO,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CAEhD;AAED,qFAAqF;AACrF,wBAAgB,cAAc,IAAI,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAIzD;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC,CAAC,GAAG,IAAI,CAGvF;AAED,wBAAgB,aAAa,IAAI,IAAI,CAEpC;AAeD,0CAA0C;AAC1C,wBAAgB,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAO9C;AAED,0EAA0E;AAC1E,wBAAgB,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAEnD;AAED,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAEpD;AAED;;;;;GAKG;AACH,wBAAgB,QAAQ,IAAI,IAAI,CAG/B;AA+BD,wBAAgB,MAAM,CAAC,MAAM,GAAE,WAAoB,GAAG,IAAI,CAOzD;AAED,wBAAgB,MAAM,CAAC,MAAM,GAAE,WAAoB,GAAG,IAAI,CAQzD"}

package/dist/core/Input.js

@@ -0,0 +1,132 @@
+import { Signal } from './Signal.js';
+const bindings = new Map();
+const held = new Set();
+const pressedThisFrame = new Set();
+const releasedThisFrame = new Set();
+/** fires when an action starts; a listener returning true stops it reaching anything else */
+export const onAction = new Signal(true);
+/** fires for every keydown, for the rare case that needs the raw key */
+export const onKey = new Signal(true);
+let attached = false;
+/** the bindings a game starts with; every one can be replaced */
+export const DEFAULT_BINDINGS = {
+    up: ['ArrowUp', 'KeyW', 'Numpad8'],
+    down: ['ArrowDown', 'KeyS', 'Numpad2'],
+    left: ['ArrowLeft', 'KeyA', 'Numpad4'],
+    right: ['ArrowRight', 'KeyD', 'Numpad6'],
+    upLeft: ['Numpad7'],
+    upRight: ['Numpad9'],
+    downLeft: ['Numpad1'],
+    downRight: ['Numpad3'],
+    wait: ['Numpad5', 'Period'],
+    confirm: ['Enter', 'Space', 'NumpadEnter'],
+    cancel: ['Escape', 'Backspace'],
+    menu: ['KeyI', 'Tab'],
+};
+export function bind(action, keys) {
+    bindings.set(action, new Set(keys));
+}
+export function unbind(action) {
+    bindings.delete(action);
+}
+export function keysFor(action) {
+    return [...(bindings.get(action) ?? [])];
+}
+/** every binding, in a shape that can be written to a settings file and read back */
+export function exportBindings() {
+    const out = {};
+    for (const [action, keys] of bindings)
+        out[action] = [...keys];
+    return out;
+}
+export function importBindings(saved) {
+    bindings.clear();
+    for (const [action, keys] of Object.entries(saved))
+        bind(action, keys);
+}
+export function resetBindings() {
+    importBindings(DEFAULT_BINDINGS);
+}
+//installed as soon as this module loads, so a game may add or replace a binding before it
+//starts without that being mistaken for "this game defines all its own keys". Deferring
+//this to attach() cost every default the moment a game bound one action of its own.
+resetBindings();
+function actionsFor(code) {
+    const out = [];
+    for (const [action, keys] of bindings) {
+        if (keys.has(code))
+            out.push(action);
+    }
+    return out;
+}
+/** true for as long as the key is held */
+export function isDown(action) {
+    const keys = bindings.get(action);
+    if (!keys)
+        return false;
+    for (const key of keys) {
+        if (held.has(key))
+            return true;
+    }
+    return false;
+}
+/** true only on the frame the action began, for menus and single steps */
+export function justPressed(action) {
+    return pressedThisFrame.has(action);
+}
+export function justReleased(action) {
+    return releasedThisFrame.has(action);
+}
+/**
+ * Clears the one-frame state.
+ *
+ * Called by `Game` at the end of every frame. It has to run after the scene's update, or
+ * a `justPressed` would be missed by whatever polls it later in the same frame.
+ */
+export function endFrame() {
+    pressedThisFrame.clear();
+    releasedThisFrame.clear();
+}
+function handleKeyDown(event) {
+    //a held key repeats; the action already started, so only the raw signal repeats
+    if (event.repeat) {
+        onKey.dispatch(event);
+        return;
+    }
+    held.add(event.code);
+    for (const action of actionsFor(event.code)) {
+        pressedThisFrame.add(action);
+        onAction.dispatch(action);
+    }
+    onKey.dispatch(event);
+}
+function handleKeyUp(event) {
+    held.delete(event.code);
+    for (const action of actionsFor(event.code)) {
+        releasedThisFrame.add(action);
+    }
+}
+function handleBlur() {
+    //a key held while the window loses focus never sends its keyup, and would stay stuck
+    held.clear();
+    pressedThisFrame.clear();
+    releasedThisFrame.clear();
+}
+export function attach(target = window) {
+    if (attached)
+        return;
+    attached = true;
+    target.addEventListener('keydown', handleKeyDown);
+    target.addEventListener('keyup', handleKeyUp);
+    window.addEventListener('blur', handleBlur);
+}
+export function detach(target = window) {
+    if (!attached)
+        return;
+    attached = false;
+    target.removeEventListener('keydown', handleKeyDown);
+    target.removeEventListener('keyup', handleKeyUp);
+    window.removeEventListener('blur', handleBlur);
+    handleBlur();
+}
+//# sourceMappingURL=Input.js.map

package/dist/core/Input.js.map

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

package/dist/core/Log.d.ts

@@ -0,0 +1,39 @@
+/**
+ * What severity a log entry carries. Ordered, so a logger can keep `warn` and
+ * above while silencing the chatter below.
+ */
+export type LogLevel = 'debug' | 'info' | 'warn' | 'error';
+export interface LogEntry {
+    level: LogLevel;
+    category: string;
+    message: string;
+    data?: unknown;
+    time: number;
+}
+export interface LoggerOptions {
+    /** entries below this never reach the sink; defaults to `debug` (everything) */
+    level?: LogLevel;
+    /** where entries go; defaults to the matching console method */
+    sink?: (entry: LogEntry) => void;
+}
+/**
+ * Categories and severity over bare `console.log`.
+ *
+ * Marginal on its own - the browser console already exists - which is why this
+ * stays small: a named category per system, four levels, a filter, and a sink
+ * tests can capture instead of the console.
+ */
+export declare class Logger {
+    private readonly category;
+    private level;
+    private readonly sink;
+    constructor(category: string, options?: LoggerOptions);
+    /** raises or lowers what reaches the sink from here on */
+    setLevel(level: LogLevel): void;
+    debug(message: string, data?: unknown): void;
+    info(message: string, data?: unknown): void;
+    warn(message: string, data?: unknown): void;
+    error(message: string, data?: unknown): void;
+    private write;
+}
+//# sourceMappingURL=Log.d.ts.map

package/dist/core/Log.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Log.d.ts","sourceRoot":"","sources":["../../src/core/Log.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,MAAM,MAAM,QAAQ,GAAG,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC;AAI3D,MAAM,WAAW,QAAQ;IACxB,KAAK,EAAE,QAAQ,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;CACb;AAED,MAAM,WAAW,aAAa;IAC7B,gFAAgF;IAChF,KAAK,CAAC,EAAE,QAAQ,CAAC;IACjB,gEAAgE;IAChE,IAAI,CAAC,EAAE,CAAC,KAAK,EAAE,QAAQ,KAAK,IAAI,CAAC;CACjC;AAED;;;;;;GAMG;AACH,qBAAa,MAAM;IAClB,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAS;IAClC,OAAO,CAAC,KAAK,CAAW;IACxB,OAAO,CAAC,QAAQ,CAAC,IAAI,CAA4B;IAEjD,YAAY,QAAQ,EAAE,MAAM,EAAE,OAAO,GAAE,aAAkB,EAKxD;IAED,0DAA0D;IAC1D,QAAQ,CAAC,KAAK,EAAE,QAAQ,GAAG,IAAI,CAE9B;IAED,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,GAAG,IAAI,CAE3C;IAED,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,GAAG,IAAI,CAE1C;IAED,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,GAAG,IAAI,CAE1C;IAED,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,GAAG,IAAI,CAE3C;IAED,OAAO,CAAC,KAAK;CAIb"}

package/dist/core/Log.js

@@ -0,0 +1,50 @@
+const ORDER = { debug: 0, info: 1, warn: 2, error: 3 };
+/**
+ * Categories and severity over bare `console.log`.
+ *
+ * Marginal on its own - the browser console already exists - which is why this
+ * stays small: a named category per system, four levels, a filter, and a sink
+ * tests can capture instead of the console.
+ */
+export class Logger {
+    constructor(category, options = {}) {
+        if (!category)
+            throw new Error('a logger needs a category');
+        this.category = category;
+        this.level = options.level ?? 'debug';
+        this.sink = options.sink ?? defaultSink;
+    }
+    /** raises or lowers what reaches the sink from here on */
+    setLevel(level) {
+        this.level = level;
+    }
+    debug(message, data) {
+        this.write('debug', message, data);
+    }
+    info(message, data) {
+        this.write('info', message, data);
+    }
+    warn(message, data) {
+        this.write('warn', message, data);
+    }
+    error(message, data) {
+        this.write('error', message, data);
+    }
+    write(level, message, data) {
+        if (ORDER[level] < ORDER[this.level])
+            return;
+        this.sink({ level, category: this.category, message, data, time: Date.now() });
+    }
+}
+function defaultSink(entry) {
+    const line = `[${entry.category}] ${entry.message}`;
+    if (entry.level === 'debug')
+        console.debug(line, entry.data ?? '');
+    else if (entry.level === 'info')
+        console.info(line, entry.data ?? '');
+    else if (entry.level === 'warn')
+        console.warn(line, entry.data ?? '');
+    else
+        console.error(line, entry.data ?? '');
+}
+//# sourceMappingURL=Log.js.map

package/dist/core/Log.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Log.js","sourceRoot":"","sources":["../../src/core/Log.ts"],"names":[],"mappings":"AAMA,MAAM,KAAK,GAA6B,EAAE,KAAK,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,CAAC;AAiBjF;;;;;;GAMG;AACH,MAAM,OAAO,MAAM;IAKlB,YAAY,QAAgB,EAAE,OAAO,GAAkB,EAAE;QACxD,IAAI,CAAC,QAAQ;YAAE,MAAM,IAAI,KAAK,CAAC,2BAA2B,CAAC,CAAC;QAC5D,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC;QACzB,IAAI,CAAC,KAAK,GAAG,OAAO,CAAC,KAAK,IAAI,OAAO,CAAC;QACtC,IAAI,CAAC,IAAI,GAAG,OAAO,CAAC,IAAI,IAAI,WAAW,CAAC;IACzC,CAAC;IAED,0DAA0D;IAC1D,QAAQ,CAAC,KAAe;QACvB,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;IACpB,CAAC;IAED,KAAK,CAAC,OAAe,EAAE,IAAc;QACpC,IAAI,CAAC,KAAK,CAAC,OAAO,EAAE,OAAO,EAAE,IAAI,CAAC,CAAC;IACpC,CAAC;IAED,IAAI,CAAC,OAAe,EAAE,IAAc;QACnC,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE,OAAO,EAAE,IAAI,CAAC,CAAC;IACnC,CAAC;IAED,IAAI,CAAC,OAAe,EAAE,IAAc;QACnC,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE,OAAO,EAAE,IAAI,CAAC,CAAC;IACnC,CAAC;IAED,KAAK,CAAC,OAAe,EAAE,IAAc;QACpC,IAAI,CAAC,KAAK,CAAC,OAAO,EAAE,OAAO,EAAE,IAAI,CAAC,CAAC;IACpC,CAAC;IAEO,KAAK,CAAC,KAAe,EAAE,OAAe,EAAE,IAAc;QAC7D,IAAI,KAAK,CAAC,KAAK,CAAC,GAAG,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC;YAAE,OAAO;QAC7C,IAAI,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE,QAAQ,EAAE,IAAI,CAAC,QAAQ,EAAE,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC;IAChF,CAAC;CACD;AAED,SAAS,WAAW,CAAC,KAAe;IACnC,MAAM,IAAI,GAAG,IAAI,KAAK,CAAC,QAAQ,KAAK,KAAK,CAAC,OAAO,EAAE,CAAC;IACpD,IAAI,KAAK,CAAC,KAAK,KAAK,OAAO;QAAE,OAAO,CAAC,KAAK,CAAC,IAAI,EAAE,KAAK,CAAC,IAAI,IAAI,EAAE,CAAC,CAAC;SAC9D,IAAI,KAAK,CAAC,KAAK,KAAK,MAAM;QAAE,OAAO,CAAC,IAAI,CAAC,IAAI,EAAE,KAAK,CAAC,IAAI,IAAI,EAAE,CAAC,CAAC;SACjE,IAAI,KAAK,CAAC,KAAK,KAAK,MAAM;QAAE,OAAO,CAAC,IAAI,CAAC,IAAI,EAAE,KAAK,CAAC,IAAI,IAAI,EAAE,CAAC,CAAC;;QACjE,OAAO,CAAC,KAAK,CAAC,IAAI,EAAE,KAAK,CAAC,IAAI,IAAI,EAAE,CAAC,CAAC;AAC5C,CAAC"}

package/dist/core/Random.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Deterministic random numbers.
+ *
+ * A roguelike lives or dies on this: the same seed has to produce the same dungeon, on
+ * any machine, in any browser, forever. `Math.random()` cannot do that — it is not
+ * seedable and its algorithm is not specified.
+ *
+ * The generator is xoshiro128**, by David Blackman and Sebastiano Vigna, released into the
+ * public domain. It is fast, passes the standard statistical test suites, and its state is
+ * four 32-bit words, which JavaScript can hold exactly.
+ *
+ * Generators are kept on a stack. Level generation pushes a seeded one so a floor is
+ * reproducible, then pops it, so unrelated rolls elsewhere do not consume from that
+ * stream and shift the results.
+ */
+export declare class Generator {
+    private s0;
+    private s1;
+    private s2;
+    private s3;
+    readonly seed: number;
+    constructor(seed?: number);
+    /** the raw generator: a uniformly distributed unsigned 32-bit integer */
+    nextUint32(): number;
+    /** a float in [0, 1), with 32 bits of resolution */
+    float(): number;
+    /**
+     * An integer in [0, bound), without modulo bias.
+     *
+     * The naive `nextUint32() % bound` favours the low values whenever bound does not
+     * divide 2^32; this rejects the unfair tail of the range instead.
+     */
+    int(bound: number): number;
+    /** captures the generator state, so a save file can resume the same stream */
+    getState(): [number, number, number, number];
+    setState(state: readonly [number, number, number, number]): void;
+}
+/** starts a reproducible stream; pair every call with `pop()` */
+export declare function push(seed?: number): Generator;
+export declare function pop(): void;
+/** runs `body` with a seeded generator, popping it even if `body` throws */
+export declare function withSeed<T>(seed: number, body: () => T): T;
+export declare function reset(): void;
+/** a float in [0, 1), or [0, max), or [min, max) */
+export declare function float(min?: number, max?: number): number;
+/** an integer in [0, max), or [min, max) */
+export declare function int(min: number, max?: number): number;
+/** an integer in [min, max], both ends included — the usual shape for dice */
+export declare function range(min: number, max: number): number;
+/**
+ * A triangular distribution over [min, max], peaking in the middle.
+ *
+ * Useful wherever a uniform roll feels wrong: damage, room sizes, item quality.
+ */
+export declare function normalRange(min: number, max: number): number;
+export declare function chance(probability: number): boolean;
+export declare function element<T>(items: readonly T[]): T | undefined;
+/** an index into `weights`, each index drawn in proportion to its weight */
+export declare function weighted(weights: readonly number[]): number;
+/** a key from `weights`, drawn in proportion to the value it maps to */
+export declare function weightedKey<K>(weights: ReadonlyMap<K, number>): K | undefined;
+/** Fisher-Yates, in place */
+export declare function shuffle<T>(items: T[]): T[];
+//# sourceMappingURL=Random.d.ts.map

package/dist/core/Random.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Random.d.ts","sourceRoot":"","sources":["../../src/core/Random.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAcH,qBAAa,SAAS;IACrB,OAAO,CAAC,EAAE,CAAK;IACf,OAAO,CAAC,EAAE,CAAK;IACf,OAAO,CAAC,EAAE,CAAK;IACf,OAAO,CAAC,EAAE,CAAK;IAEf,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAEtB,YAAY,IAAI,CAAC,EAAE,MAAM,EAcxB;IAED,yEAAyE;IACzE,UAAU,IAAI,MAAM,CAanB;IAED,oDAAoD;IACpD,KAAK,IAAI,MAAM,CAEd;IAED;;;;;OAKG;IACH,GAAG,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CASzB;IAED,8EAA8E;IAC9E,QAAQ,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAE3C;IAED,QAAQ,CAAC,KAAK,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI,CAE/D;CACD;AAUD,iEAAiE;AACjE,wBAAgB,IAAI,CAAC,IAAI,CAAC,EAAE,MAAM,GAAG,SAAS,CAI7C;AAED,wBAAgB,GAAG,IAAI,IAAI,CAK1B;AAED,4EAA4E;AAC5E,wBAAgB,QAAQ,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,GAAG,CAAC,CAO1D;AAED,wBAAgB,KAAK,IAAI,IAAI,CAG5B;AAED,oDAAoD;AACpD,wBAAgB,KAAK,CAAC,GAAG,CAAC,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,MAAM,CAIxD;AAED,4CAA4C;AAC5C,wBAAgB,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,MAAM,CAGrD;AAED,8EAA8E;AAC9E,wBAAgB,KAAK,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAEtD;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAE5D;AAED,wBAAgB,MAAM,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAEnD;AAED,wBAAgB,OAAO,CAAC,CAAC,EAAE,KAAK,EAAE,SAAS,CAAC,EAAE,GAAG,CAAC,GAAG,SAAS,CAE7D;AAED,4EAA4E;AAC5E,wBAAgB,QAAQ,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAW3D;AAED,wEAAwE;AACxE,wBAAgB,WAAW,CAAC,CAAC,EAAE,OAAO,EAAE,WAAW,CAAC,CAAC,EAAE,MAAM,CAAC,GAAG,CAAC,GAAG,SAAS,CAI7E;AAED,6BAA6B;AAC7B,wBAAgB,OAAO,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,GAAG,CAAC,EAAE,CAM1C"}

package/dist/core/Random.js

@@ -0,0 +1,178 @@
+/**
+ * Deterministic random numbers.
+ *
+ * A roguelike lives or dies on this: the same seed has to produce the same dungeon, on
+ * any machine, in any browser, forever. `Math.random()` cannot do that — it is not
+ * seedable and its algorithm is not specified.
+ *
+ * The generator is xoshiro128**, by David Blackman and Sebastiano Vigna, released into the
+ * public domain. It is fast, passes the standard statistical test suites, and its state is
+ * four 32-bit words, which JavaScript can hold exactly.
+ *
+ * Generators are kept on a stack. Level generation pushes a seeded one so a floor is
+ * reproducible, then pops it, so unrelated rolls elsewhere do not consume from that
+ * stream and shift the results.
+ */
+/** splitmix32, used to expand a single seed into the four words of generator state */
+function splitmix32(seed) {
+    let a = seed >>> 0;
+    return () => {
+        a = (a + 0x9e3779b9) >>> 0;
+        let t = a;
+        t = Math.imul(t ^ (t >>> 16), 0x21f0aaad);
+        t = Math.imul(t ^ (t >>> 15), 0x735a2d97);
+        return (t ^ (t >>> 15)) >>> 0;
+    };
+}
+export class Generator {
+    constructor(seed) {
+        this.s0 = 0;
+        this.s1 = 0;
+        this.s2 = 0;
+        this.s3 = 0;
+        //an unseeded generator still has to be deterministic once created, so a random seed
+        //is drawn once and kept, rather than the state being seeded from entropy directly
+        this.seed = seed === undefined ? (Math.random() * 0x100000000) >>> 0 : seed >>> 0;
+        const next = splitmix32(this.seed);
+        this.s0 = next();
+        this.s1 = next();
+        this.s2 = next();
+        this.s3 = next();
+        //an all-zero state is a fixed point of the generator; splitmix never produces one,
+        //but a future change to the seeding must not either
+        if ((this.s0 | this.s1 | this.s2 | this.s3) === 0)
+            this.s0 = 1;
+    }
+    /** the raw generator: a uniformly distributed unsigned 32-bit integer */
+    nextUint32() {
+        const result = (Math.imul(rotl(Math.imul(this.s1, 5), 7), 9) >>> 0) >>> 0;
+        const t = (this.s1 << 9) >>> 0;
+        this.s2 ^= this.s0;
+        this.s3 ^= this.s1;
+        this.s1 ^= this.s2;
+        this.s0 ^= this.s3;
+        this.s2 ^= t;
+        this.s3 = rotl(this.s3, 11);
+        return result;
+    }
+    /** a float in [0, 1), with 32 bits of resolution */
+    float() {
+        return this.nextUint32() / 0x100000000;
+    }
+    /**
+     * An integer in [0, bound), without modulo bias.
+     *
+     * The naive `nextUint32() % bound` favours the low values whenever bound does not
+     * divide 2^32; this rejects the unfair tail of the range instead.
+     */
+    int(bound) {
+        if (bound <= 0)
+            return 0;
+        const limit = 0x100000000 - (0x100000000 % bound);
+        let value = this.nextUint32();
+        while (value >= limit) {
+            value = this.nextUint32();
+        }
+        return value % bound;
+    }
+    /** captures the generator state, so a save file can resume the same stream */
+    getState() {
+        return [this.s0, this.s1, this.s2, this.s3];
+    }
+    setState(state) {
+        [this.s0, this.s1, this.s2, this.s3] = state;
+    }
+}
+function rotl(x, k) {
+    return ((x << k) | (x >>> (32 - k))) >>> 0;
+}
+const stack = [new Generator()];
+const current = () => stack[stack.length - 1];
+/** starts a reproducible stream; pair every call with `pop()` */
+export function push(seed) {
+    const generator = new Generator(seed);
+    stack.push(generator);
+    return generator;
+}
+export function pop() {
+    if (stack.length === 1) {
+        throw new Error('the base random generator cannot be popped');
+    }
+    stack.pop();
+}
+/** runs `body` with a seeded generator, popping it even if `body` throws */
+export function withSeed(seed, body) {
+    push(seed);
+    try {
+        return body();
+    }
+    finally {
+        pop();
+    }
+}
+export function reset() {
+    stack.length = 0;
+    stack.push(new Generator());
+}
+/** a float in [0, 1), or [0, max), or [min, max) */
+export function float(min, max) {
+    if (min === undefined)
+        return current().float();
+    if (max === undefined)
+        return current().float() * min;
+    return min + current().float() * (max - min);
+}
+/** an integer in [0, max), or [min, max) */
+export function int(min, max) {
+    if (max === undefined)
+        return current().int(min);
+    return min + current().int(max - min);
+}
+/** an integer in [min, max], both ends included — the usual shape for dice */
+export function range(min, max) {
+    return min + current().int(max - min + 1);
+}
+/**
+ * A triangular distribution over [min, max], peaking in the middle.
+ *
+ * Useful wherever a uniform roll feels wrong: damage, room sizes, item quality.
+ */
+export function normalRange(min, max) {
+    return min + Math.floor(((current().float() + current().float()) * (max - min + 1)) / 2);
+}
+export function chance(probability) {
+    return current().float() < probability;
+}
+export function element(items) {
+    return items.length > 0 ? items[current().int(items.length)] : undefined;
+}
+/** an index into `weights`, each index drawn in proportion to its weight */
+export function weighted(weights) {
+    let total = 0;
+    for (const w of weights)
+        total += w;
+    if (total <= 0)
+        return -1;
+    let value = current().float() * total;
+    for (let i = 0; i < weights.length; i++) {
+        value -= weights[i];
+        if (value < 0)
+            return i;
+    }
+    return weights.length - 1;
+}
+/** a key from `weights`, drawn in proportion to the value it maps to */
+export function weightedKey(weights) {
+    const keys = [...weights.keys()];
+    const index = weighted(keys.map((k) => weights.get(k) ?? 0));
+    return index === -1 ? undefined : keys[index];
+}
+/** Fisher-Yates, in place */
+export function shuffle(items) {
+    for (let i = items.length - 1; i > 0; i--) {
+        const j = current().int(i + 1);
+        [items[i], items[j]] = [items[j], items[i]];
+    }
+    return items;
+}
+//# sourceMappingURL=Random.js.map