@datamoc/mw_games 0.43.0 → 0.45.0

package/dist/rpg/index.js

@@ -1,14 +0,0 @@
-export { automap } from './automap.js';
-export { EMPTY as AUTOMAP_EMPTY } from './automap.js';
-export { GameState } from './GameState.js';
-export { activePage, conditionHolds } from './Event.js';
-export { EventRunner } from './EventRunner.js';
-export { GridMover } from './GridMover.js';
-export { MoveRouteRunner } from './MoveRoute.js';
-export { FreeMover } from './FreeMover.js';
-export { aabbOverlap, circleOverlap, circleAabbOverlap, resolveAabbAgainstTiles } from './Collision.js';
-export { QuestLog, questsFromRows } from './Quest.js';
-export { decodeMarshal, encodeMarshal, RubySymbol, hashDefaultOf, withHashDefault } from './Marshal.js';
-export { parseDialogueText, extractDialogueCatalog } from './dialogue-text.js';
-export { importTwee } from './twee-events.js';
-//# sourceMappingURL=index.js.map

package/dist/rpg/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/rpg/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AAEvC,OAAO,EAAE,KAAK,IAAI,aAAa,EAAE,MAAM,cAAc,CAAC;AAEtD,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAC3C,OAAO,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAExD,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAW/C,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAE3C,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAEjD,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAE3C,OAAO,EAAE,WAAW,EAAE,aAAa,EAAE,iBAAiB,EAAE,uBAAuB,EAAE,MAAM,gBAAgB,CAAC;AAExG,OAAO,EAAE,QAAQ,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAEtD,OAAO,EAAE,aAAa,EAAE,aAAa,EAAE,UAAU,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAExG,OAAO,EAAE,iBAAiB,EAAE,sBAAsB,EAAE,MAAM,oBAAoB,CAAC;AAC/E,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC"}

package/dist/rpg/twee-events.d.ts

@@ -1,48 +0,0 @@
-import type { EventStoryScript } from './EventRunner.ts';
-/**
- * A story imported from Twine's Twee notation, ready for `EventRunner.runStory`.
- *
- * The `two-d/stage` counterpart, `importTwee`, targets `StageCommand`/`StoryScript` instead -
- * declared independently here for the same reason `EventChoice` already duplicates
- * `two-d/ui`'s `Choice`: a text-only RPG (`core` plus `rpg`, no renderer at all) should not
- * have to depend on `two-d` just to import a branching Twee story, and a Pixi-based visual
- * novel that never touches map events should not have to depend on `rpg` either.
- */
-export interface EventTwineStory {
-    story: EventStoryScript;
-    /** `StoryData`'s start passage when the file names one, else the first passage */
-    start: string;
-    /** the `StoryTitle` passage, when the file has one */
-    title?: string;
-}
-/**
- * Reads a `.twee` file into an `EventStoryScript`.
- *
- * The actual parsing (passages, `[[links]]`, `StoryData`/`StoryTitle`) lives once in
- * `core.parseTwee` - this is a thin wrapper naming the `rpg`-specific return type, the same
- * way `two-d/stage.importTwee` wraps the same engine for `StageCommand`.
- *
- * @example
- * ```ts
- * import { importTwee, EventRunner, GameState, type DialoguePresenter } from '@datamoc/mw_games/rpg';
- *
- * declare const present: DialoguePresenter;
- *
- * const story = importTwee(`:: Start
- * You stand at a crossroads.
- *
- * [[Take the left path->Left]]
- * [[Take the right path->Right]]
- *
- * :: Left
- * The path ends at a wall.
- *
- * :: Right
- * An open road.
- * `);
- * const runner = new EventRunner({ present, game: new GameState() });
- * await runner.runStory(story.story, story.start);
- * ```
- */
-export declare function importTwee(source: string): EventTwineStory;
-//# sourceMappingURL=twee-events.d.ts.map

package/dist/rpg/twee-events.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"twee-events.d.ts","sourceRoot":"","sources":["../../src/rpg/twee-events.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AAEzD;;;;;;;;GAQG;AACH,MAAM,WAAW,eAAe;IAC/B,KAAK,EAAE,gBAAgB,CAAC;IACxB,kFAAkF;IAClF,KAAK,EAAE,MAAM,CAAC;IACd,sDAAsD;IACtD,KAAK,CAAC,EAAE,MAAM,CAAC;CACf;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,eAAe,CAG1D"}

package/dist/rpg/twee-events.js

