@datamoc/mw_games 0.43.0 → 0.45.0

package/dist/core/PlayerInput.js

@@ -1,82 +0,0 @@
-import * as Input from './Input.js';
-/**
- * A player-scoped view over `mwg/core`'s `Input` module for same-screen local multiplayer.
- *
- * `Input` has no concept of a player: `Action` is a bare string, and its `bindings`/`held`/
- * `onAction` all live at module scope. Binding the same action name to two pads directly -
- * `Input.bindButton('confirm', 0, [0])` and `Input.bindButton('confirm', 1, [0])` - does not
- * give two independent "confirm"s; both bindings land in the very same action's key set, so
- * either pad pressing it fires the one shared `onAction`, with no way to tell which pad did.
- *
- * This does not change `Input` itself - it is a thin, purely additive naming convention:
- * every action a `PlayerInput` binds or queries is transparently prefixed with this
- * player's own `id`, so two players' "confirm" become two distinct actions
- * (`"p1:confirm"`, `"p2:confirm"`) that never collide. A single-player game using `Input`'s
- * bare action names directly is entirely unaffected.
- *
- * @example
- * ```ts
- * import { PlayerInput } from '@datamoc/mw_games/core';
- *
- * const player1 = new PlayerInput('p1', { padIndex: 0 });
- * const player2 = new PlayerInput('p2', { padIndex: 1 });
- *
- * player1.bind('confirm', ['Enter']);
- * player2.bind('confirm', ['Space']);
- *
- * // each player's "confirm" fires independently, even though both call it "confirm"
- * if (player1.justPressed('confirm')) console.log('player 1 confirmed');
- * ```
- */
-export class PlayerInput {
-    constructor(id, options = {}) {
-        if (!id)
-            throw new Error('a player needs a non-empty id');
-        this.id = id;
-        this.padIndex = options.padIndex;
-    }
-    scoped(action) {
-        return `${this.id}:${action}`;
-    }
-    /** binds this player's own action to keyboard keys, independent of any other player's binding for the same action name */
-    bind(action, keys) {
-        Input.bind(this.scoped(action), keys);
-    }
-    /** binds this player's own action to a button on their own `padIndex` */
-    bindButton(action, buttons) {
-        if (this.padIndex === undefined)
-            throw new Error(`player "${this.id}" has no padIndex to bind a gamepad button to`);
-        Input.bindButton(this.scoped(action), this.padIndex, buttons);
-    }
-    /** binds this player's own action to an axis direction on their own `padIndex` */
-    bindAxis(action, axis, direction) {
-        if (this.padIndex === undefined)
-            throw new Error(`player "${this.id}" has no padIndex to bind a gamepad axis to`);
-        Input.bindAxis(this.scoped(action), this.padIndex, axis, direction);
-    }
-    /** binds this player's own action to an on-screen touch control, independent of any other player's binding for the same action name */
-    bindTouch(action, id = action) {
-        Input.bindTouch(this.scoped(action), `${this.id}:${id}`);
-    }
-    /** presses this player's own touch control, bound previously with `bindTouch` */
-    pressTouch(id) {
-        Input.pressTouch(`${this.id}:${id}`);
-    }
-    releaseTouch(id) {
-        Input.releaseTouch(`${this.id}:${id}`);
-    }
-    isDown(action) {
-        return Input.isDown(this.scoped(action));
-    }
-    justPressed(action) {
-        return Input.justPressed(this.scoped(action));
-    }
-    justReleased(action) {
-        return Input.justReleased(this.scoped(action));
-    }
-    /** every key/pad binding for this player's own action, in the same shape `Input.exportBindings` uses */
-    keysFor(action) {
-        return Input.keysFor(this.scoped(action));
-    }
-}
-//# sourceMappingURL=PlayerInput.js.map

