narraleaf-react 0.13.2 → 0.14.0

package/dist/game/nlcore/action/gameHistory.d.ts

@@ -1,3 +1,4 @@
+import type { SerializedGameHistory, SerializedGameState } from "../gameTypes";
 import { Action } from "./action";
 import { ActionHistoryManager } from "./actionHistory";
 type GameHistoryAction = {
@@ -5,7 +6,7 @@ type GameHistoryAction = {
     action: Action;
     isPending?: boolean;
 };
-type GameElementHistory = {
+export type GameElementHistory = {
     type: "say";
     text: string;
     voice: string | null;
@@ -17,6 +18,12 @@ type GameElementHistory = {
 };
 export type GameHistory = GameHistoryAction & {
     element: GameElementHistory;
+    /**
+     * Self-contained core state captured when this line was reached, used to restore the game
+     * back to this backlog line (see {@link LiveGame.restoreToHistory}). Optional because a
+     * capture can fail, and legacy in-memory entries created before a snapshot was taken.
+     */
+    snapshot?: SerializedGameState | null;
 };
 export declare class GameHistoryManager {
     private history;
@@ -24,7 +31,28 @@ export declare class GameHistoryManager {
     constructor(actionHistoryMgr: ActionHistoryManager);
     push(action: GameHistory): this;
     getHistory(): GameHistory[];
+    getByToken(token: string): GameHistory | null;
+    /**
+     * Serialize the whole backlog for persistence (save format v2).
+     */
+    serialize(): SerializedGameHistory[];
+    /**
+     * Serialize the backlog up to and including the entry with the given token.
+     *
+     * Used by restore-to-history to trim the backlog back to the restored line.
+     * Returns an empty array if the token is not found.
+     */
+    serializeUntil(token: string): SerializedGameHistory[];
+    /**
+     * Rebuild the backlog from persisted entries.
+     *
+     * Each entry is re-bound to a live {@link Action} through `actionMap`; entries whose action no
+     * longer exists (the script changed since the save) are dropped rather than throwing, so a
+     * still-loadable save degrades to a shorter backlog instead of failing.
+     */
+    load(entries: SerializedGameHistory[], actionMap: ReadonlyMap<string, Action>): void;
     reset(): void;
+    private static toSerialized;
     updateByToken(id: string, handler: (result: GameHistory | null) => void): void;
     resolvePending(id: string): void;
     private crossFilter;

package/dist/game/nlcore/game/liveGame.d.ts

@@ -59,6 +59,18 @@ export declare class LiveGame {
      * - If the id is not provided, it will undo **the last action**
      */
     undo(id?: string): void;
+    /**
+     * Restore the game to a past backlog line.
+     *
+     * Unlike {@link undo}, this works **after loading a save**: it does not rely on the
+     * (non-serializable) undo stack. Every backlog entry carries a self-contained state snapshot,
+     * so restoring re-applies that snapshot and trims the backlog back to that line.
+     *
+     * @param token - the backlog entry token (as returned by {@link getHistory})
+     * @returns `true` if the line was restored, `false` if the token is unknown or the entry has
+     *          no restore snapshot.
+     */
+    restoreToHistory(token: string): boolean;
     /**
      * Notify the player with a message
      *
@@ -74,6 +86,35 @@ export declare class LiveGame {
      * Skip the current dialog
      */
     skipDialog(): void;
+    /**
+     * Fast-forward playback to the next menu (or the end of the story).
+     *
+     * Every line in between is executed for real, so the backlog and its restore snapshots
+     * accumulate exactly as in normal play — only faster and silent. Audio is muted for the
+     * duration, in-flight transitions are settled immediately, and timed pauses (`Control.sleep`,
+     * auto-forward) resolve at once. It stops as soon as a menu is waiting for a choice, so the
+     * choice itself is always left to the player.
+     *
+     * Because history accumulates the whole way, {@link getHistory} and
+     * {@link restoreToHistory} cover the fast-forwarded span just like normal play.
+     *
+     * ```typescript
+     * // Jump ahead to the next decision point.
+     * await game.getLiveGame().fastForward();
+     * ```
+     *
+     * @param options.until - `"menu"` (default) stops at the next menu; `"end"` runs until the
+     *                         story finishes.
+     * @param options.maxSteps - safety bound on the number of advance steps (defaults to the
+     *                           `maxStackModelLoop` config).
+     * @returns why it stopped: `"menu"`, `"end"` (the stack drained), or `"maxSteps"`.
+     */
+    fastForward(options?: {
+        until?: "menu" | "end";
+        maxSteps?: number;
+    }): Promise<{
+        reason: "menu" | "end" | "maxSteps";
+    }>;
     private assertScreenshot;
     /**
      * Capture the game screenshot, will only include the player element

package/dist/game/nlcore/gameTypes.d.ts

@@ -7,8 +7,17 @@ import { PlayerStateData } from "../player/gameState";
 import { GuardConfig } from "../player/guard";
 import React from "react";
 import { StackModel, StackModelRawData } from "./action/stackModel";
+import type { GameElementHistory } from "./action/gameHistory";
 import { MenuComponent, NotificationComponent, NvlDialogComponent, SayComponent } from "./common/player";
 import { LiveGameEventToken } from "./types";
+/**
+ * Current save format version.
+ *
+ * - v1 (undefined on the save): core resume state only, no backlog history.
+ * - v2: adds `game.history`, a full backlog where every entry carries a self-contained
+ *   restore snapshot, so loading a save keeps the backlog and any past line can be restored.
+ */
+export declare const SAVE_FORMAT_VERSION = 2;
 export interface SavedGameMetaData {
     /**
      * The timestamp of when the game was created
@@ -34,21 +43,63 @@ export interface SavedGameMetaData {
      * The hash of the story is used to check whether the stories are compatible.
      */
     storyHash: string;
+    /**
+     * The save format version (see {@link SAVE_FORMAT_VERSION}).
+     *
+     * Absent on legacy (v1) saves written before backlog history existed.
+     */
+    version?: number;
+}
+/**
+ * The core, resumable game state — everything needed to restore the game to a point,
+ * **without** the backlog history.
+ *
+ * This is the unit captured per backlog entry (see {@link SerializedGameHistory}); it is
+ * deliberately history-free so that per-entry snapshots do not nest the whole backlog inside
+ * themselves (which would make saves grow exponentially).
+ */
+export interface SerializedGameState {
+    store: {
+        [key: string]: SerializedNamespaceData;
+    };
+    elementStates: RawData<ElementStateRaw>[];
+    stage: PlayerStateData;
+    services: {
+        [key: string]: unknown;
+    };
+    stackModel: StackModelRawData;
+    asyncStackModels: StackModelRawData[];
+}
+/**
+ * A single persisted backlog line: the rendered say/menu content, a stable action anchor, and a
+ * self-contained snapshot that restores the game to exactly this line.
+ */
+export interface SerializedGameHistory {
+    /**
+     * Stable action id anchor (`action.getId()`). Used to re-bind the entry to the live story on
+     * load; entries whose action no longer exists (script changed) are dropped from the backlog.
+     */
+    actionId: string | null;
+    element: GameElementHistory;
+    isPending?: boolean;
+    /**
+     * Core game state captured when this line was reached. Restoring it returns the game to this
+     * exact line. `null` when a snapshot could not be captured (the line stays visible but is not
+     * restorable).
+     */
+    snapshot: SerializedGameState | null;
 }
 export interface SavedGame {
     name: string;
     meta: SavedGameMetaData;
-    game: {
-        store: {
-            [key: string]: SerializedNamespaceData;
-        };
-        elementStates: RawData<ElementStateRaw>[];
-        stage: PlayerStateData;
-        services: {
-            [key: string]: unknown;
-        };
-        stackModel: StackModelRawData;
-        asyncStackModels: StackModelRawData[];
+    game: SerializedGameState & {
+        /**
+         * Full backlog with per-entry restore snapshots (save format v2+).
+         *
+         * Absent on legacy saves; a missing/empty history simply means loading starts with an
+         * empty backlog, exactly as before this feature existed.
+         */
+        history?: SerializedGameHistory[];
     };
 }
 export type GameConfig = {

package/dist/game/player/gameState.d.ts

@@ -178,6 +178,7 @@ export declare class GameState {
     private stageClickBuffer;
     private readonly nvlAdvanceWaiters;
     private advDialogState;
+    private _fastForwarding;
     constructor(game: Game, stage: StageUtils);
     get deps(): number;
     addVideo(video: Video): this;