@@ -1,35 +0,0 @@
-import { parseTwee } from '../core/Twee.js';
-/**
- * Reads a `.twee` file into an `EventStoryScript`.
- *
- * The actual parsing (passages, `[[links]]`, `StoryData`/`StoryTitle`) lives once in
- * `core.parseTwee` - this is a thin wrapper naming the `rpg`-specific return type, the same
- * way `two-d/stage.importTwee` wraps the same engine for `StageCommand`.
- *
- * @example
- * ```ts
- * import { importTwee, EventRunner, GameState, type DialoguePresenter } from '@datamoc/mw_games/rpg';
- *
- * declare const present: DialoguePresenter;
- *
- * const story = importTwee(`:: Start
- * You stand at a crossroads.
- *
- * [[Take the left path->Left]]
- * [[Take the right path->Right]]
- *
- * :: Left
- * The path ends at a wall.
- *
- * :: Right
- * An open road.
- * `);
- * const runner = new EventRunner({ present, game: new GameState() });
- * await runner.runStory(story.story, story.start);
- * ```
- */
-export function importTwee(source) {
-    const { story, start, title } = parseTwee(source);
-    return title === undefined ? { story, start } : { story, start, title };
-}
-//# sourceMappingURL=twee-events.js.map

package/dist/rpg/twee-events.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"twee-events.js","sourceRoot":"","sources":["../../src/rpg/twee-events.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAoB5C;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,MAAM,UAAU,UAAU,CAAC,MAAc;IACxC,MAAM,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,GAAG,SAAS,CAAC,MAAM,CAAC,CAAC;IAClD,OAAO,KAAK,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC;AACzE,CAAC"}

package/dist/simulation/Campaign.d.ts

@@ -1,60 +0,0 @@
-import type { StateValue } from '../core/State.ts';
-export type CampaignOutcome = 'completed' | 'failed' | 'abandoned';
-export interface CampaignLevel<State extends StateValue, Result extends StateValue = StateValue> {
-    readonly id: string;
-    readonly run: (state: State, context: {
-        readonly levelId: string;
-    }) => CampaignLevelResult<State, Result>;
-}
-export interface CampaignLevelResult<State extends StateValue, Result extends StateValue = StateValue> {
-    readonly outcome: CampaignOutcome;
-    readonly state: State;
-    readonly result?: Result;
-    readonly next?: string | null;
-    readonly reminders?: readonly string[];
-}
-export interface CampaignSnapshot<State extends StateValue, Result extends StateValue = StateValue> {
-    readonly currentLevel: string | null;
-    readonly state: State;
-    readonly reminders: readonly string[];
-    readonly results: Readonly<Record<string, Result>>;
-}
-/**
- * Game-neutral level sequencing and carry-over state. A campaign adapter supplies the
- * actual level runner and decides what a level result means; MWG only preserves order,
- * transitions, reminders and serialisable state.
- *
- * @example
- * ```ts
- * import { Campaign } from '@datamoc/mw_games/simulation';
- * const campaign = new Campaign({
- *   levels: [{ id: 'intro', run: (state) => ({ outcome: 'completed', state, next: null }) }],
- *   start: 'intro', state: { gold: 0 },
- * });
- * campaign.completeCurrent({ outcome: 'completed', state: { gold: 10 }, next: null });
- * ```
- */
-export declare class Campaign<State extends StateValue, Result extends StateValue = StateValue> {
-    private readonly levels;
-    private _currentLevel;
-    private _state;
-    private _reminders;
-    private _results;
-    constructor(options: {
-        readonly levels: readonly CampaignLevel<State, Result>[];
-        readonly start: string;
-        readonly state: State;
-    });
-    get currentLevel(): string | null;
-    get state(): State;
-    get reminders(): readonly string[];
-    get results(): Readonly<Record<string, Result>>;
-    /** Runs the current level and applies its carry-over state and transition. */
-    playCurrent(): CampaignLevelResult<State, Result>;
-    completeCurrent(result: CampaignLevelResult<State, Result>): CampaignLevelResult<State, Result>;
-    snapshot(): CampaignSnapshot<State, Result>;
-    static restore<State extends StateValue, Result extends StateValue = StateValue>(snapshot: CampaignSnapshot<State, Result>, options: {
-        readonly levels: readonly CampaignLevel<State, Result>[];
-    }): Campaign<State, Result>;
-}
-//# sourceMappingURL=Campaign.d.ts.map

package/dist/simulation/Campaign.d.ts.map

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

package/dist/simulation/Campaign.js