package/dist/core/PlayerInput.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"PlayerInput.js","sourceRoot":"","sources":["../../src/core/PlayerInput.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,YAAY,CAAC;AAQpC;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,MAAM,OAAO,WAAW;IAIvB,YAAY,EAAU,EAAE,OAAO,GAAuB,EAAE;QACvD,IAAI,CAAC,EAAE;YAAE,MAAM,IAAI,KAAK,CAAC,+BAA+B,CAAC,CAAC;QAC1D,IAAI,CAAC,EAAE,GAAG,EAAE,CAAC;QACb,IAAI,CAAC,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAC;IAClC,CAAC;IAEO,MAAM,CAAC,MAAc;QAC5B,OAAO,GAAG,IAAI,CAAC,EAAE,IAAI,MAAM,EAAE,CAAC;IAC/B,CAAC;IAED,0HAA0H;IAC1H,IAAI,CAAC,MAAc,EAAE,IAAuB;QAC3C,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE,IAAI,CAAC,CAAC;IACvC,CAAC;IAED,yEAAyE;IACzE,UAAU,CAAC,MAAc,EAAE,OAA0B;QACpD,IAAI,IAAI,CAAC,QAAQ,KAAK,SAAS;YAC9B,MAAM,IAAI,KAAK,CAAC,WAAW,IAAI,CAAC,EAAE,+CAA+C,CAAC,CAAC;QACpF,KAAK,CAAC,UAAU,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE,IAAI,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAC;IAC/D,CAAC;IAED,kFAAkF;IAClF,QAAQ,CAAC,MAAc,EAAE,IAAY,EAAE,SAAiB;QACvD,IAAI,IAAI,CAAC,QAAQ,KAAK,SAAS;YAC9B,MAAM,IAAI,KAAK,CAAC,WAAW,IAAI,CAAC,EAAE,6CAA6C,CAAC,CAAC;QAClF,KAAK,CAAC,QAAQ,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE,IAAI,CAAC,QAAQ,EAAE,IAAI,EAAE,SAAS,CAAC,CAAC;IACrE,CAAC;IAED,uIAAuI;IACvI,SAAS,CAAC,MAAc,EAAE,EAAE,GAAW,MAAM;QAC5C,KAAK,CAAC,SAAS,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE,GAAG,IAAI,CAAC,EAAE,IAAI,EAAE,EAAE,CAAC,CAAC;IAC1D,CAAC;IAED,iFAAiF;IACjF,UAAU,CAAC,EAAU;QACpB,KAAK,CAAC,UAAU,CAAC,GAAG,IAAI,CAAC,EAAE,IAAI,EAAE,EAAE,CAAC,CAAC;IACtC,CAAC;IAED,YAAY,CAAC,EAAU;QACtB,KAAK,CAAC,YAAY,CAAC,GAAG,IAAI,CAAC,EAAE,IAAI,EAAE,EAAE,CAAC,CAAC;IACxC,CAAC;IAED,MAAM,CAAC,MAAc;QACpB,OAAO,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC;IAC1C,CAAC;IAED,WAAW,CAAC,MAAc;QACzB,OAAO,KAAK,CAAC,WAAW,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC;IAC/C,CAAC;IAED,YAAY,CAAC,MAAc;QAC1B,OAAO,KAAK,CAAC,YAAY,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC;IAChD,CAAC;IAED,wGAAwG;IACxG,OAAO,CAAC,MAAc;QACrB,OAAO,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC;IAC3C,CAAC;CACD"}

package/dist/core/Presentation.d.ts

