narraleaf-react 0.0.1-beta.12 → 0.0.1-beta.13

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

@@ -30,8 +30,8 @@ export type SceneDataRaw = {
     state: {
         backgroundMusic?: SoundDataRaw | null;
         background?: Background["background"];
-        backgroundImageState?: Partial<CommonImage>;
     };
+    backgroundImageState?: Partial<CommonImage>;
 };
 export type SceneEventTypes = {
     "event:scene.applyTransition": [ITransition | null];
@@ -46,35 +46,48 @@ export type SceneEventTypes = {
     "event:scene.setBackgroundMusic": [Sound | null, number];
     "event:scene.applyTransform": [Transform<ImageTransformProps>];
 };
-export declare class Scene extends Constructable<Actions> {
+export declare class Scene extends Constructable<Actions, Scene> {
     static EventTypes: {
         [K in keyof SceneEventTypes]: K;
     };
     static defaultConfig: SceneConfig;
     static defaultState: SceneState;
-    static targetAction: typeof SceneAction;
     readonly id: string;
     readonly name: string;
     readonly config: SceneConfig;
     state: SceneConfig & SceneState;
-    srcManager: SrcManager;
-    events: EventDispatcher<SceneEventTypes>;
+    readonly srcManager: SrcManager;
+    readonly events: EventDispatcher<SceneEventTypes>;
     backgroundImageState: Partial<CommonImage>;
     _liveState: {
         active: boolean;
     };
     sceneRoot?: SceneAction<"scene:action">;
     constructor(name: string, config?: DeepPartial<SceneConfig>);
+    /**
+     * Activate the scene
+     *
+     * This is only used when auto activation is not working
+     * @chainable
+     */
     activate(): ChainedScene;
+    /**
+     * Deactivate the scene
+     *
+     * This is only used when auto deactivation is not working
+     * @chainable
+     */
     deactivate(): ChainedScene;
     /**
      * Set background, if {@link transition} is provided, it will be applied
+     * @chainable
      */
     setBackground(background: Background["background"], transition?: ITransition): ChainedScene;
     /**
      * Apply a transform to the scene
      *
      * for example, you can shake the scene by applying a transform with a shake effect
+     * @chainable
      */
     applyTransform(transform: Transform<ImageTransformProps>): ChainedScene;
     /**
@@ -86,7 +99,6 @@ export declare class Scene extends Constructable<Actions> {
      * @chainable
      */
     jumpTo(arg0: Scene, config?: Partial<JumpConfig>): ChainedScene;
-    transitionSceneBackground(scene?: Scene, transition?: ITransition): ChainedScene;
     /**
      * Wait for a period of time, the parameter can be the number of milliseconds, a Promise, or an unresolved {@link Awaitable}
      * @chainable
@@ -98,19 +110,26 @@ export declare class Scene extends Constructable<Actions> {
      * Set background music
      * @param sound Target music
      * @param fade If set, the fade-out effect will be applied to the previous music, and the fade-in effect will be applied to the current music, with a duration of {@link fade} milliseconds
+     * @chainable
      */
     setBackgroundMusic(sound: Sound, fade?: number): ChainedScene;
-    _$getBackgroundMusic(): Sound | null;
     toData(): SceneDataRaw | null;
     fromData(data: SceneDataRaw): this;
-    _setTransition(transition: ITransition): ChainedScene;
-    _applyTransition(transition: ITransition): ChainedScene;
-    _toTransform(): Transform<ImageTransformProps>;
-    _initTransform(): Transform<ImageTransformProps>;
-    registerSrc(seen?: Set<Scene>): void;
+    getInitTransform(): Transform<ImageTransformProps>;
     action(actions: (ChainableAction | ChainableAction[])[]): this;
     action(actions: ((scene: Scene) => ChainableAction[])): this;
-    _jumpTo(scene: Scene): ChainedScene;
+    registerSrc(seen?: Set<Scene>): void;
+    /**
+     * @internal STILL IN DEVELOPMENT
+     */
+    assignActionId(): void;
+    /**
+     * @internal STILL IN DEVELOPMENT
+     */
+    assignElementId(): void;
+    private _applyTransition;
+    private _transitionSceneBackground;
+    private _jumpTo;
     private _exit;
     private _transitionToScene;
     private _init;

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

@@ -1,41 +1,17 @@
 import { Constructable } from "../action/constructable";
-import { LogicAction } from "../game";
-import { SceneAction, StoryAction } from "../action/actions";
-import { RawData, RenderableNode } from "../action/tree/actionTree";
+import { SceneAction } from "../action/actions";
 import { Scene } from "../elements/scene";
+import { RawData } from "../action/tree/actionTree";
 export type StoryConfig = {};
 export type ElementStateRaw = Record<string, any>;
 export type NodeChildIdMap = Map<string, string>;
-export declare class Story extends Constructable<SceneAction<"scene:action">> {
+export declare class Story extends Constructable<SceneAction<"scene:action">, Story> {
     static defaultConfig: StoryConfig;
-    static targetAction: typeof StoryAction;
     readonly id: string;
     readonly name: string;
     readonly config: StoryConfig;
     entryScene: Scene | null;
     constructor(name: string, config?: StoryConfig);
-    /**@internal */
-    _setAllElementState(data: RawData<ElementStateRaw>[], actions?: LogicAction.Actions[]): void;
-    /**@internal */
-    _getAllElementState(actions?: LogicAction.Actions[]): RawData<ElementStateRaw>[];
-    /**
-     * @internal
-     * Generate node descendant ID mapping
-     * The key is the node ID, and the value is the child node ID
-     */
-    _getNodeChildIdMap(actions?: LogicAction.Actions[]): NodeChildIdMap;
-    /**
-     * @internal
-     * Use the specified mapping table to restore the node descendants
-     */
-    _setNodeChildByMap(map: NodeChildIdMap | Record<string, string>, actions?: LogicAction.Actions[]): void;
-    /**
-     * @internal
-     * Generate node ID mapping
-     */
-    _getMappedNodes(nodes: RenderableNode[]): Map<string, RenderableNode>;
-    toData(): null;
-    fromData(_: any): this;
     /**
      * Set the entry scene of the story
      * @example
@@ -46,4 +22,7 @@ export declare class Story extends Constructable<SceneAction<"scene:action">> {
      * ```
      */
     entry(scene: Scene): this;
+    constructStory(): this;
+    getAllElementStates(): RawData<ElementStateRaw>[];
+    private runStaticCheck;
 }

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

@@ -16,12 +16,6 @@ declare class IdManager extends IdManager_base {
     getStringId(): string;
     prefix(prefix: string, value: string, separator?: string): string;
 }
-declare class GameIdManager {
-    private id;
-    getId(): number;
-    getStringId(): string;
-    prefix(prefix: string, value: string, separator?: string): string;
-}
 declare enum GameSettingsNamespace {
     game = "game"
 }
@@ -53,18 +47,12 @@ export declare class LiveGame {
     };
     game: Game;
     storable: Storable;
-    /**
-     * @deprecated
-     */
-    currentSceneNumber: number | null;
     currentSavedGame: SavedGame | null;
     story: Story | null;
     lockedAwaiting: Awaitable<CalledActionResult, any> | null;
-    idManager: GameIdManager;
     _lockedCount: number;
     private currentAction;
     constructor(game: Game);
-    getDefaultSavedGame(): SavedGame;
     initNamespaces(): this;
     getStorable(): Storable;
     loadStory(story: Story): this;
@@ -75,21 +63,22 @@ export declare class LiveGame {
     /**
      * Load a saved game
      *
-     * Note: Different versions of the game won't be able to load each other's saved games
+     * Note: Even if you change just a single line of code, the saved game might not be compatible with the new version
      *
-     * @internal - DO NOT USE IT, it's not ready yet
+     * After calling this method, the current game state will be lost, can the stage will trigger force reset
      */
     deserialize(savedGame: SavedGame, { gameState }: {
         gameState: GameState;
     }): void;
+    reset({ gameState }: {
+        gameState: GameState;
+    }): void;
     /**
      * Serialize the current game state
      *
      * You can use this to save the game state to a file or a database
      *
-     * Note: Different versions of the game won't be able to load each other's saved games
-     *
-     * @internal - DO NOT USE IT, it's not ready yet
+     * Note: Even if you change just a single line of code, the saved game might not be compatible with the new version
      */
     serialize({ gameState }: {
         gameState: GameState;
@@ -99,6 +88,7 @@ export declare class LiveGame {
     next(state: GameState): CalledActionResult | Awaitable<CalledActionResult, CalledActionResult> | null;
     abortAwaiting(): void;
     executeAction(state: GameState, action: LogicAction.Actions): LogicAction.Actions | Awaitable<CalledActionResult, CalledActionResult> | null;
+    private getNewSavedGame;
 }
 declare const _default: {
     Game: typeof Game;

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

@@ -6,7 +6,6 @@ import { StorableData } from "./store/type";
 import { MenuComponent, SayComponent } from "../player/elements/type";
 export interface SavedGame {
     name: string;
-    version: string;
     meta: {
         created: number;
         updated: number;
@@ -15,10 +14,8 @@ export interface SavedGame {
         store: {
             [key: string]: StorableData;
         };
-        elementState: RawData<ElementStateRaw>[];
-        nodeChildIdMap: Record<string, string>;
+        elementStates: RawData<ElementStateRaw>[];
         stage: PlayerStateData;
-        currentScene: number;
         currentAction: string | null;
     };
 }

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

@@ -25,9 +25,9 @@ export type PlayerState = {
     }[];
 };
 export type PlayerStateData = {
-    elements: {
-        scene: string;
-        ele: {
+    scenes: {
+        sceneId: string;
+        elements: {
             images: string[];
         };
     }[];
@@ -76,6 +76,7 @@ export declare class GameState {
     createMenu(menu: MenuData, afterChoose?: (choice: Choice) => void, scene?: Scene): void;
     createImage(image: Image, scene?: Scene): this;
     disposeImage(image: Image, scene?: Scene): this;
+    forceReset(): void;
     playSound(howl: Howler.Howl, onEnd?: () => void): any;
     getHowl(): typeof Howler.Howl;
     animateImage<T extends keyof ImageEventTypes>(type: T, target: Image, args: ImageEventTypes[T], onEnd: () => void): undefined;
@@ -83,7 +84,7 @@ export declare class GameState {
     offSrcManager(srcManager: SrcManager): this;
     getStorable(): Storable;
     toData(): PlayerStateData;
-    loadData(data: PlayerStateData, actions: LogicAction.Actions[]): void;
+    loadData(data: PlayerStateData, elementMap: Map<string, LogicAction.GameElement>): void;
     private getElementMap;
     private removeElements;
     private _getLastSceneIfNot;