@@ -1,89 +0,0 @@
-import { cloneData } from '../core/Clone.js';
-/**
- * Game-neutral level sequencing and carry-over state. A campaign adapter supplies the
- * actual level runner and decides what a level result means; MWG only preserves order,
- * transitions, reminders and serialisable state.
- *
- * @example
- * ```ts
- * import { Campaign } from '@datamoc/mw_games/simulation';
- * const campaign = new Campaign({
- *   levels: [{ id: 'intro', run: (state) => ({ outcome: 'completed', state, next: null }) }],
- *   start: 'intro', state: { gold: 0 },
- * });
- * campaign.completeCurrent({ outcome: 'completed', state: { gold: 10 }, next: null });
- * ```
- */
-export class Campaign {
-    constructor(options) {
-        this._reminders = [];
-        this._results = {};
-        this.levels = new Map(options.levels.map((level) => [level.id, level]));
-        if (this.levels.size !== options.levels.length)
-            throw new Error('campaign level ids must be unique');
-        if (!this.levels.has(options.start))
-            throw new Error(`unknown campaign start level: ${options.start}`);
-        this._currentLevel = options.start;
-        this._state = cloneData(options.state, 'campaign state');
-    }
-    get currentLevel() {
-        return this._currentLevel;
-    }
-    get state() {
-        return structuredClone(this._state);
-    }
-    get reminders() {
-        return [...this._reminders];
-    }
-    get results() {
-        return structuredClone(this._results);
-    }
-    /** Runs the current level and applies its carry-over state and transition. */
-    playCurrent() {
-        if (!this._currentLevel)
-            throw new Error('campaign has no current level');
-        const level = this.levels.get(this._currentLevel);
-        return this.completeCurrent(level.run(this.state, { levelId: level.id }));
-    }
-    completeCurrent(result) {
-        if (!this._currentLevel)
-            throw new Error('campaign has no current level');
-        const completedId = this._currentLevel;
-        // Both copies before either assignment, so a refused result leaves the campaign unchanged.
-        const state = cloneData(result.state, 'level result state');
-        const levelResult = result.result === undefined ? undefined : cloneData(result.result, 'level result');
-        this._state = state;
-        if (levelResult !== undefined)
-            this._results[completedId] = levelResult;
-        this._reminders = [...(result.reminders ?? [])];
-        if (result.outcome !== 'completed')
-            this._currentLevel = null;
-        else if (result.next === undefined)
-            throw new Error(`campaign level ${completedId} did not choose a next level`);
-        else {
-            if (result.next !== null && !this.levels.has(result.next))
-                throw new Error(`unknown campaign transition: ${completedId} -> ${result.next}`);
-            this._currentLevel = result.next;
-        }
-        return { ...result, state: this.state };
-    }
-    snapshot() {
-        return {
-            currentLevel: this._currentLevel,
-            state: this.state,
-            reminders: this.reminders,
-            results: this.results,
-        };
-    }
-    static restore(snapshot, options) {
-        const start = snapshot.currentLevel ?? options.levels[0]?.id;
-        if (!start)
-            throw new Error('campaign restore requires at least one level');
-        const campaign = new Campaign({ levels: options.levels, start, state: snapshot.state });
-        campaign._currentLevel = snapshot.currentLevel;
-        campaign._reminders = [...snapshot.reminders];
-        campaign._results = cloneData(snapshot.results, 'snapshot.results');
-        return campaign;
-    }
-}
-//# sourceMappingURL=Campaign.js.map

package/dist/simulation/Campaign.js.map

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

package/dist/simulation/CampaignSave.d.ts