@@ -1,56 +0,0 @@
-export interface PresentationQueueOptions<Event> {
-    /**
-     * Presents one event - starts a tween, plays a sound, shows a floating number - and
-     * returns how many seconds to wait before the next one starts. Return 0 or nothing for an
-     * event with no visual duration of its own (a sound cue riding along another animation);
-     * several of those in a row drain in the same `enqueue`/`update` call rather than costing
-     * a frame each.
-     */
-    play: (event: Event) => number | void;
-}
-/**
- * Plays simulation events one at a time, at whatever pace their presentation actually takes,
- * entirely separate from the commit that already happened: `simulation.SimulationRuntime.
- * dispatch` (or `runScenario`) returns its events synchronously and completely, and this is
- * what a scene hands them to afterwards. `mwg` never sees what an event *means* - `play` is
- * the game's own mapping from event to animation/sound/UI, this only sequences the calls.
- *
- * The same shape as `two-d.ui.Toast`'s queued, timed presentation, generalised to any event
- * type and freed of `Toast`'s own Pixi container, since queuing which event plays next needs
- * no renderer at all.
- *
- * @example
- * ```ts
- * import { PresentationQueue } from '@datamoc/mw_games/core';
- *
- * type GameEvent = { type: 'move' } | { type: 'damage'; amount: number };
- *
- * const presentation = new PresentationQueue<GameEvent>({
- *   play: (event) => {
- *     if (event.type === 'move') return 0.2; // a move tween takes 200ms
- *     console.log('damage:', event.amount); // a floating number, shown instantly
- *   },
- * });
- *
- * presentation.enqueue([{ type: 'move' }, { type: 'damage', amount: 7 }]);
- * presentation.update(0.2); // the move finishes; the damage event plays right behind it
- * console.log(presentation.isBusy); // false - nothing left queued
- * ```
- */
-export declare class PresentationQueue<Event> {
-    private readonly play;
-    private queue;
-    private busy;
-    private remaining;
-    constructor(options: PresentationQueueOptions<Event>);
-    /** adds events to the end of the queue, starting them immediately if nothing is playing */
-    enqueue(events: readonly Event[]): void;
-    /** advances the current event's timer; starts the next one once it elapses */
-    update(dt: number): void;
-    /** true while an event is playing or others are waiting behind it */
-    get isBusy(): boolean;
-    /** drops every queued and in-progress event without playing it */
-    clear(): void;
-    private advance;
-}
-//# sourceMappingURL=Presentation.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"Presentation.d.ts","sourceRoot":"","sources":["../../src/core/Presentation.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,wBAAwB,CAAC,KAAK;IAC9C;;;;;;OAMG;IACH,IAAI,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,MAAM,GAAG,IAAI,CAAC;CACtC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,qBAAa,iBAAiB,CAAC,KAAK;IACnC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAkC;IACvD,OAAO,CAAC,KAAK,CAAe;IAC5B,OAAO,CAAC,IAAI,CAAS;IACrB,OAAO,CAAC,SAAS,CAAK;IAEtB,YAAY,OAAO,EAAE,wBAAwB,CAAC,KAAK,CAAC,EAEnD;IAED,2FAA2F;IAC3F,OAAO,CAAC,MAAM,EAAE,SAAS,KAAK,EAAE,GAAG,IAAI,CAGtC;IAED,8EAA8E;IAC9E,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,CAIvB;IAED,qEAAqE;IACrE,IAAI,MAAM,IAAI,OAAO,CAEpB;IAED,kEAAkE;IAClE,KAAK,IAAI,IAAI,CAIZ;IAED,OAAO,CAAC,OAAO;CAgBf"}

package/dist/core/Presentation.js

@@ -1,78 +0,0 @@
-/**
- * Plays simulation events one at a time, at whatever pace their presentation actually takes,
- * entirely separate from the commit that already happened: `simulation.SimulationRuntime.
- * dispatch` (or `runScenario`) returns its events synchronously and completely, and this is
- * what a scene hands them to afterwards. `mwg` never sees what an event *means* - `play` is
- * the game's own mapping from event to animation/sound/UI, this only sequences the calls.
- *
- * The same shape as `two-d.ui.Toast`'s queued, timed presentation, generalised to any event
- * type and freed of `Toast`'s own Pixi container, since queuing which event plays next needs
- * no renderer at all.
- *
- * @example
- * ```ts
- * import { PresentationQueue } from '@datamoc/mw_games/core';
- *
- * type GameEvent = { type: 'move' } | { type: 'damage'; amount: number };
- *
- * const presentation = new PresentationQueue<GameEvent>({
- *   play: (event) => {
- *     if (event.type === 'move') return 0.2; // a move tween takes 200ms
- *     console.log('damage:', event.amount); // a floating number, shown instantly
- *   },
- * });
- *
- * presentation.enqueue([{ type: 'move' }, { type: 'damage', amount: 7 }]);
- * presentation.update(0.2); // the move finishes; the damage event plays right behind it
- * console.log(presentation.isBusy); // false - nothing left queued
- * ```
- */
-export class PresentationQueue {
-    constructor(options) {
-        this.queue = [];
-        this.busy = false;
-        this.remaining = 0;
-        this.play = options.play;
-    }
-    /** adds events to the end of the queue, starting them immediately if nothing is playing */
-    enqueue(events) {
-        this.queue.push(...events);
-        if (!this.busy)
-            this.advance();
-    }
-    /** advances the current event's timer; starts the next one once it elapses */
-    update(dt) {
-        if (!this.busy)
-            return;
-        this.remaining -= dt;
-        if (this.remaining <= 0)
-            this.advance();
-    }
-    /** true while an event is playing or others are waiting behind it */
-    get isBusy() {
-        return this.busy;
-    }
-    /** drops every queued and in-progress event without playing it */
-    clear() {
-        this.queue = [];
-        this.busy = false;
-        this.remaining = 0;
-    }
-    advance() {
-        const next = this.queue.shift();
-        if (next === undefined) {
-            this.busy = false;
-            this.remaining = 0;
-            return;
-        }
-        this.busy = true;
-        const duration = this.play(next) || 0;
-        if (duration > 0) {
-            this.remaining = duration;
-        }
-        else {
-            this.advance(); //no visual duration: chain straight into the next one
-        }
-    }
-}
-//# sourceMappingURL=Presentation.js.map

