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

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

@@ -2,6 +2,7 @@ import { RenderableNode } from "../action/tree/actionTree";
 import { LogicAction } from "../action/logicAction";
 import { Actionable } from "../action/actionable";
 import { GameState } from "../../player/gameState";
+import { Chained, ChainedActions, Proxied } from "../action/chain";
 export type ConditionConfig = {};
 interface LambdaCtx {
     gameState: GameState;
@@ -34,18 +35,18 @@ export type ConditionData = {
 };
 export declare class Condition extends Actionable {
     static defaultConfig: ConditionConfig;
+    static getInitialState(): ConditionData;
     readonly config: ConditionConfig;
     conditions: ConditionData;
     constructor(config?: ConditionConfig);
-    static getInitialState(): ConditionData;
-    If(condition: Lambda | LambdaHandler<boolean>, action: LogicAction.Actions | LogicAction.Actions[]): this;
-    ElseIf(condition: Lambda | LambdaHandler<boolean>, action: (LogicAction.Actions | LogicAction.Actions[])): this;
-    Else(action: (LogicAction.Actions | LogicAction.Actions[])): this;
+    If(condition: Lambda | LambdaHandler<boolean>, action: ChainedActions): Proxied<Condition, Chained<LogicAction.Actions>>;
+    ElseIf(condition: Lambda | LambdaHandler<boolean>, action: ChainedActions): Proxied<Condition, Chained<LogicAction.Actions>>;
+    Else(action: ChainedActions): Proxied<Condition, Chained<LogicAction.Actions>>;
     evaluate(conditions: ConditionData, { gameState }: {
         gameState: GameState;
     }): LogicAction.Actions[] | null;
-    toActions(): LogicAction.Actions[];
-    construct(actions: LogicAction.Actions[], lastChild?: RenderableNode, parentChild?: RenderableNode): LogicAction.Actions[];
+    fromChained(chained: Proxied<Condition, Chained<LogicAction.Actions>>): LogicAction.Actions[];
+    construct(chainedActions: ChainedActions, lastChild?: RenderableNode, parentChild?: RenderableNode): LogicAction.Actions[];
     _getFutureActions(): LogicAction.Actions[];
 }
 export {};

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

@@ -1,38 +1,41 @@
 import { Actionable } from "../action/actionable";
 import { LogicAction } from "../action/logicAction";
+import { Chained, ChainedActions, Proxied } from "../action/chain";
 import Actions = LogicAction.Actions;
+type ChainedControl = Proxied<Control, Chained<LogicAction.Actions>>;
 export declare class Control extends Actionable {
     /**
      * Execute actions in order, waiting for each action to complete
      */
-    static do(actions: (Actions | Actions[])[]): Control;
+    static do(actions: ChainedActions): never;
     /**
      * Execute actions in order, do not wait for this action to complete
      */
-    static doAsync(actions: (Actions | Actions[])[]): Control;
+    static doAsync(actions: ChainedActions): never;
     /**
      * Execute all actions at the same time, waiting for any one action to complete
      */
-    static any(actions: (Actions | Actions[])[]): Control;
+    static any(actions: ChainedActions): never;
     /**
      * Execute all actions at the same time, waiting for all actions to complete
      */
-    static all(actions: (Actions | Actions[])[]): Control;
+    static all(actions: ChainedActions): never;
     /**
      * Execute all actions at the same time, do not wait for all actions to complete
      */
-    static allAsync(actions: (Actions | Actions[])[]): Control;
+    static allAsync(actions: ChainedActions): never;
     /**
      * Execute actions multiple times
      */
-    static repeat(times: number, actions: (Actions | Actions[])[]): Control;
+    static repeat(times: number, actions: ChainedActions): never;
     constructor();
-    do(actions: (Actions | Actions[])[]): this;
-    doAsync(actions: (Actions | Actions[])[]): this;
-    any(actions: (Actions | Actions[])[]): this;
-    all(actions: (Actions | Actions[])[]): this;
-    allAsync(actions: (Actions | Actions[])[]): this;
-    repeat(times: number, actions: (Actions | Actions[])[]): this;
+    do(actions: ChainedActions): ChainedControl;
+    doAsync(actions: ChainedActions): ChainedControl;
+    any(actions: ChainedActions): ChainedControl;
+    all(actions: ChainedActions): ChainedControl;
+    allAsync(actions: ChainedActions): ChainedControl;
+    repeat(times: number, actions: ChainedActions): ChainedControl;
     construct(actions: Actions[]): Actions[];
     private push;
 }
+export {};

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

@@ -2,10 +2,13 @@ import React from "react";
 import type { TransformDefinitions } from "../elements/transform/type";
 import { ImageAction } from "../action/actions";
 import { Actionable } from "../action/actionable";
+import { Scene } from "../elements/scene";
 import { Transform } from "./transform/transform";
 import { CommonImage, StaticImageData } from "../types";
+import { LogicAction } from "../game";
 import { ITransition } from "../elements/transition/type";
 import { DeepPartial, EventDispatcher } from "../../../util/data";
+import { Chained, Proxied } from "../action/chain";
 export type ImageConfig = {
     src: string | StaticImageData;
     display: boolean;
@@ -25,7 +28,7 @@ export type ImageEventTypes = {
     "event:image.elementLoaded": [];
     "event:image.setTransition": [ITransition | null];
 };
-export declare class Image extends Actionable<ImageDataRaw> {
+export declare class Image extends Actionable<ImageDataRaw, Image> {
     static EventTypes: {
         [K in keyof ImageEventTypes]: K;
     };
@@ -35,18 +38,17 @@ export declare class Image extends Actionable<ImageDataRaw> {
         left: "left";
         right: "right";
     };
+    static serializeImageState(state: Record<string, any>): Record<string, any>;
+    static deserializeImageState(state: Record<string, any>): ImageConfig;
     readonly name: string;
     readonly config: ImageConfig;
     state: ImageConfig;
-    actions: ImageAction<any>[];
-    events: EventDispatcher<ImageEventTypes>;
+    readonly events: EventDispatcher<ImageEventTypes>;
     ref: React.RefObject<HTMLImageElement> | undefined;
     constructor(name: string, config: DeepPartial<ImageConfig>);
     constructor(config: DeepPartial<ImageConfig>);
-    static serializeImageState(state: Record<string, any>): Record<string, any>;
-    static deserializeImageState(state: Record<string, any>): ImageConfig;
-    dispose(): this;
-    init(): this;
+    dispose(): Proxied<Image, Chained<LogicAction.Actions, any>>;
+    init(): Proxied<Image, Chained<LogicAction.Actions>>;
     checkConfig(): this;
     /**
      * Set the source of the image
@@ -62,7 +64,7 @@ export declare class Image extends Actionable<ImageDataRaw> {
      * image.setSrc(yourImage, new Fade(1000));
      * ```
      */
-    setSrc(src: string | StaticImageData, transition?: ITransition): this;
+    setSrc(src: string | StaticImageData, transition?: ITransition): Proxied<Image, Chained<LogicAction.Actions>>;
     /**
      * Apply a transform to the image
      * @example
@@ -95,7 +97,7 @@ export declare class Image extends Actionable<ImageDataRaw> {
      * );
      * ```
      */
-    applyTransform(transform: Transform): this;
+    applyTransform(transform: Transform): Proxied<Image, Chained<LogicAction.Actions>>;
     /**
      * Show the image
      *
@@ -107,15 +109,15 @@ export declare class Image extends Actionable<ImageDataRaw> {
      * });
      * ```
      */
-    show(): this;
-    show(options: Transform): this;
-    show(options: Partial<TransformDefinitions.CommonTransformProps>): this;
+    show(): Proxied<Image, Chained<LogicAction.Actions>>;
+    show(options: Transform): Proxied<Image, Chained<LogicAction.Actions>>;
+    show(options: Partial<TransformDefinitions.CommonTransformProps>): Proxied<Image, Chained<LogicAction.Actions>>;
     /**
      * Hide the image
      */
-    hide(): this;
-    hide(transform: Transform): this;
-    hide(transform: Partial<TransformDefinitions.CommonTransformProps>): this;
+    hide(): Proxied<Image, Chained<LogicAction.Actions>>;
+    hide(transform: Transform): Proxied<Image, Chained<LogicAction.Actions>>;
+    hide(transform: Partial<TransformDefinitions.CommonTransformProps>): Proxied<Image, Chained<LogicAction.Actions>>;
     toTransform(): Transform;
     setScope(scope: React.RefObject<HTMLImageElement>): this;
     getScope(): React.RefObject<HTMLImageElement> | undefined;
@@ -123,9 +125,9 @@ export declare class Image extends Actionable<ImageDataRaw> {
     toData(): ImageDataRaw | null;
     fromData(data: ImageDataRaw): this;
     _$setDispose(): this;
-    _setTransition(transition: ITransition | null): this;
-    _applyTransition(transition: ITransition): this;
+    _setTransition(transition: ITransition | null): Proxied<Image, Chained<LogicAction.Actions>>;
+    _applyTransition(transition: ITransition): Proxied<Image, Chained<LogicAction.Actions>>;
     private _transitionSrc;
     private _dispose;
-    private _init;
+    _init(scene?: Scene): ImageAction<typeof ImageAction.ActionTypes.init>;
 }

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

@@ -1,14 +1,17 @@
 import { Sentence, Word } from "./text";
-import { RenderableNode } from "../action/tree/actionTree";
 import { LogicAction } from "../action/logicAction";
 import { MenuAction } from "../action/actions";
 import { Actionable } from "../action/actionable";
 import Actions = LogicAction.Actions;
+import { Chained, Proxied } from "../action/chain";
+import GameElement = LogicAction.GameElement;
 export type MenuConfig = {};
 export type MenuChoice = {
-    action: Actions[];
+    action: ChainedActions;
     prompt: UnSentencePrompt | Sentence;
 };
+type ChainedAction = Proxied<GameElement, Chained<LogicAction.Actions>>;
+type ChainedActions = (ChainedAction | ChainedAction[] | Actions | Actions[])[];
 type UnSentencePrompt = (string | Word)[] | (string | Word);
 export type Choice = {
     action: Actions[];
@@ -18,7 +21,7 @@ export type MenuData = {
     prompt: Sentence;
     choices: Choice[];
 };
-export declare class Menu extends Actionable {
+export declare class Menu extends Actionable<any, Menu> {
     static defaultConfig: MenuConfig;
     static targetAction: typeof MenuAction;
     prompt: Sentence;
@@ -33,11 +36,11 @@ export declare class Menu extends Actionable {
      *     character.say("I went left").toActions()
      * ]);
      */
-    choose(choice: MenuChoice): this;
-    choose(prompt: Sentence, action: (Actions | Actions[])[]): this;
-    choose(prompt: UnSentencePrompt, action: (Actions | Actions[])[]): this;
-    construct(actions: Actions[], lastChild?: RenderableNode, parentChild?: RenderableNode): Actions[];
-    toActions(): MenuAction<"menu:action">[];
+    choose(choice: MenuChoice): Proxied<Menu, Chained<LogicAction.Actions>>;
+    choose(prompt: Sentence, action: ChainedActions): Proxied<Menu, Chained<LogicAction.Actions>>;
+    choose(prompt: UnSentencePrompt, action: ChainedActions): Proxied<Menu, Chained<LogicAction.Actions>>;
+    fromChained(chained: Proxied<Menu, Chained<LogicAction.Actions>>): LogicAction.Actions[];
+    private construct;
     _getFutureActions(choices: Choice[]): LogicAction.Actions[];
     private constructChoices;
 }

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

@@ -8,8 +8,10 @@ import { ITransition } from "../elements/transition/type";
 import { SrcManager } from "../elements/srcManager";
 import { Sound, SoundDataRaw } from "../elements/sound";
 import { TransformDefinitions } from "../elements/transform/type";
+import { Chained, Proxied } from "../action/chain";
 import Actions = LogicAction.Actions;
 import ImageTransformProps = TransformDefinitions.ImageTransformProps;
+import GameElement = LogicAction.GameElement;
 export type SceneConfig = {
     invertY: boolean;
     invertX: boolean;
@@ -22,15 +24,17 @@ export type SceneState = {
 export type JumpConfig = {
     transition: ITransition;
 };
+type ChainableAction = Proxied<GameElement, Chained<LogicAction.Actions>> | Actions;
+type ChainedScene = Proxied<Scene, Chained<LogicAction.Actions>>;
 export type SceneDataRaw = {
     state: {
         backgroundMusic?: SoundDataRaw | null;
         background?: Background["background"];
-        backgroundImageState?: Partial<CommonImage>;
     };
+    backgroundImageState?: Partial<CommonImage>;
 };
 export type SceneEventTypes = {
-    "event:scene.setTransition": [ITransition | null];
+    "event:scene.applyTransition": [ITransition | null];
     "event:scene.remove": [];
     "event:scene.load": [];
     "event:scene.unload": [];
@@ -42,72 +46,92 @@ export type SceneEventTypes = {
     "event:scene.setBackgroundMusic": [Sound | null, number];
     "event:scene.applyTransform": [Transform<ImageTransformProps>];
 };
-export declare class Scene extends Constructable<any, Actions, SceneAction<"scene:action">> {
+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">;
-    private _actions;
+    sceneRoot?: SceneAction<"scene:action">;
     constructor(name: string, config?: DeepPartial<SceneConfig>);
-    activate(): this;
-    deactivate(): this;
+    /**
+     * 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): this;
+    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>): this;
+    applyTransform(transform: Transform<ImageTransformProps>): ChainedScene;
     /**
      * Jump to the specified scene
      *
      * After calling the method, you **will not be able to return to the context of the scene** that called the jump, so the scene will be unloaded
      *
      * Any operations after the jump operation will not be executed
+     * @chainable
      */
-    jumpTo(arg0: Scene, config?: Partial<JumpConfig>): this;
-    transitionSceneBackground(scene?: Scene, transition?: ITransition): this;
+    jumpTo(arg0: Scene, config?: Partial<JumpConfig>): ChainedScene;
     /**
      * Wait for a period of time, the parameter can be the number of milliseconds, a Promise, or an unresolved {@link Awaitable}
+     * @chainable
      */
-    sleep(ms: number): this;
-    sleep(promise: Promise<any>): this;
-    sleep(awaitable: Awaitable<any, any>): this;
+    sleep(ms: number): ChainedScene;
+    sleep(promise: Promise<any>): ChainedScene;
+    sleep(awaitable: Awaitable<any, any>): ChainedScene;
     /**
      * 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): this;
-    toActions(): SceneAction<any>[];
-    _$getBackgroundMusic(): Sound | null;
+    setBackgroundMusic(sound: Sound, fade?: number): ChainedScene;
     toData(): SceneDataRaw | null;
     fromData(data: SceneDataRaw): this;
-    _setTransition(transition: ITransition): this;
-    _applyTransition(transition: ITransition): this;
-    _toTransform(): Transform<ImageTransformProps>;
+    getInitTransform(): Transform<ImageTransformProps>;
+    action(actions: (ChainableAction | ChainableAction[])[]): this;
+    action(actions: ((scene: Scene) => ChainableAction[])): this;
     registerSrc(seen?: Set<Scene>): void;
-    action(actions: (Actions | Actions[])[]): this;
-    action(actions: ((scene: Scene) => Actions[])): this;
-    protected getSceneActions(): SceneAction<any>[];
+    /**
+     * @internal STILL IN DEVELOPMENT
+     */
+    assignActionId(): void;
+    /**
+     * @internal STILL IN DEVELOPMENT
+     */
+    assignElementId(): void;
+    private _applyTransition;
+    private _transitionSceneBackground;
     private _jumpTo;
     private _exit;
     private _transitionToScene;
     private _init;
 }
+export {};

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

@@ -1,7 +1,7 @@
 import { LogicAction } from "../action/logicAction";
 import { Actionable } from "../action/actionable";
 import { GameState } from "../../player/gameState";
-import Actions = LogicAction.Actions;
+import { Chained, Proxied } from "../action/chain";
 export interface ScriptCtx {
     script: Script;
     gameState: GameState;
@@ -18,6 +18,6 @@ export declare class Script extends Actionable<object> {
     getCtx({ gameState }: {
         gameState: GameState;
     }): ScriptCtx;
-    toActions(): Actions[];
+    fromChained(chained: Proxied<Script, Chained<LogicAction.Actions>>): LogicAction.Actions[];
 }
 export {};

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

@@ -1,7 +1,10 @@
 import { Actionable } from "../action/actionable";
 import { DeepPartial } from "../../../util/data";
+import { LogicAction } from "../game";
 import * as Howler from "howler";
 import { HowlOptions } from "howler";
+import { Chained, Proxied } from "../action/chain";
+type ChainedSound = Proxied<Sound, Chained<LogicAction.Actions>>;
 export declare enum SoundType {
     soundEffect = "soundEffect",
     music = "music",
@@ -40,13 +43,13 @@ export declare class Sound extends Actionable<SoundDataRaw> {
         token: any;
     };
     constructor(config?: DeepPartial<SoundConfig>);
-    play(): this;
-    stop(): this;
-    fade(start: number | undefined, end: number, duration: number): this;
-    setVolume(volume: number): this;
-    setRate(rate: number): this;
-    pause(fade?: number): this;
-    resume(fade?: number): this;
+    play(): ChainedSound;
+    stop(): ChainedSound;
+    fade(start: number | undefined, end: number, duration: number): ChainedSound;
+    setVolume(volume: number): ChainedSound;
+    setRate(rate: number): ChainedSound;
+    pause(fade?: number): ChainedSound;
+    resume(fade?: number): ChainedSound;
     getHowlOptions(): HowlOptions;
     getSrc(): string;
     $setToken(token: any): void;
@@ -58,3 +61,4 @@ export declare class Sound extends Actionable<SoundDataRaw> {
     fromData(data: SoundDataRaw): this;
     private pushAction;
 }
+export {};

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

@@ -1,40 +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<any, SceneAction<"scene:action">, StoryAction<"story: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
@@ -45,4 +22,7 @@ export declare class Story extends Constructable<any, SceneAction<"scene:action"
      * ```
      */
     entry(scene: Scene): this;
+    constructStory(): this;
+    getAllElementStates(): RawData<ElementStateRaw>[];
+    private runStaticCheck;
 }

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

@@ -1,7 +1,9 @@
+import { LogicAction } from "../game";
 import { color, Color } from "../types";
 import { DeepPartial } from "../../../util/data";
 import { Actionable } from "../action/actionable";
 import type { Sound } from "../elements/sound";
+import { Chained, Proxied } from "../action/chain";
 export type SentenceConfig = {
     pause?: boolean | number;
     voice: Sound | string | null | undefined;
@@ -17,14 +19,14 @@ type UnSentencePrompt = (string | Word)[] | (string | Word);
 export declare class Sentence {
     static defaultConfig: SentenceConfig;
     static defaultState: SentenceState;
+    static isSentence(obj: any): obj is Sentence;
+    static toSentence(prompt: UnSentencePrompt | Sentence): Sentence;
     id: string;
     character: Character | null;
     text: Word[];
     config: SentenceConfig;
     state: SentenceState;
     constructor(character: Character | null, text: (string | Word)[] | (string | Word), config?: Partial<SentenceConfig>);
-    static isSentence(obj: any): obj is Sentence;
-    static toSentence(prompt: UnSentencePrompt | Sentence): Sentence;
     format(text: (string | Word)[] | (string | Word)): Word[];
     toData(): SentenceDataRaw | null;
     fromData(data: SentenceDataRaw): this;
@@ -33,10 +35,10 @@ export declare class Sentence {
 export declare class Word {
     static defaultConfig: Partial<WordConfig>;
     static defaultColor: color;
+    static isWord(obj: any): obj is Word;
     text: string;
     config: Partial<WordConfig>;
     constructor(text: string, config?: Partial<WordConfig>);
-    static isWord(obj: any): obj is Word;
 }
 export declare enum CharacterMode {
     "adv" = "adv",
@@ -46,34 +48,33 @@ export type CharacterConfig = {
     mode: CharacterMode;
 };
 export type CharacterStateData = {};
-export declare class Character extends Actionable<CharacterStateData> {
+export declare class Character extends Actionable<CharacterStateData, Character> {
     static Modes: typeof CharacterMode;
     static defaultConfig: CharacterConfig;
-    name: string | null;
-    config: CharacterConfig;
+    readonly name: string | null;
+    readonly config: CharacterConfig;
     constructor(name: string | null, config?: DeepPartial<CharacterConfig>);
     /**
      * Say something
      * @example
      * ```typescript
-     * character.say("Hello, world!").toActions();
+     * character.say("Hello, world!");
      * ```
      * @example
      * ```typescript
      * character
      *     .say("Hello, world!")
-     *     .say("Hello, world!")
-     *     .toActions();
+     *     .say("Hello, world!");
      * ```
      * @example
      * ```typescript
      * character.say(new Sentence(character, [
      *     "Hello, ",
      *     new Word("world", {color: "#f00"}), // Some words can be colored
-     * ])).toActions();
+     * ]));
      */
-    say(content: string): Character;
-    say(content: Sentence): Character;
-    say(content: (string | Word)[]): Character;
+    say(content: string): Proxied<Character, Chained<LogicAction.Actions>>;
+    say(content: Sentence): Proxied<Character, Chained<LogicAction.Actions>>;
+    say(content: (string | Word)[]): Proxied<Character, Chained<LogicAction.Actions>>;
 }
 export {};

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"
 }
@@ -32,6 +26,7 @@ export declare class Game {
     };
     static DefaultConfig: GameConfig;
     static GameSettingsNamespace: typeof GameSettingsNamespace;
+    static getIdManager(): IdManager;
     readonly config: Readonly<GameConfig>;
     liveGame: LiveGame | null;
     /**
@@ -39,7 +34,6 @@ export declare class Game {
      * @param config - Game configuration
      */
     constructor(config: DeepPartial<GameConfig>);
-    static getIdManager(): IdManager;
     useComponent<T extends keyof ComponentsTypes>(key: T, components: ComponentsTypes[T]): this;
     getLiveGame(): LiveGame;
     private createLiveGame;
@@ -53,15 +47,12 @@ export declare class LiveGame {
     };
     game: Game;
     storable: Storable;
-    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;
@@ -72,17 +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
+     *
+     * 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
+     * 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;
@@ -92,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;