@@ -1,68 +0,0 @@
-import { type SaveMeta, type SaveSystemOptions } from '../core/Save.ts';
-import type { StateValue } from '../core/State.ts';
-import type { CampaignSnapshot } from './Campaign.ts';
-import type { SimulationSnapshot } from './Runtime.ts';
-/**
- * Everything one campaign save holds, as plain JSON: which level the campaign is on and what
- * it carries, the scenario/world state, and the turn-level simulation. The `world` payload is
- * opaque here on purpose - an `mwl.MwlWorld`, a `roguelike.Level`, a game's own scenario
- * object - because this is a container, the same way `SaveSystem` is.
- */
-export interface CampaignSaveState<CampaignState extends StateValue, Result extends StateValue, World, TurnState> {
-    readonly campaign: CampaignSnapshot<CampaignState, Result>;
-    readonly world: World;
-    readonly simulation: SimulationSnapshot<TurnState> | null;
-}
-/** The live pieces to capture: anything with the snapshot method, so no class import is forced. */
-export interface CampaignSaveParts<CampaignState extends StateValue, Result extends StateValue, World, TurnState> {
-    readonly campaign: {
-        snapshot(): CampaignSnapshot<CampaignState, Result>;
-    };
-    readonly world: World;
-    readonly simulation?: {
-        snapshot(): SimulationSnapshot<TurnState>;
-    } | null;
-}
-/**
- * One save slot for a whole campaign, over `core.SaveSystem`. `SaveSystem` deliberately owns
- * one state value and `mwl`'s persistence owns one world, so neither saves a campaign's level
- * sequence, its world and its turn together; this is the composition, not a second save
- * format. Versioning, migrations, previews, the storage fallback and slot listing are all
- * `SaveSystem`'s, unchanged.
- *
- * Capturing takes each piece's own `snapshot()`, so the pieces stay responsible for what
- * resuming them means: `Campaign.restore` and `SimulationRuntime.restore` read their halves
- * back, and the game reads its own world.
- *
- * @example
- * ```ts
- * import { CampaignSave } from '@datamoc/mw_games/simulation';
- *
- * const saves = new CampaignSave<{ gold: number }, never, unknown, { hp: number }>({
- *   namespace: 'my-campaign',
- *   version: 1,
- * });
- *
- * declare const campaign: { snapshot(): never };
- * declare const simulation: { snapshot(): never };
- * saves.save('slot1', { campaign, world: { terrain: '...' }, simulation }, 'Chapter 2');
- *
- * const loaded = saves.load('slot1');
- * // loaded.campaign -> Campaign.restore(...); loaded.world -> the game's own; loaded.simulation -> SimulationRuntime.restore(...)
- * ```
- */
-export declare class CampaignSave<CampaignState extends StateValue, Result extends StateValue, World, TurnState> {
-    private readonly saves;
-    constructor(options: SaveSystemOptions);
-    /** Writes one slot: the campaign, the world and the simulation captured together. */
-    save(slot: string, parts: CampaignSaveParts<CampaignState, Result, World, TurnState>, preview?: unknown): void;
-    /** Reads one slot back as plain state, already migrated to the current version. */
-    load(slot: string): CampaignSaveState<CampaignState, Result, World, TurnState> | null;
-    /** Every slot with a save, and its metadata, for a save-select screen. */
-    list(): Array<{
-        slot: string;
-        meta: SaveMeta;
-    }>;
-    delete(slot: string): void;
-}
-//# sourceMappingURL=CampaignSave.d.ts.map

package/dist/simulation/CampaignSave.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"CampaignSave.d.ts","sourceRoot":"","sources":["../../src/simulation/CampaignSave.ts"],"names":[],"mappings":"AAAA,OAAO,EAAc,KAAK,QAAQ,EAAE,KAAK,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AACpF,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AACnD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AACtD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AAEvD;;;;;GAKG;AACH,MAAM,WAAW,iBAAiB,CAAC,aAAa,SAAS,UAAU,EAAE,MAAM,SAAS,UAAU,EAAE,KAAK,EAAE,SAAS;IAC/G,QAAQ,CAAC,QAAQ,EAAE,gBAAgB,CAAC,aAAa,EAAE,MAAM,CAAC,CAAC;IAC3D,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC;IACtB,QAAQ,CAAC,UAAU,EAAE,kBAAkB,CAAC,SAAS,CAAC,GAAG,IAAI,CAAC;CAC1D;AAED,mGAAmG;AACnG,MAAM,WAAW,iBAAiB,CAAC,aAAa,SAAS,UAAU,EAAE,MAAM,SAAS,UAAU,EAAE,KAAK,EAAE,SAAS;IAC/G,QAAQ,CAAC,QAAQ,EAAE;QAAE,QAAQ,IAAI,gBAAgB,CAAC,aAAa,EAAE,MAAM,CAAC,CAAA;KAAE,CAAC;IAC3E,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC;IACtB,QAAQ,CAAC,UAAU,CAAC,EAAE;QAAE,QAAQ,IAAI,kBAAkB,CAAC,SAAS,CAAC,CAAA;KAAE,GAAG,IAAI,CAAC;CAC3E;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,qBAAa,YAAY,CAAC,aAAa,SAAS,UAAU,EAAE,MAAM,SAAS,UAAU,EAAE,KAAK,EAAE,SAAS;IACtG,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAyE;IAE/F,YAAY,OAAO,EAAE,iBAAiB,EAErC;IAED,qFAAqF;IACrF,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,iBAAiB,CAAC,aAAa,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,CAAC,EAAE,OAAO,CAAC,EAAE,OAAO,GAAG,IAAI,CAU7G;IAED,mFAAmF;IACnF,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,iBAAiB,CAAC,aAAa,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,CAAC,GAAG,IAAI,CAEpF;IAED,0EAA0E;IAC1E,IAAI,IAAI,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,QAAQ,CAAA;KAAE,CAAC,CAE9C;IAED,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAEzB;CACD"}