package/dist/core/Presentation.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"Presentation.js","sourceRoot":"","sources":["../../src/core/Presentation.ts"],"names":[],"mappings":"AAWA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,MAAM,OAAO,iBAAiB;IAM7B,YAAY,OAAwC;QAJ5C,UAAK,GAAY,EAAE,CAAC;QACpB,SAAI,GAAG,KAAK,CAAC;QACb,cAAS,GAAG,CAAC,CAAC;QAGrB,IAAI,CAAC,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;IAC1B,CAAC;IAED,2FAA2F;IAC3F,OAAO,CAAC,MAAwB;QAC/B,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC,CAAC;QAC3B,IAAI,CAAC,IAAI,CAAC,IAAI;YAAE,IAAI,CAAC,OAAO,EAAE,CAAC;IAChC,CAAC;IAED,8EAA8E;IAC9E,MAAM,CAAC,EAAU;QAChB,IAAI,CAAC,IAAI,CAAC,IAAI;YAAE,OAAO;QACvB,IAAI,CAAC,SAAS,IAAI,EAAE,CAAC;QACrB,IAAI,IAAI,CAAC,SAAS,IAAI,CAAC;YAAE,IAAI,CAAC,OAAO,EAAE,CAAC;IACzC,CAAC;IAED,qEAAqE;IACrE,IAAI,MAAM;QACT,OAAO,IAAI,CAAC,IAAI,CAAC;IAClB,CAAC;IAED,kEAAkE;IAClE,KAAK;QACJ,IAAI,CAAC,KAAK,GAAG,EAAE,CAAC;QAChB,IAAI,CAAC,IAAI,GAAG,KAAK,CAAC;QAClB,IAAI,CAAC,SAAS,GAAG,CAAC,CAAC;IACpB,CAAC;IAEO,OAAO;QACd,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,KAAK,EAAE,CAAC;QAChC,IAAI,IAAI,KAAK,SAAS,EAAE,CAAC;YACxB,IAAI,CAAC,IAAI,GAAG,KAAK,CAAC;YAClB,IAAI,CAAC,SAAS,GAAG,CAAC,CAAC;YACnB,OAAO;QACR,CAAC;QAED,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;QACjB,MAAM,QAAQ,GAAG,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACtC,IAAI,QAAQ,GAAG,CAAC,EAAE,CAAC;YAClB,IAAI,CAAC,SAAS,GAAG,QAAQ,CAAC;QAC3B,CAAC;aAAM,CAAC;YACP,IAAI,CAAC,OAAO,EAAE,CAAC,CAAC,sDAAsD;QACvE,CAAC;IACF,CAAC;CACD"}

package/dist/core/Random.d.ts

