narraleaf-react 1.1.1 → 1.2.1

package/dist/game/nlcore/action/actions/vfxAction.d.ts

@@ -18,6 +18,15 @@ export declare class VfxAction<T extends Values<typeof VfxActionTypes> = Values<
         readonly setRate: "vfx:setRate";
     };
     executeAction(gameState: GameState, injection: ActionExecutionInjection): Awaitable<CalledActionResult>;
+    /**
+     * A pause, a resume or a rate change aimed at an overlay that is no longer on the stage.
+     *
+     * An overlay leaves the stage with the scene that started it, so a handle kept in script and used
+     * after that scene is gone has nothing to talk to. It does nothing and says so - what `hide` on an
+     * overlay that is not shown has always done, and what a clip's transport does - rather than
+     * stopping the story.
+     */
+    private skipOffStage;
     private changeStateBase;
     private changeState;
     private changeStateAsync;

package/dist/game/nlcore/elements/vfx.d.ts

@@ -54,8 +54,13 @@ export type VfxStateRaw = {
  * A full-screen looping video overlay for particle and ambience effects
  * (falling petals, light dust, rain, snow, fog, light flares).
  *
- * The effect is a pre-rendered video that plays above the scenes and videos of the
- * stage; camera transforms apply to it like any other stage content.
+ * The effect is a pre-rendered video that plays over the scene that shows it, above that scene's
+ * sprites and videos; camera transforms apply to it like any other stage content.
+ *
+ * Like everything else on the stage, an overlay belongs to the scene that shows it: rain started in
+ * one scene stops when the story jumps to another, waits hidden and paused while its scene has
+ * called another, and comes back when the call returns. A scene that wants the rain to go on shows
+ * it itself.
  */
 export declare class Vfx extends Actionable<VfxStateRaw> {
     /**
@@ -104,8 +109,8 @@ export declare class Vfx extends Actionable<VfxStateRaw> {
      *
      * A paused video decodes nothing, so a hidden overlay costs no frame time — and keeping the
      * element means the next {@link show} has a decoder already holding the clip instead of starting
-     * over. Both halves of the same decision: stop the work, keep the warmth. Only a new game or a
-     * load clears the stage.
+     * over. Both halves of the same decision: stop the work, keep the warmth. The overlay leaves the
+     * stage when its scene does.
      *
      * The action waits for the fade-out to finish. Calling it while the overlay is
      * not shown is a no-op (a weak warning is logged).

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

@@ -141,6 +141,14 @@ export type PlayerStateData = {
              * scenes, and a clip no scene names is given to the scene the story is running in.
              */
             videos?: string[];
+            /**
+             * The ids of the overlays this scene put on the stage, the same way
+             * {@link videos} names its clips. Their state is in {@link PlayerStateData.vfx}.
+             *
+             * Written only when the scene has any. Absent in saves written before overlays belonged
+             * to scenes, and an overlay no scene names is given to the scene the story is running in.
+             */
+            vfx?: string[];
         };
     }[];
     audio: AudioManagerDataRaw;
@@ -172,6 +180,12 @@ export type PlayerStateElementSnapshot = {
      * clips belonged to scenes; read as none.
      */
     videos?: [Video, VideoStateRaw][];
+    /**
+     * The overlays this scene had on the stage, each with its state, in stage order - for the same
+     * reason as {@link videos}. Absent in snapshots taken before overlays belonged to scenes; read as
+     * none.
+     */
+    vfx?: [Vfx, VfxStateRaw][];
 };
 export type PlayerAction = CalledActionResult;
 interface StageUtils {
@@ -236,6 +250,12 @@ export declare class GameState {
      * the stage order of clips is not grouped by scene.
      */
     private videoOwners;
+    /**
+     * Which scene each overlay on the stage belongs to: the one running when it went on. An overlay
+     * is a stage object like any other - rain started in a scene stops when the scene is left - and
+     * it is drawn beside its scene's root for the reason a clip is (see {@link videoOwners}).
+     */
+    private vfxOwners;
     private videoMissingReporter;
     /** Sources already reported as unwarmed, so one clip in a loop does not report every pass. */
     private readonly reportedUnwarmedVideos;
@@ -588,6 +608,11 @@ export declare class GameState {
      * come back with it when the step is undone.
      */
     private releaseVideosOf;
+    /**
+     * The overlay half of leaving a scene, the same as {@link releaseVideosOf}: rain the scene started
+     * stops when the scene is left, and the overlay goes back to its authored state.
+     */
+    private releaseVfxOf;
     private syncNvlDerivedState;
     private emitNvlStateChange;
     private resolveNvlAdvance;

package/dist/game/player/lib/parkedPlayback.d.ts

@@ -0,0 +1 @@
+export {};