package/dist/simulation/CampaignSave.js

@@ -1,54 +0,0 @@
-import { SaveSystem } from '../core/Save.js';
-/**
- * One save slot for a whole campaign, over `core.SaveSystem`. `SaveSystem` deliberately owns
- * one state value and `mwl`'s persistence owns one world, so neither saves a campaign's level
- * sequence, its world and its turn together; this is the composition, not a second save
- * format. Versioning, migrations, previews, the storage fallback and slot listing are all
- * `SaveSystem`'s, unchanged.
- *
- * Capturing takes each piece's own `snapshot()`, so the pieces stay responsible for what
- * resuming them means: `Campaign.restore` and `SimulationRuntime.restore` read their halves
- * back, and the game reads its own world.
- *
- * @example
- * ```ts
- * import { CampaignSave } from '@datamoc/mw_games/simulation';
- *
- * const saves = new CampaignSave<{ gold: number }, never, unknown, { hp: number }>({
- *   namespace: 'my-campaign',
- *   version: 1,
- * });
- *
- * declare const campaign: { snapshot(): never };
- * declare const simulation: { snapshot(): never };
- * saves.save('slot1', { campaign, world: { terrain: '...' }, simulation }, 'Chapter 2');
- *
- * const loaded = saves.load('slot1');
- * // loaded.campaign -> Campaign.restore(...); loaded.world -> the game's own; loaded.simulation -> SimulationRuntime.restore(...)
- * ```
- */
-export class CampaignSave {
-    constructor(options) {
-        this.saves = new SaveSystem(options);
-    }
-    /** Writes one slot: the campaign, the world and the simulation captured together. */
-    save(slot, parts, preview) {
-        this.saves.save(slot, {
-            campaign: parts.campaign.snapshot(),
-            world: parts.world,
-            simulation: parts.simulation ? parts.simulation.snapshot() : null,
-        }, preview);
-    }
-    /** Reads one slot back as plain state, already migrated to the current version. */
-    load(slot) {
-        return this.saves.load(slot)?.state ?? null;
-    }
-    /** Every slot with a save, and its metadata, for a save-select screen. */
-    list() {
-        return this.saves.list();
-    }
-    delete(slot) {
-        this.saves.delete(slot);
-    }
-}
-//# sourceMappingURL=CampaignSave.js.map

package/dist/simulation/CampaignSave.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"CampaignSave.js","sourceRoot":"","sources":["../../src/simulation/CampaignSave.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAyC,MAAM,iBAAiB,CAAC;AAwBpF;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,MAAM,OAAO,YAAY;IAGxB,YAAY,OAA0B;QACrC,IAAI,CAAC,KAAK,GAAG,IAAI,UAAU,CAA6D,OAAO,CAAC,CAAC;IAClG,CAAC;IAED,qFAAqF;IACrF,IAAI,CAAC,IAAY,EAAE,KAAiE,EAAE,OAAiB;QACtG,IAAI,CAAC,KAAK,CAAC,IAAI,CACd,IAAI,EACJ;YACC,QAAQ,EAAE,KAAK,CAAC,QAAQ,CAAC,QAAQ,EAAE;YACnC,KAAK,EAAE,KAAK,CAAC,KAAK;YAClB,UAAU,EAAE,KAAK,CAAC,UAAU,CAAC,CAAC,CAAC,KAAK,CAAC,UAAU,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC,IAAI;SACjE,EACD,OAAO,CACP,CAAC;IACH,CAAC;IAED,mFAAmF;IACnF,IAAI,CAAC,IAAY;QAChB,OAAO,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,KAAK,IAAI,IAAI,CAAC;IAC7C,CAAC;IAED,0EAA0E;IAC1E,IAAI;QACH,OAAO,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC;IAC1B,CAAC;IAED,MAAM,CAAC,IAAY;QAClB,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;IACzB,CAAC;CACD"}

package/dist/simulation/EventPresentation.d.ts

