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

package/README.md

@@ -42,7 +42,6 @@ Read more in [🛠React.NarraLeaf.com](https://react.narraleaf.com)
 import {Character, Scene, Story, Image, Player, GameProviders} from "narraleaf-react";
 
 export default function App() {
-
     const character1 = new Character("character1");
     const image1 = new Image({
         src: "https://placehold.it/200x200",
@@ -53,14 +52,13 @@ export default function App() {
             // Show image1 for 1 second
             image1.show({
                 duration: 1000,
-            }).toActions(),
+            }),
 
             // Say something
             character1
                 .say("Hello, world!")
                 .say("This is my first NarraLeaf story.")
-                .say("Start editing this file and enjoy the journey!")
-                .toActions(),
+                .say("Start editing this file and enjoy the journey!"),
         ])
     );
 

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

@@ -1,5 +1,7 @@
 import { LogicAction } from "../action/logicAction";
-export declare class Actionable<StateData extends Record<string, any> = Record<string, any>> {
+import { Chainable, Chained, Proxied } from "../action/chain";
+import GameElement = LogicAction.GameElement;
+export declare class Actionable<StateData extends Record<string, any> = Record<string, any>, Self extends Actionable = any> extends Chainable<LogicAction.Actions, Self> {
     static IdPrefixes: {
         readonly Actionable: "actionable";
         readonly Condition: "$0";
@@ -11,9 +13,12 @@ export declare class Actionable<StateData extends Record<string, any> = Record<s
         readonly Menu: "$6";
     };
     readonly id: string;
-    protected actions: LogicAction.Actions[];
     constructor(idPrefix?: string);
-    toActions(): LogicAction.Actions[];
+    /**
+     * @deprecated
+     */
+    toActions(): never[];
     toData(): StateData | null;
     fromData(_: StateData): this;
+    fromChained(chained: Proxied<GameElement, Chained<LogicAction.Actions>>): LogicAction.Actions[];
 }

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

@@ -0,0 +1,24 @@
+import { LogicAction } from "../action/logicAction";
+import Actions = LogicAction.Actions;
+import GameElement = LogicAction.GameElement;
+export type Proxied<T extends Record<any, any>, U extends Record<any, any>> = T & U;
+export type ChainedAction = Proxied<GameElement, Chained<LogicAction.Actions>>;
+export type ChainedActions = (ChainedAction | ChainedAction[] | Actions | Actions[])[];
+declare const ChainedFlag: unique symbol;
+export declare class Chained<T> {
+    static isChained<T>(value: any): value is Chained<T>;
+    static toActions(chainedActions: ChainedActions): Actions[];
+    [ChainedFlag]: boolean;
+    private __actions;
+    push(...actions: T[]): void;
+    getActions(): T[];
+}
+/**
+ * - T - the action type
+ * - U - self constructor
+ */
+export declare class Chainable<T, U extends Record<any, any>> {
+    chain(arg0?: T[] | T): Proxied<U, Chained<T>>;
+    proxy<T extends Record<any, any>, U extends Record<any, any>>(target: T, chained: U): Proxied<T, U>;
+}
+export {};

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

@@ -1,12 +1,24 @@
 import { ContentNode, RenderableNode, RootNode } from "../action/tree/actionTree";
 import { LogicAction } from "../action/logicAction";
-export declare class Constructable<T extends typeof Constructable = any, TAction extends LogicAction.Actions = LogicAction.Actions, CAction extends LogicAction.Actions = LogicAction.Actions> {
+import { Chainable, Chained, Proxied } from "../action/chain";
+import GameElement = LogicAction.GameElement;
+export declare class Constructable<TAction extends LogicAction.Actions = LogicAction.Actions> extends Chainable<any, any> {
     static targetAction: any;
+    /**
+     * @deprecated
+     * @private
+     */
     private readonly actions;
     constructor();
+    /**
+     * @deprecated
+     * @param root
+     */
     setRoot(root: RootNode): LogicAction.Actions | undefined;
-    getActions(): TAction[];
-    setActions(actions: TAction[]): void;
+    /**
+     * @deprecated
+     */
+    _getActions(): TAction[];
     /**@internal */
     getAllActions(includeJumpTo?: boolean, actions?: LogicAction.Actions[]): LogicAction.Actions[];
     /**@internal */
@@ -28,13 +40,9 @@ export declare class Constructable<T extends typeof Constructable = any, TAction
      * Find multiple elements by multiple IDs
      */
     findElementsByIds(ids: string[], elements: LogicAction.GameElement[]): LogicAction.GameElement[];
-    /**
-     * Adds an action to the current specified context instance
-     */
-    protected _action(actions: (callee: this) => (TAction | TAction[])[]): CAction;
-    protected _action(actions: (TAction | TAction[])[]): CAction;
+    fromChained(chained: Proxied<GameElement, Chained<LogicAction.Actions>>): LogicAction.Actions[];
     /**
      * Construct the actions into a tree
      */
-    protected construct(parent?: RenderableNode): RenderableNode | null;
+    protected construct(actions: LogicAction.Actions[], parent?: RenderableNode): RenderableNode | null;
 }

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

@@ -26,7 +26,7 @@ type ImageState = {
 export declare class StaticChecker {
     private readonly scene;
     constructor(target: Scene);
-    start(): Map<Image, ImageState> | null;
+    run(): Map<Image, ImageState> | null;
     private checkAction;
     private checkImage;
 }

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>>;
+    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,6 +24,8 @@ 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;
@@ -30,7 +34,7 @@ export type SceneDataRaw = {
     };
 };
 export type SceneEventTypes = {
-    "event:scene.setTransition": [ITransition | null];
+    "event:scene.applyTransition": [ITransition | null];
     "event:scene.remove": [];
     "event:scene.load": [];
     "event:scene.unload": [];
@@ -42,7 +46,7 @@ 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> {
     static EventTypes: {
         [K in keyof SceneEventTypes]: K;
     };
@@ -59,55 +63,56 @@ export declare class Scene extends Constructable<any, Actions, SceneAction<"scen
     _liveState: {
         active: boolean;
     };
-    _sceneRoot?: SceneAction<"scene:action">;
-    private _actions;
+    sceneRoot?: SceneAction<"scene:action">;
     constructor(name: string, config?: DeepPartial<SceneConfig>);
-    activate(): this;
-    deactivate(): this;
+    activate(): ChainedScene;
+    deactivate(): ChainedScene;
     /**
      * Set background, if {@link transition} is provided, it will be applied
      */
-    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
      */
-    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;
+    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
      */
-    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
      */
-    setBackgroundMusic(sound: Sound, fade?: number): this;
-    toActions(): SceneAction<any>[];
+    setBackgroundMusic(sound: Sound, fade?: number): ChainedScene;
     _$getBackgroundMusic(): Sound | null;
     toData(): SceneDataRaw | null;
     fromData(data: SceneDataRaw): this;
-    _setTransition(transition: ITransition): this;
-    _applyTransition(transition: ITransition): this;
+    _setTransition(transition: ITransition): ChainedScene;
+    _applyTransition(transition: ITransition): ChainedScene;
     _toTransform(): Transform<ImageTransformProps>;
+    _initTransform(): Transform<ImageTransformProps>;
     registerSrc(seen?: Set<Scene>): void;
-    action(actions: (Actions | Actions[])[]): this;
-    action(actions: ((scene: Scene) => Actions[])): this;
-    protected getSceneActions(): SceneAction<any>[];
-    private _jumpTo;
+    action(actions: (ChainableAction | ChainableAction[])[]): this;
+    action(actions: ((scene: Scene) => ChainableAction[])): this;
+    _jumpTo(scene: Scene): ChainedScene;
     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

@@ -6,12 +6,13 @@ import { Scene } from "../elements/scene";
 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">> {
     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;

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 {};