@@ -1,259 +0,0 @@
-/**
- * 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.
- *
- * @example
- * ```ts
- * import { Random } from '@datamoc/mw_games/core';
- *
- * // a floor generated from a seed always comes out the same
- * Random.push(12345);
- * const roll = Random.int(1, 20);
- * const critical = Random.chance(0.05);
- * Random.pop();
- * ```
- */
-/**
- * The seeded generator class `Random`'s free functions wrap directly, for a game that wants
- * its own independent stream rather than sharing the ambient one.
- *
- * @example
- * ```ts
- * import { Generator } from '@datamoc/mw_games/core';
- *
- * const rng = new Generator(42); // same seed, same sequence, every time
- * const roll = rng.int(20);
- * const saved = rng.getState(); // resumable, for a save file
- * ```
- */
-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;
-    private rotl;
-}
-/**
- * The minimal draw surface the derived helpers (`chance`, `element`, `weighted`,
- * `weightedKey`, `shuffle`, `int`, `range`, `normalRange`) need. `Generator` and
- * `MersenneTwister` both satisfy it structurally, so a rule dispatched by a simulation
- * runtime can pass its own injected, snapshot-able stream instead of touching the
- * ambient one - the ambient stream stays the default when no source is given, and the
- * null-reporting conventions are identical either way.
- *
- * @example
- * ```ts
- * import { Generator, Random } from '@datamoc/mw_games/core';
- *
- * // a journaled rule draws from its own stream, never the ambient one
- * const stream = new Generator(99);
- * const pick = Random.weightedKey(new Map([['a', 1], ['b', 2]]), stream);
- * ```
- */
-/**
- * The minimal draw surface for the helpers that draw floats only (`float`, `chance`,
- * `weighted`, `weightedKey`). A rule whose draws are floats-only implements just this -
- * no dead `int` member that must never be called.
- *
- * @example
- * ```ts
- * import { Random } from '@datamoc/mw_games/core';
- * import type { FloatSource } from '@datamoc/mw_games/core';
- *
- * // a scripted float-only stream: every draw is data, no integer path exists
- * const scripted: FloatSource = { float: () => 0.25 };
- * const hit = Random.chance(0.5, scripted);
- * ```
- */
-export interface FloatSource {
-    /** a float in [0, 1) */
-    float(): number;
-}
-/**
- * The minimal draw surface for the helpers that may draw integers (`int`, `range`,
- * `normalRange`, `element`, `shuffle`) as well as floats. `Generator` and
- * `MersenneTwister` both satisfy it structurally.
- *
- * `element` stays on this wider type even though it only picks one item: it draws
- * through `int()`, and re-spelling that draw with `float()` would change its stream
- * (and break seeded replays that use it), so a float-only source is rejected here
- * rather than silently re-drawn.
- */
-export interface RandomSource extends FloatSource {
-    /** an integer in [0, bound), without modulo bias */
-    int(bound: number): number;
-}
-/**
- * The generator the free functions (`int`, `float`, `chance`, ...) draw from.
- *
- * This is the handle a `SimulationRuntime` needs to share the ambient stream:
- * pass the returned object as the runtime's `random` and both sides draw from
- * (and snapshot) one sequence, so a journal replay reproduces scene draws.
- *
- * @example
- * ```ts
- * import { Random } from '@datamoc/mw_games/core';
- *
- * Random.push(12345);
- * const shared = Random.active();
- * const roll = shared.int(20);
- * Random.pop();
- * ```
- */
-export declare function active(): Generator;
-/** 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, source?: FloatSource): number;
-/** an integer in [0, max), or [min, max) */
-export declare function int(min: number, max?: number, source?: RandomSource): number;
-/** an integer in [min, max], both ends included (the usual shape for dice) */
-export declare function range(min: number, max: number, source?: RandomSource): 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, source?: RandomSource): number;
-export declare function chance(probability: number, source?: FloatSource): boolean;
-/**
- * Every "pick one" function here reports "there was nothing to pick" as `null`, never as
- * `-1` or `undefined`.
- *
- * `weighted` used to return `-1` and the two functions built on it returned `undefined`,
- * which meant one call chain carried three different spellings of the same outcome and two
- * separate hand-written translations between them. One sentinel, checked one way.
- */
-/** a random element, or `null` for an empty list; draws from `source` when given */
-export declare function element<T>(items: readonly T[], source?: RandomSource): T | null;
-/** an index into `weights` drawn in proportion to its weight, or `null` if nothing has any; draws from `source` when given */
-export declare function weighted(weights: readonly number[], source?: FloatSource): number | null;
-/** a key from `weights`, drawn in proportion to the value it maps to, or `null` if none has any; draws from `source` when given */
-export declare function weightedKey<K>(weights: ReadonlyMap<K, number>, source?: FloatSource): K | null;
-/** Fisher-Yates, in place; draws from `source` when given */
-export declare function shuffle<T>(items: T[], source?: RandomSource): T[];
-/** the engine state a `MersenneTwister` save or a named stream resumes from */
-export interface MersenneTwisterState {
-    /** the value `seed()` was last given */
-    seed: number;
-    /** the 624 words of engine state */
-    state: number[];
-    /** how many words have been drawn from the current block */
-    index: number;
-    /** how many values have been produced since the last seed, `mt_rng.get_discard()`'s number */
-    discard: number;
-}
-/**
- * MT19937, the Mersenne Twister the reference strategy game's `mt_rng` wraps, with the same
- * `seed`/`discard` bookkeeping its save files use. The engine itself is exactly specified
- * (the paper's constants and the 32-bit seeding routine), so `nextUint32` matches that
- * engine bit for bit on any machine; a port that consumes the raw stream, or a replay of raw
- * draws, lines up.
- *
- * What is *not* portable is C++'s `std::uniform_int_distribution`, which the reference then
- * runs the engine through: the C++ standard leaves that mapping implementation-defined, so
- * two standard libraries do not agree on it. `int` here is the same unbiased rejection
- * `Generator` uses, which makes a replay deterministic within this framework rather than
- * bit-identical to any one C++ standard library.
- *
- * @example
- * ```ts
- * import { MersenneTwister } from '@datamoc/mw_games/core';
- *
- * const rng = new MersenneTwister(5489);
- * const first = rng.nextUint32(); // 3499211612, the engine's own first value for this seed
- * rng.discard(10); // skip ahead without consuming the values
- * const saved = rng.getState(); // { seed, state, index, discard } - restorable
- * ```
- */
-export declare class MersenneTwister {
-    private state;
-    private index;
-    private seedValue;
-    private produced;
-    constructor(seed?: number);
-    /** re-seeds the engine and resets the discard count, as `mt_rng::seed` does */
-    seed(seed: number): void;
-    private generate;
-    /** the raw generator, tempered as MT19937 specifies */
-    nextUint32(): number;
-    /** a float in [0, 1), with 32 bits of resolution */
-    float(): number;
-    /** an integer in [0, bound), without modulo bias (the same rule `Generator.int` uses) */
-    int(bound: number): number;
-    /** advances the engine without using the values, as `mt_rng::discard` does */
-    discard(count: number): void;
-    /** how many values have been produced since the last seed - `get_discard()`'s number */
-    get discardCount(): number;
-    getState(): MersenneTwisterState;
-    setState(state: MersenneTwisterState): void;
-}
-/**
- * Named, independent random streams over one base seed: `streams.stream('loot')` and
- * `streams.stream('ai:goblin-3')` each get their own MT19937 position, so one consumer
- * drawing more numbers never shifts another's results - the property a replay and a
- * per-entity stream both need, and one a single shared generator cannot give.
- *
- * A stream is created on first use, from `baseSeed ^ FNV-1a(name)`, and then kept. Creating
- * a stream later therefore does not disturb an existing one, which is what makes adding a
- * new consumer reproducible rather than a change to every draw after it.
- *
- * @example
- * ```ts
- * import { RandomStreams } from '@datamoc/mw_games/core';
- *
- * const streams = new RandomStreams(12345);
- * streams.stream('loot').int(100); // one stream
- * streams.stream('ai:goblin-3').int(6); // an unrelated one, unaffected by the loot draw
- *
- * const saved = streams.getState(); // every stream's engine state, for a save file
- * ```
- */
-export declare class RandomStreams {
-    private baseSeed;
-    private streams;
-    constructor(seed?: number);
-    /** the stream named `name`, created from the base seed on first use and kept after that */
-    stream(name: string): MersenneTwister;
-    /** the seed a stream was created from; undefined for one that has never been asked for */
-    seedOf(name: string): number | undefined;
-    /** drops every stream and re-bases future ones; existing streams are gone, not reset */
-    reseed(seed: number): void;
-    /** the names that have been asked for, in creation order */
-    names(): string[];
-    getState(): Record<string, MersenneTwisterState>;
-    /** restores what `getState` wrote; a stream missing from `state` stays as it was */
-    setState(state: Readonly<Record<string, MersenneTwisterState>>): void;
-}
-//# sourceMappingURL=Random.d.ts.map

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

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