@@ -1,111 +0,0 @@
-import { PresentationQueue } from '../core/Presentation.ts';
-import type { Actor } from '../roguelike/Scheduler.ts';
-import { SimulationRuntime } from './Runtime.ts';
-import type { SimulationOutcome, SimulationSnapshot, SimulationRuntimeRule } from './Runtime.ts';
-export interface EventPresentationOptions<State, Command, Event, A extends Actor> {
-    /** the simulation whose commands this presents */
-    runtime: SimulationRuntime<State, Command, Event, A>;
-    /**
-     * The game's own mapping from one event to what it looks like: a tween, a sound, a
-     * floating number. Returns how many seconds the next event should wait, the same contract
-     * `PresentationQueue`'s own `play` has.
-     */
-    play: (event: Event) => number | void;
-    /**
-     * Commands a secondary actor should take once the batch that just resolved has finished
-     * presenting - a counter-attack, the next actor the scheduler calls. Receives the outcome
-     * that just resolved and returns whatever commands follow from it, in order; return an
-     * empty list (or omit the option) when nothing follows. A game reads the scheduler through
-     * its own closure to decide who is next.
-     *
-     * Must eventually return nothing: this is what chains a turn forward, so a function that
-     * always returns a command would spin forever.
-     */
-    followUp?: (outcome: SimulationOutcome<State, Event>) => readonly Command[];
-}
-/**
- * The documented integration between a turn-based simulation and its presentation, over the
- * two pieces that already exist (`simulation.SimulationRuntime` and `core.PresentationQueue`)
- * rather than a third kind of thing. It fixes the five interactions that are easy to get
- * subtly wrong when a game wires them by hand:
- *
- * - **A command result**: `submit` dispatches through the runtime and hands the returned
- *   events to the queue, in one call, so the state commit and the animation are never started
- *   from two places that can drift apart.
- * - **An animation lock**: `locked` is the queue's own `isBusy`, and `submit` refuses while it
- *   is true - a click during an attack cannot commit a second attack on top of the first.
- * - **A scheduled secondary actor**: `followUp` returns the commands that follow an outcome,
- *   and they are dispatched only once the batch before them has finished presenting, so the
- *   counter-attack animation starts after the attack animation, not underneath it.
- * - **Cancellation**: `cancel` drops everything not yet played. The simulation state is not
- *   rolled back, because the commands it already committed *did* happen; cancelling stops the
- *   show, it does not undo the turn.
- * - **Save/load**: `snapshot` saves the simulation only, deliberately not the queue. A
- *   restored run comes back idle, so loading mid-animation skips the rest of that batch
- *   instead of replaying it on top of the loaded state.
- *
- * @example
- * ```ts
- * import { EventPresentation } from '@datamoc/mw_games/simulation';
- * import type { SimulationRuntime } from '@datamoc/mw_games/simulation';
- * import type { Actor } from '@datamoc/mw_games/roguelike';
- *
- * interface Fighter extends Actor {
- *   id: string;
- * }
- *
- * declare const runtime: SimulationRuntime<{ hp: number }, 'attack' | 'counter', { amount: number }, Fighter>;
- *
- * const presentation = new EventPresentation({
- *   runtime,
- *   play: (event) => 0.25 * event.amount, // a hit is a quarter second per point
- *   followUp: (outcome): readonly ('attack' | 'counter')[] =>
- *     outcome.events.length > 0 ? ['counter'] : [],
- * });
- *
- * presentation.submit('attack'); // commits the attack and starts its animation
- * presentation.submit('attack'); // null - the first is still playing
- * presentation.update(1 / 60); // drains the queue, then the scheduled counter
- * presentation.cancel(); // abandons whatever is left; the committed state stands
- * const saved = presentation.snapshot(); // the simulation only
- * ```
- */
-export declare class EventPresentation<State, Command, Event, A extends Actor> {
-    readonly runtime: SimulationRuntime<State, Command, Event, A>;
-    readonly queue: PresentationQueue<Event>;
-    private readonly followUpOf?;
-    private followUps;
-    constructor(options: EventPresentationOptions<State, Command, Event, A>);
-    /** true while events are presenting or waiting behind the current one; input belongs to the animation */
-    get locked(): boolean;
-    /**
-     * Runs `command`, enqueues its events, and returns the outcome - or null when `locked`, so
-     * a command issued mid-animation is refused rather than committed ahead of the show.
-     */
-    submit(command: Command): SimulationOutcome<State, Event> | null;
-    /** advances the current animation and starts whatever follows it */
-    update(dt: number): void;
-    /**
-     * Abandons every event not yet presented, current one included, and any scheduled
-     * follow-ups. The simulation's committed state is untouched: cancellation stops the
-     * presentation, not the turn.
-     */
-    cancel(): void;
-    /** saves the simulation state; the queue is deliberately not part of a save */
-    snapshot(version?: number): SimulationSnapshot<State>;
-    /**
-     * Rebuilds a runtime from `snapshot` and wraps it in a fresh, idle presentation, so a
-     * loaded run does not replay the animation that was interrupted.
-     */
-    static restore<State, Command, Event, A extends Actor>(snapshot: SimulationSnapshot<State>, options: {
-        play: (event: Event) => number | void;
-        followUp?: (outcome: SimulationOutcome<State, Event>) => readonly Command[];
-        rule: SimulationRuntimeRule<State, Command, Event, A>;
-        actorOf: (id: string) => A;
-        actorId: (actor: A) => string;
-    }): EventPresentation<State, Command, Event, A>;
-    private commit;
-    /** runs scheduled follow-ups while the queue is idle, so each starts after the last finished */
-    private drainFollowUps;
-}
-//# sourceMappingURL=EventPresentation.d.ts.map

package/dist/simulation/EventPresentation.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"EventPresentation.d.ts","sourceRoot":"","sources":["../../src/simulation/EventPresentation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAC5D,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,2BAA2B,CAAC;AACvD,OAAO,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAC;AACjD,OAAO,KAAK,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,qBAAqB,EAAE,MAAM,cAAc,CAAC;AAEjG,MAAM,WAAW,wBAAwB,CAAC,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,CAAC,SAAS,KAAK;IAC/E,kDAAkD;IAClD,OAAO,EAAE,iBAAiB,CAAC,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC;IAErD;;;;OAIG;IACH,IAAI,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,MAAM,GAAG,IAAI,CAAC;IAEtC;;;;;;;;;OASG;IACH,QAAQ,CAAC,EAAE,CAAC,OAAO,EAAE,iBAAiB,CAAC,KAAK,EAAE,KAAK,CAAC,KAAK,SAAS,OAAO,EAAE,CAAC;CAC5E;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AACH,qBAAa,iBAAiB,CAAC,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,CAAC,SAAS,KAAK;IACpE,QAAQ,CAAC,OAAO,EAAE,iBAAiB,CAAC,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC;IAC9D,QAAQ,CAAC,KAAK,EAAE,iBAAiB,CAAC,KAAK,CAAC,CAAC;IAEzC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAmE;IAC/F,OAAO,CAAC,SAAS,CAAiB;IAElC,YAAY,OAAO,EAAE,wBAAwB,CAAC,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,CAAC,CAAC,EAItE;IAED,yGAAyG;IACzG,IAAI,MAAM,IAAI,OAAO,CAEpB;IAED;;;OAGG;IACH,MAAM,CAAC,OAAO,EAAE,OAAO,GAAG,iBAAiB,CAAC,KAAK,EAAE,KAAK,CAAC,GAAG,IAAI,CAG/D;IAED,oEAAoE;IACpE,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,CAGvB;IAED;;;;OAIG;IACH,MAAM,IAAI,IAAI,CAGb;IAED,+EAA+E;IAC/E,QAAQ,CAAC,OAAO,SAAI,GAAG,kBAAkB,CAAC,KAAK,CAAC,CAE/C;IAED;;;OAGG;IACH,MAAM,CAAC,OAAO,CAAC,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,CAAC,SAAS,KAAK,EACpD,QAAQ,EAAE,kBAAkB,CAAC,KAAK,CAAC,EACnC,OAAO,EAAE;QACR,IAAI,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,MAAM,GAAG,IAAI,CAAC;QACtC,QAAQ,CAAC,EAAE,CAAC,OAAO,EAAE,iBAAiB,CAAC,KAAK,EAAE,KAAK,CAAC,KAAK,SAAS,OAAO,EAAE,CAAC;QAC5E,IAAI,EAAE,qBAAqB,CAAC,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC;QACtD,OAAO,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,CAAC,CAAC;QAC3B,OAAO,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,MAAM,CAAC;KAC9B,GACC,iBAAiB,CAAC,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,CAAC,CAAC,CAW7C;IAED,OAAO,CAAC,MAAM;IAQd,gGAAgG;IAChG,OAAO,CAAC,cAAc;CAMtB"}

package/dist/simulation/EventPresentation.js

@@ -1,120 +0,0 @@
-import { PresentationQueue } from '../core/Presentation.js';
-import { SimulationRuntime } from './Runtime.js';
-/**
- * The documented integration between a turn-based simulation and its presentation, over the
- * two pieces that already exist (`simulation.SimulationRuntime` and `core.PresentationQueue`)
- * rather than a third kind of thing. It fixes the five interactions that are easy to get
- * subtly wrong when a game wires them by hand:
- *
- * - **A command result**: `submit` dispatches through the runtime and hands the returned
- *   events to the queue, in one call, so the state commit and the animation are never started
- *   from two places that can drift apart.
- * - **An animation lock**: `locked` is the queue's own `isBusy`, and `submit` refuses while it
- *   is true - a click during an attack cannot commit a second attack on top of the first.
- * - **A scheduled secondary actor**: `followUp` returns the commands that follow an outcome,
- *   and they are dispatched only once the batch before them has finished presenting, so the
- *   counter-attack animation starts after the attack animation, not underneath it.
- * - **Cancellation**: `cancel` drops everything not yet played. The simulation state is not
- *   rolled back, because the commands it already committed *did* happen; cancelling stops the
- *   show, it does not undo the turn.
- * - **Save/load**: `snapshot` saves the simulation only, deliberately not the queue. A
- *   restored run comes back idle, so loading mid-animation skips the rest of that batch
- *   instead of replaying it on top of the loaded state.
- *
- * @example
- * ```ts
- * import { EventPresentation } from '@datamoc/mw_games/simulation';
- * import type { SimulationRuntime } from '@datamoc/mw_games/simulation';
- * import type { Actor } from '@datamoc/mw_games/roguelike';
- *
- * interface Fighter extends Actor {
- *   id: string;
- * }
- *
- * declare const runtime: SimulationRuntime<{ hp: number }, 'attack' | 'counter', { amount: number }, Fighter>;
- *
- * const presentation = new EventPresentation({
- *   runtime,
- *   play: (event) => 0.25 * event.amount, // a hit is a quarter second per point
- *   followUp: (outcome): readonly ('attack' | 'counter')[] =>
- *     outcome.events.length > 0 ? ['counter'] : [],
- * });
- *
- * presentation.submit('attack'); // commits the attack and starts its animation
- * presentation.submit('attack'); // null - the first is still playing
- * presentation.update(1 / 60); // drains the queue, then the scheduled counter
- * presentation.cancel(); // abandons whatever is left; the committed state stands
- * const saved = presentation.snapshot(); // the simulation only
- * ```
- */
-export class EventPresentation {
-    constructor(options) {
-        this.followUps = [];
-        this.runtime = options.runtime;
-        this.queue = new PresentationQueue({ play: options.play });
-        this.followUpOf = options.followUp;
-    }
-    /** true while events are presenting or waiting behind the current one; input belongs to the animation */
-    get locked() {
-        return this.queue.isBusy;
-    }
-    /**
-     * Runs `command`, enqueues its events, and returns the outcome - or null when `locked`, so
-     * a command issued mid-animation is refused rather than committed ahead of the show.
-     */
-    submit(command) {
-        if (this.locked)
-            return null;
-        return this.commit(command);
-    }
-    /** advances the current animation and starts whatever follows it */
-    update(dt) {
-        this.queue.update(dt);
-        this.drainFollowUps();
-    }
-    /**
-     * Abandons every event not yet presented, current one included, and any scheduled
-     * follow-ups. The simulation's committed state is untouched: cancellation stops the
-     * presentation, not the turn.
-     */
-    cancel() {
-        this.queue.clear();
-        this.followUps = [];
-    }
-    /** saves the simulation state; the queue is deliberately not part of a save */
-    snapshot(version = 1) {
-        return this.runtime.snapshot(version);
-    }
-    /**
-     * Rebuilds a runtime from `snapshot` and wraps it in a fresh, idle presentation, so a
-     * loaded run does not replay the animation that was interrupted.
-     */
-    static restore(snapshot, options) {
-        const runtime = SimulationRuntime.restore(snapshot, {
-            rule: options.rule,
-            actorOf: options.actorOf,
-            actorId: options.actorId,
-        });
-        return new EventPresentation({
-            runtime,
-            play: options.play,
-            followUp: options.followUp,
-        });
-    }
-    commit(command) {
-        const outcome = this.runtime.dispatch(command);
-        this.queue.enqueue(outcome.events);
-        if (this.followUpOf)
-            this.followUps.push(...this.followUpOf(outcome));
-        this.drainFollowUps();
-        return outcome;
-    }
-    /** runs scheduled follow-ups while the queue is idle, so each starts after the last finished */
-    drainFollowUps() {
-        while (!this.queue.isBusy && this.followUps.length > 0) {
-            const command = this.followUps.shift();
-            this.commit(command);
-        }
-    }
-}
-//# sourceMappingURL=EventPresentation.js.map