narraleaf-react 0.0.5 → 0.1.0

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

@@ -3,16 +3,16 @@ import { ContentNode } from "../action/tree/actionTree";
 import type { CalledActionResult } from "../gameTypes";
 import { Awaitable } from "../../../util/data";
 import { GameState } from "../../player/gameState";
-export declare class Action<ContentNodeType = any, Callee = LogicAction.GameElement> {
+export declare class Action<ContentNodeType = any, Callee = LogicAction.GameElement, Type extends string = any> {
     static ActionTypes: {
         action: string;
     };
     callee: Callee;
-    type: ContentNodeType;
+    type: Type;
     contentNode: ContentNode<ContentNodeType>;
     _id: string;
     readonly __stack: string;
-    constructor(callee: Callee, type: ContentNodeType, contentNode: ContentNode<ContentNodeType>);
+    constructor(callee: Callee, type: Type, contentNode: ContentNode<ContentNodeType>);
     executeAction(_state: GameState): CalledActionResult | Awaitable<CalledActionResult, any>;
     getId(): string;
     setId(id: string): void;

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

@@ -1,21 +1,23 @@
 import { LogicAction } from "../action/logicAction";
 import type { Story } from "../elements/story";
 import type { ConditionData } from "../elements/condition";
-import { Background, CommonImage } from "../types";
+import { CommonDisplayable, ImageColor, ImageSrc } from "../types";
 import { Transform } from "../elements/transform/transform";
 import type { Scene } from "../elements/scene";
-import type { Sentence } from "../elements/text";
 import type { MenuData } from "../elements/menu";
 import { Awaitable } from "../../../util/data";
 import { ITransition } from "../elements/transition/type";
 import type { Sound } from "../elements/sound";
 import type { Script } from "../elements/script";
+import { Sentence } from "../elements/character/sentence";
+import type { TransformDefinitions } from "../elements/transform/type";
 export declare const CharacterActionTypes: {
     readonly say: "character:say";
     readonly action: "character:action";
+    readonly setName: "character:setName";
 };
 export type CharacterActionContentType = {
-    [K in typeof CharacterActionTypes[keyof typeof CharacterActionTypes]]: K extends "character:say" ? Sentence : K extends "character:action" ? any : any;
+    [K in typeof CharacterActionTypes[keyof typeof CharacterActionTypes]]: K extends "character:say" ? Sentence : K extends "character:action" ? any : K extends "character:setName" ? [string] : any;
 };
 export declare const SceneActionTypes: {
     readonly action: "scene:action";
@@ -31,7 +33,7 @@ export declare const SceneActionTypes: {
     readonly applyTransform: "scene:applyTransform";
 };
 export type SceneActionContentType = {
-    [K in typeof SceneActionTypes[keyof typeof SceneActionTypes]]: K extends typeof SceneActionTypes["action"] ? Scene : K extends typeof SceneActionTypes["sleep"] ? number | Promise<any> | Awaitable<any, any> : K extends typeof SceneActionTypes["setBackground"] ? [Background["background"]] : K extends typeof SceneActionTypes["setTransition"] ? [ITransition | null] : K extends typeof SceneActionTypes["applyTransition"] ? [ITransition] : K extends typeof SceneActionTypes["init"] ? [] : K extends typeof SceneActionTypes["exit"] ? [] : K extends typeof SceneActionTypes["jumpTo"] ? [Scene] : K extends typeof SceneActionTypes["setBackgroundMusic"] ? [Sound | null, number?] : K extends typeof SceneActionTypes["preUnmount"] ? [] : K extends typeof SceneActionTypes["applyTransform"] ? [Transform] : any;
+    [K in typeof SceneActionTypes[keyof typeof SceneActionTypes]]: K extends typeof SceneActionTypes["action"] ? Scene : K extends typeof SceneActionTypes["sleep"] ? number | Promise<any> | Awaitable<any, any> : K extends typeof SceneActionTypes["setBackground"] ? [ImageSrc | ImageColor] : K extends typeof SceneActionTypes["setTransition"] ? [ITransition | null] : K extends typeof SceneActionTypes["applyTransition"] ? [ITransition] : K extends typeof SceneActionTypes["init"] ? [] : K extends typeof SceneActionTypes["exit"] ? [] : K extends typeof SceneActionTypes["jumpTo"] ? [Scene] : K extends typeof SceneActionTypes["setBackgroundMusic"] ? [Sound | null, number?] : K extends typeof SceneActionTypes["preUnmount"] ? [] : K extends typeof SceneActionTypes["applyTransform"] ? [Transform] : any;
 };
 export declare const StoryActionTypes: {
     readonly action: "story:action";
@@ -56,7 +58,7 @@ export declare const ImageActionTypes: {
     readonly flush: "image:flush";
 };
 export type ImageActionContentType = {
-    [K in typeof ImageActionTypes[keyof typeof ImageActionTypes]]: K extends "image:setSrc" ? [string] : K extends "image:setPosition" ? [CommonImage["position"], Transform] : K extends "image:show" ? [void, Transform] : K extends "image:hide" ? [void, Transform] : K extends "image:applyTransform" ? [void, Transform, string] : K extends "image:init" ? [Scene?] : K extends "image:dispose" ? [] : K extends "image:setTransition" ? [ITransition | null] : K extends "image:applyTransition" ? [ITransition] : K extends "image:flush" ? [] : any;
+    [K in typeof ImageActionTypes[keyof typeof ImageActionTypes]]: K extends "image:setSrc" ? [string] : K extends "image:setPosition" ? [CommonDisplayable["position"], Transform<TransformDefinitions.ImageTransformProps>] : K extends "image:show" ? [void, Transform<TransformDefinitions.ImageTransformProps>] : K extends "image:hide" ? [void, Transform<TransformDefinitions.ImageTransformProps>] : K extends "image:applyTransform" ? [void, Transform<TransformDefinitions.ImageTransformProps>, string] : K extends "image:init" ? [Scene?] : K extends "image:dispose" ? [] : K extends "image:setTransition" ? [ITransition | null] : K extends "image:applyTransition" ? [ITransition] : K extends "image:flush" ? [] : any;
 };
 export declare const ConditionActionTypes: {
     readonly action: "condition:action";
@@ -103,7 +105,21 @@ export declare const ControlActionTypes: {
     readonly all: "control:all";
     readonly allAsync: "control:allAsync";
     readonly repeat: "control:repeat";
+    readonly sleep: "control:sleep";
 };
 export type ControlActionContentType = {
-    [K in typeof ControlActionTypes[keyof typeof ControlActionTypes]]: K extends "control:do" ? [LogicAction.Actions[]] : K extends "control:doAsync" ? [LogicAction.Actions[]] : K extends "control:any" ? [LogicAction.Actions[]] : K extends "control:all" ? [LogicAction.Actions[]] : K extends "control:parallel" ? [LogicAction.Actions[]] : K extends "control:allAsync" ? [LogicAction.Actions[]] : K extends "control:repeat" ? [LogicAction.Actions[], number] : any;
+    [K in typeof ControlActionTypes[keyof typeof ControlActionTypes]]: K extends "control:do" ? [LogicAction.Actions[]] : K extends "control:doAsync" ? [LogicAction.Actions[]] : K extends "control:any" ? [LogicAction.Actions[]] : K extends "control:all" ? [LogicAction.Actions[]] : K extends "control:parallel" ? [LogicAction.Actions[]] : K extends "control:allAsync" ? [LogicAction.Actions[]] : K extends "control:repeat" ? [LogicAction.Actions[], number] : K extends "control:sleep" ? [LogicAction.Actions[], number | Awaitable<any> | Promise<any>] : any;
+};
+export declare const TextActionTypes: {
+    readonly action: "text:action";
+    readonly setText: "text:setText";
+    readonly show: "text:show";
+    readonly hide: "text:hide";
+    readonly applyTransform: "text:applyTransform";
+    readonly init: "text:init";
+    readonly applyTransition: "text:applyTransition";
+    readonly setFontSize: "text:setFontSize";
+};
+export type TextActionContentType = {
+    [K in typeof TextActionTypes[keyof typeof TextActionTypes]]: K extends "text:setText" ? [string] : K extends "text:show" ? [Transform<TransformDefinitions.TextTransformProps>] : K extends "text:hide" ? [Transform<TransformDefinitions.TextTransformProps>] : K extends "text:applyTransform" ? [Transform<TransformDefinitions.TextTransformProps>] : K extends "text:init" ? [Scene?] : K extends "text:applyTransition" ? [ITransition] : K extends "text:setFontSize" ? [number] : any;
 };

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

@@ -0,0 +1,14 @@
+import { CharacterActionContentType, CharacterActionTypes } from "../../action/actionTypes";
+import type { Character } from "../../elements/character";
+import { GameState } from "../../../player/gameState";
+import type { CalledActionResult } from "../../gameTypes";
+import { Awaitable } from "../../../../util/data";
+import { TypedAction } from "../../action/actions";
+export declare class CharacterAction<T extends typeof CharacterActionTypes[keyof typeof CharacterActionTypes] = typeof CharacterActionTypes[keyof typeof CharacterActionTypes]> extends TypedAction<CharacterActionContentType, T, Character> {
+    static ActionTypes: {
+        readonly say: "character:say";
+        readonly action: "character:action";
+        readonly setName: "character:setName";
+    };
+    executeAction(state: GameState): CalledActionResult | Awaitable<CalledActionResult, any>;
+}

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

@@ -0,0 +1,15 @@
+import { ConditionActionContentType, ConditionActionTypes } from "../../action/actionTypes";
+import type { Condition } from "../../elements/condition";
+import { GameState } from "../../../player/gameState";
+import { LogicAction } from "../../action/logicAction";
+import { TypedAction } from "../../action/actions";
+export declare class ConditionAction<T extends typeof ConditionActionTypes[keyof typeof ConditionActionTypes] = typeof ConditionActionTypes[keyof typeof ConditionActionTypes]> extends TypedAction<ConditionActionContentType, T, Condition> {
+    static ActionTypes: {
+        readonly action: "condition:action";
+    };
+    executeAction(gameState: GameState): {
+        type: any;
+        node: import("../tree/actionTree").RenderableNode | null;
+    };
+    getFutureActions(): LogicAction.Actions[];
+}

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

@@ -0,0 +1,32 @@
+import { ControlActionContentType, ControlActionTypes } from "../../action/actionTypes";
+import { Control } from "../../elements/control";
+import { GameState } from "../../../player/gameState";
+import { LogicAction } from "../../action/logicAction";
+import { Awaitable } from "../../../../util/data";
+import type { CalledActionResult } from "../../gameTypes";
+import { ContentNode } from "../../action/tree/actionTree";
+import { TypedAction } from "../../action/actions";
+export declare class ControlAction<T extends typeof ControlActionTypes[keyof typeof ControlActionTypes] = typeof ControlActionTypes[keyof typeof ControlActionTypes]> extends TypedAction<ControlActionContentType, T, Control> {
+    static ActionTypes: {
+        readonly action: "control:action";
+        readonly do: "control:do";
+        readonly doAsync: "control:doAsync";
+        readonly any: "control:any";
+        readonly all: "control:all";
+        readonly allAsync: "control:allAsync";
+        readonly repeat: "control:repeat";
+        readonly sleep: "control:sleep";
+    };
+    /**
+     * Execute all actions in the content node
+     * will wait for awaitable actions to resolve
+     */
+    executeAllActions(state: GameState, action: LogicAction.Actions): Promise<void>;
+    executeSingleAction(state: GameState, action: LogicAction.Actions): Promise<TypedAction<Record<string, any>, string, LogicAction.GameElement> | import("./menuAction").MenuAction<"menu:action"> | ControlAction<"control:action" | "control:do" | "control:doAsync" | "control:any" | "control:all" | "control:allAsync" | "control:repeat" | "control:sleep"> | ContentNode<any> | null>;
+    execute(state: GameState, awaitable: Awaitable<any, any>, content: LogicAction.Actions[]): {
+        type: any;
+        node: ContentNode<any> | null;
+    } | Awaitable<CalledActionResult<any>, any> | Awaitable<any, any>;
+    executeAction(state: GameState): CalledActionResult | Awaitable<CalledActionResult, CalledActionResult>;
+    getFutureActions(): LogicAction.Actions[];
+}

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

@@ -0,0 +1,22 @@
+import { ImageActionContentType, ImageActionTypes } from "../../action/actionTypes";
+import { Image } from "../../elements/image";
+import { GameState } from "../../../player/gameState";
+import type { CalledActionResult } from "../../gameTypes";
+import { Awaitable } from "../../../../util/data";
+import { TypedAction } from "../../action/actions";
+export declare class ImageAction<T extends typeof ImageActionTypes[keyof typeof ImageActionTypes] = typeof ImageActionTypes[keyof typeof ImageActionTypes]> extends TypedAction<ImageActionContentType, T, Image> {
+    static ActionTypes: {
+        readonly action: "image:action";
+        readonly setSrc: "image:setSrc";
+        readonly setPosition: "image:setPosition";
+        readonly show: "image:show";
+        readonly hide: "image:hide";
+        readonly applyTransform: "image:applyTransform";
+        readonly init: "image:init";
+        readonly dispose: "image:dispose";
+        readonly setTransition: "image:setTransition";
+        readonly applyTransition: "image:applyTransition";
+        readonly flush: "image:flush";
+    };
+    executeAction(state: GameState): CalledActionResult | Awaitable<CalledActionResult, any>;
+}

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

@@ -0,0 +1,13 @@
+import { MenuActionContentType, MenuActionTypes } from "../../action/actionTypes";
+import type { Menu } from "../../elements/menu";
+import { GameState } from "../../../player/gameState";
+import { Awaitable } from "../../../../util/data";
+import type { CalledActionResult } from "../../gameTypes";
+import { TypedAction } from "../../action/actions";
+export declare class MenuAction<T extends typeof MenuActionTypes[keyof typeof MenuActionTypes] = typeof MenuActionTypes[keyof typeof MenuActionTypes]> extends TypedAction<MenuActionContentType, T, Menu> {
+    static ActionTypes: {
+        readonly action: "menu:action";
+    };
+    executeAction(state: GameState): Awaitable<CalledActionResult<any>, CalledActionResult<any>>;
+    getFutureActions(): import("../logicAction").LogicAction.Actions[];
+}

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

@@ -0,0 +1,29 @@
+import { SceneActionContentType, SceneActionTypes } from "../../action/actionTypes";
+import type { Scene } from "../../elements/scene";
+import { GameState } from "../../../player/gameState";
+import { Awaitable } from "../../../../util/data";
+import type { CalledActionResult } from "../../gameTypes";
+import { LogicAction } from "../../action/logicAction";
+import { TypedAction } from "../../action/actions";
+export declare class SceneAction<T extends typeof SceneActionTypes[keyof typeof SceneActionTypes] = typeof SceneActionTypes[keyof typeof SceneActionTypes]> extends TypedAction<SceneActionContentType, T, Scene> {
+    static ActionTypes: {
+        readonly action: "scene:action";
+        readonly setBackground: "scene:setBackground";
+        readonly sleep: "scene:sleep";
+        readonly setTransition: "scene:setTransition";
+        readonly applyTransition: "scene:applyTransition";
+        readonly init: "scene:init";
+        readonly exit: "scene:exit";
+        readonly jumpTo: "scene:jumpTo";
+        readonly setBackgroundMusic: "scene:setBackgroundMusic";
+        readonly preUnmount: "scene:preUnmount";
+        readonly applyTransform: "scene:applyTransform";
+    };
+    static handleSceneInit(sceneAction: SceneAction, state: GameState, awaitable: Awaitable<CalledActionResult, any>): Awaitable<CalledActionResult<any>, any> | {
+        type: "scene:action" | "scene:setBackground" | "scene:sleep" | "scene:setTransition" | "scene:applyTransition" | "scene:init" | "scene:exit" | "scene:jumpTo" | "scene:setBackgroundMusic" | "scene:preUnmount" | "scene:applyTransform";
+        node: import("../../action/tree/actionTree").RenderableNode | null;
+    };
+    static registerEventListeners(scene: Scene, state: GameState, onInit?: () => void): void;
+    executeAction(state: GameState): CalledActionResult | Awaitable<CalledActionResult, any>;
+    getFutureActions(): LogicAction.Actions[];
+}

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

@@ -0,0 +1,10 @@
+import { ScriptActionContentType, ScriptActionTypes } from "../../action/actionTypes";
+import type { Script } from "../../elements/script";
+import { GameState } from "../../../player/gameState";
+import { TypedAction } from "../../action/actions";
+export declare class ScriptAction<T extends typeof ScriptActionTypes[keyof typeof ScriptActionTypes] = typeof ScriptActionTypes[keyof typeof ScriptActionTypes]> extends TypedAction<ScriptActionContentType, T, Script> {
+    static ActionTypes: {
+        readonly action: "script:action";
+    };
+    executeAction(gameState: GameState): import("../../gameTypes").CalledActionResult<any> | import("../../../../util/data").Awaitable<import("../../gameTypes").CalledActionResult<any>, any>;
+}

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

@@ -0,0 +1,20 @@
+import { SoundActionContentType, SoundActionTypes } from "../../action/actionTypes";
+import type { Sound } from "../../elements/sound";
+import { GameState } from "../../../player/gameState";
+import type { CalledActionResult } from "../../gameTypes";
+import { Awaitable } from "../../../../util/data";
+import { TypedAction } from "../../action/actions";
+export declare class SoundAction<T extends typeof SoundActionTypes[keyof typeof SoundActionTypes] = typeof SoundActionTypes[keyof typeof SoundActionTypes]> extends TypedAction<SoundActionContentType, T, Sound> {
+    static ActionTypes: {
+        readonly action: "sound:action";
+        readonly play: "sound:play";
+        readonly stop: "sound:stop";
+        readonly fade: "sound:fade";
+        readonly setVolume: "sound:setVolume";
+        readonly setRate: "sound:setRate";
+        readonly pause: "sound:pause";
+        readonly resume: "sound:resume";
+    };
+    static initSound(state: GameState, sound: Sound): void;
+    executeAction(state: GameState): CalledActionResult | Awaitable<CalledActionResult, any>;
+}

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

@@ -0,0 +1,8 @@
+import { StoryActionContentType, StoryActionTypes } from "../../action/actionTypes";
+import type { Story } from "../../elements/story";
+import { TypedAction } from "../../action/actions";
+export declare class StoryAction<T extends typeof StoryActionTypes[keyof typeof StoryActionTypes] = typeof StoryActionTypes[keyof typeof StoryActionTypes]> extends TypedAction<StoryActionContentType, T, Story> {
+    static ActionTypes: {
+        readonly action: "story:action";
+    };
+}

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

@@ -0,0 +1,19 @@
+import { TextActionContentType, TextActionTypes } from "../../action/actionTypes";
+import { TypedAction } from "../../action/actions";
+import { GameState } from "../../../player/gameState";
+import { CalledActionResult } from "../../gameTypes";
+import { Awaitable } from "../../../../util/data";
+import { Text } from "../../elements/text";
+export declare class TextAction<T extends typeof TextActionTypes[keyof typeof TextActionTypes] = typeof TextActionTypes[keyof typeof TextActionTypes]> extends TypedAction<TextActionContentType, T, Text> {
+    static ActionTypes: {
+        readonly action: "text:action";
+        readonly setText: "text:setText";
+        readonly show: "text:show";
+        readonly hide: "text:hide";
+        readonly applyTransform: "text:applyTransform";
+        readonly init: "text:init";
+        readonly applyTransition: "text:applyTransition";
+        readonly setFontSize: "text:setFontSize";
+    };
+    executeAction(state: GameState): CalledActionResult | Awaitable<CalledActionResult, any>;
+}

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

@@ -1,134 +1,9 @@
 import { ContentNode } from "../action/tree/actionTree";
-import { Awaitable } from "../../../util/data";
-import { Image } from "../elements/image";
 import { LogicAction } from "../action/logicAction";
 import { Action } from "../action/action";
-import type { Character } from "../elements/text";
-import type { Scene } from "../elements/scene";
-import type { Story } from "../elements/story";
-import type { Script } from "../elements/script";
-import type { Menu } from "../elements/menu";
-import type { Condition } from "../elements/condition";
-import type { CalledActionResult } from "../gameTypes";
-import { GameState } from "../../player/gameState";
-import type { Sound } from "../elements/sound";
-import { Control } from "../elements/control";
-import { CharacterActionContentType, CharacterActionTypes, ConditionActionContentType, ConditionActionTypes, ControlActionContentType, ControlActionTypes, ImageActionContentType, ImageActionTypes, MenuActionContentType, MenuActionTypes, SceneActionContentType, SceneActionTypes, ScriptActionContentType, ScriptActionTypes, SoundActionContentType, SoundActionTypes, StoryActionContentType, StoryActionTypes } from "../action/actionTypes";
 import { Chained, Proxied } from "../action/chain";
-export declare class TypedAction<ContentType extends Record<string, any> = Record<string, any>, T extends keyof ContentType & string = keyof ContentType & string, Callee extends LogicAction.GameElement = LogicAction.GameElement> extends Action<ContentType[T], Callee> {
+export declare class TypedAction<ContentType extends Record<string, any> = Record<string, any>, T extends keyof ContentType & string = keyof ContentType & string, Callee extends LogicAction.GameElement = LogicAction.GameElement> extends Action<ContentType[T], Callee, T> {
     callee: Callee;
-    constructor(callee: Proxied<Callee, Chained<LogicAction.Actions, Callee>>, type: any, contentNode: ContentNode<ContentType[T]>);
+    constructor(callee: Proxied<Callee, Chained<LogicAction.Actions, Callee>>, type: T, contentNode: ContentNode<ContentType[T]>);
     unknownType(): void;
 }
-export declare class CharacterAction<T extends typeof CharacterActionTypes[keyof typeof CharacterActionTypes] = typeof CharacterActionTypes[keyof typeof CharacterActionTypes]> extends TypedAction<CharacterActionContentType, T, Character> {
-    static ActionTypes: {
-        readonly say: "character:say";
-        readonly action: "character:action";
-    };
-    executeAction(state: GameState): CalledActionResult | Awaitable<CalledActionResult, any>;
-}
-export declare class SceneAction<T extends typeof SceneActionTypes[keyof typeof SceneActionTypes] = typeof SceneActionTypes[keyof typeof SceneActionTypes]> extends TypedAction<SceneActionContentType, T, Scene> {
-    static ActionTypes: {
-        readonly action: "scene:action";
-        readonly setBackground: "scene:setBackground";
-        readonly sleep: "scene:sleep";
-        readonly setTransition: "scene:setTransition";
-        readonly applyTransition: "scene:applyTransition";
-        readonly init: "scene:init";
-        readonly exit: "scene:exit";
-        readonly jumpTo: "scene:jumpTo";
-        readonly setBackgroundMusic: "scene:setBackgroundMusic";
-        readonly preUnmount: "scene:preUnmount";
-        readonly applyTransform: "scene:applyTransform";
-    };
-    static handleSceneInit(sceneAction: SceneAction, state: GameState, awaitable: Awaitable<CalledActionResult, any>): Awaitable<CalledActionResult<any>, any> | {
-        type: number | Scene | [] | [import("../common/transition").ITransition<{}> | null] | [import("../common/transition").ITransition<{}>] | [import("../types").StaticImageData | {
-            url: string;
-        } | import("../types").color | null | undefined] | Promise<any> | Awaitable<any, any> | [Scene] | [Sound | null, (number | undefined)?] | [import("../common/elements").Transform<import("../common/types").TransformDefinitions.ImageTransformProps>];
-        node: import("../action/tree/actionTree").RenderableNode | null;
-    };
-    static registerEventListeners(scene: Scene, state: GameState, onInit?: () => void): void;
-    executeAction(state: GameState): CalledActionResult | Awaitable<CalledActionResult, any>;
-    getFutureActions(): LogicAction.Actions[];
-}
-export declare class StoryAction<T extends typeof StoryActionTypes[keyof typeof StoryActionTypes] = typeof StoryActionTypes[keyof typeof StoryActionTypes]> extends TypedAction<StoryActionContentType, T, Story> {
-    static ActionTypes: {
-        readonly action: "story:action";
-    };
-}
-export declare class ImageAction<T extends typeof ImageActionTypes[keyof typeof ImageActionTypes] = typeof ImageActionTypes[keyof typeof ImageActionTypes]> extends TypedAction<ImageActionContentType, T, Image> {
-    static ActionTypes: {
-        readonly action: "image:action";
-        readonly setSrc: "image:setSrc";
-        readonly setPosition: "image:setPosition";
-        readonly show: "image:show";
-        readonly hide: "image:hide";
-        readonly applyTransform: "image:applyTransform";
-        readonly init: "image:init";
-        readonly dispose: "image:dispose";
-        readonly setTransition: "image:setTransition";
-        readonly applyTransition: "image:applyTransition";
-        readonly flush: "image:flush";
-    };
-    executeAction(state: GameState): CalledActionResult | Awaitable<CalledActionResult, any>;
-}
-export declare class ConditionAction<T extends typeof ConditionActionTypes[keyof typeof ConditionActionTypes] = typeof ConditionActionTypes[keyof typeof ConditionActionTypes]> extends TypedAction<ConditionActionContentType, T, Condition> {
-    static ActionTypes: {
-        readonly action: "condition:action";
-    };
-    executeAction(gameState: GameState): {
-        type: any;
-        node: import("../action/tree/actionTree").RenderableNode | null;
-    };
-    getFutureActions(): LogicAction.Actions[];
-}
-export declare class ScriptAction<T extends typeof ScriptActionTypes[keyof typeof ScriptActionTypes] = typeof ScriptActionTypes[keyof typeof ScriptActionTypes]> extends TypedAction<ScriptActionContentType, T, Script> {
-    static ActionTypes: {
-        readonly action: "script:action";
-    };
-    executeAction(gameState: GameState): CalledActionResult<any> | Awaitable<CalledActionResult<any>, any>;
-}
-export declare class MenuAction<T extends typeof MenuActionTypes[keyof typeof MenuActionTypes] = typeof MenuActionTypes[keyof typeof MenuActionTypes]> extends TypedAction<MenuActionContentType, T, Menu> {
-    static ActionTypes: {
-        readonly action: "menu:action";
-    };
-    executeAction(state: GameState): Awaitable<CalledActionResult<any>, CalledActionResult<any>>;
-    getFutureActions(): LogicAction.Actions[];
-}
-export declare class SoundAction<T extends typeof SoundActionTypes[keyof typeof SoundActionTypes] = typeof SoundActionTypes[keyof typeof SoundActionTypes]> extends TypedAction<SoundActionContentType, T, Sound> {
-    static ActionTypes: {
-        readonly action: "sound:action";
-        readonly play: "sound:play";
-        readonly stop: "sound:stop";
-        readonly fade: "sound:fade";
-        readonly setVolume: "sound:setVolume";
-        readonly setRate: "sound:setRate";
-        readonly pause: "sound:pause";
-        readonly resume: "sound:resume";
-    };
-    static initSound(state: GameState, sound: Sound): void;
-    executeAction(state: GameState): CalledActionResult | Awaitable<CalledActionResult, any>;
-}
-export declare class ControlAction<T extends typeof ControlActionTypes[keyof typeof ControlActionTypes] = typeof ControlActionTypes[keyof typeof ControlActionTypes]> extends TypedAction<ControlActionContentType, T, Control> {
-    static ActionTypes: {
-        readonly action: "control:action";
-        readonly do: "control:do";
-        readonly doAsync: "control:doAsync";
-        readonly any: "control:any";
-        readonly all: "control:all";
-        readonly allAsync: "control:allAsync";
-        readonly repeat: "control:repeat";
-    };
-    /**
-     * Execute all actions in the content node
-     * will wait for awaitable actions to resolve
-     */
-    executeAllActions(state: GameState, action: LogicAction.Actions): Promise<void>;
-    executeSingleAction(state: GameState, action: LogicAction.Actions): Promise<TypedAction<Record<string, any>, string, LogicAction.GameElement> | MenuAction<"menu:action"> | ControlAction<"control:action" | "control:do" | "control:doAsync" | "control:any" | "control:all" | "control:allAsync" | "control:repeat"> | ContentNode<any> | null>;
-    execute(state: GameState, awaitable: Awaitable<any, any>, content: LogicAction.Actions[]): Awaitable<any, any> | {
-        type: any;
-        node: ContentNode<any> | null;
-    } | Awaitable<CalledActionResult<any>, any>;
-    executeAction(state: GameState): CalledActionResult | Awaitable<CalledActionResult, CalledActionResult>;
-    getFutureActions(): LogicAction.Actions[];
-}

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

@@ -1,4 +1,4 @@
-import type { Character } from "../elements/text";
+import type { Character } from "../elements/character";
 import type { Scene } from "../elements/scene";
 import type { Story } from "../elements/story";
 import type { Image } from "../elements/image";
@@ -6,13 +6,25 @@ import type { Condition } from "../elements/condition";
 import type { Script } from "../elements/script";
 import type { Menu } from "../elements/menu";
 import { Values } from "../../../util/data";
-import { CharacterAction, ConditionAction, ControlAction, ImageAction, MenuAction, SceneAction, ScriptAction, SoundAction, StoryAction, TypedAction } from "../action/actions";
+import { TypedAction } from "../action/actions";
 import { Sound } from "../elements/sound";
 import { Control } from "../elements/control";
-import { CharacterActionContentType, CharacterActionTypes, ConditionActionContentType, ConditionActionTypes, ControlActionContentType, ImageActionContentType, ImageActionTypes, MenuActionContentType, MenuActionTypes, SceneActionContentType, SceneActionTypes, ScriptActionContentType, ScriptActionTypes, SoundActionContentType, StoryActionContentType, StoryActionTypes } from "../action/actionTypes";
+import { CharacterActionContentType, CharacterActionTypes, ConditionActionContentType, ConditionActionTypes, ControlActionContentType, ImageActionContentType, ImageActionTypes, MenuActionContentType, MenuActionTypes, SceneActionContentType, SceneActionTypes, ScriptActionContentType, ScriptActionTypes, SoundActionContentType, StoryActionContentType, StoryActionTypes, TextActionContentType } from "../action/actionTypes";
+import { CharacterAction } from "../action/actions/characterAction";
+import { SceneAction } from "../action/actions/sceneAction";
+import { StoryAction } from "../action/actions/storyAction";
+import { ImageAction } from "../action/actions/imageAction";
+import { ConditionAction } from "../action/actions/conditionAction";
+import { ScriptAction } from "../action/actions/scriptAction";
+import { MenuAction } from "../action/actions/menuAction";
+import { SoundAction } from "../action/actions/soundAction";
+import { ControlAction } from "../action/actions/controlAction";
+import { Text } from "../elements/text";
+import { TextAction } from "../action/actions/textAction";
 export declare namespace LogicAction {
-    type GameElement = Character | Scene | Story | Image | Condition | Script | Menu | Sound | Control;
-    type Actions = (TypedAction | CharacterAction | ConditionAction | ImageAction | SceneAction | ScriptAction | StoryAction | MenuAction | SoundAction | ControlAction);
-    type ActionTypes = Values<typeof CharacterActionTypes> | Values<typeof ConditionActionTypes> | Values<typeof ImageActionTypes> | Values<typeof SceneActionTypes> | Values<typeof ScriptActionTypes> | Values<typeof StoryActionTypes> | Values<typeof MenuActionTypes> | Values<typeof SoundAction.ActionTypes> | Values<typeof ControlAction.ActionTypes>;
-    type ActionContents = CharacterActionContentType & ConditionActionContentType & ImageActionContentType & SceneActionContentType & ScriptActionContentType & StoryActionContentType & MenuActionContentType & SoundActionContentType & ControlActionContentType;
+    type Displayable = Text;
+    type GameElement = Character | Scene | Story | Image | Condition | Script | Menu | Sound | Control | Text;
+    type Actions = (TypedAction | CharacterAction | ConditionAction | ImageAction | SceneAction | ScriptAction | StoryAction | MenuAction | SoundAction | ControlAction | TextAction);
+    type ActionTypes = Values<typeof CharacterActionTypes> | Values<typeof ConditionActionTypes> | Values<typeof ImageActionTypes> | Values<typeof SceneActionTypes> | Values<typeof ScriptActionTypes> | Values<typeof StoryActionTypes> | Values<typeof MenuActionTypes> | Values<typeof SoundAction.ActionTypes> | Values<typeof ControlAction.ActionTypes> | Values<typeof TextAction.ActionTypes>;
+    type ActionContents = CharacterActionContentType & ConditionActionContentType & ImageActionContentType & SceneActionContentType & ScriptActionContentType & StoryActionContentType & MenuActionContentType & SoundActionContentType & ControlActionContentType & TextActionContentType;
 }

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

@@ -1,12 +1,31 @@
-import type { Background, NextJSStaticImageData } from "../types";
+import type { Background, color, HexColor, ImageColor, ImageSrc, NextJSStaticImageData } from "../types";
 import type { Scene } from "../elements/scene";
 import type { Image } from "../elements/image";
+export declare class RGBColor {
+    static isHexString(color: any): color is HexColor;
+    static fromHex(hex: HexColor): RGBColor;
+    r: number;
+    g: number;
+    b: number;
+    a: number;
+    constructor(r: number, g: number, b: number, a?: number);
+    toString(): string;
+    toHex(): string;
+    toImageColor(): ImageColor;
+}
 export declare class Utils {
+    static RGBColor: typeof RGBColor;
     static srcToString(src: string | NextJSStaticImageData): string;
     static staticImageDataToSrc(image: NextJSStaticImageData | string): string;
     static isStaticImageData(src: any): src is NextJSStaticImageData;
-    static backgroundToSrc(background: Background["background"]): any;
+    static backgroundToSrc(background: Background["background"]): string | null;
     static isExternalSrc(src: string): boolean;
+    static isImageSrc(src: any): src is ImageSrc;
+    static isImageColor(color: any): color is ImageColor;
+    static isPlainColor(color: any): color is color;
+    static isHexString(color: any): color is HexColor;
+    static toBackgroundSrc(src: ImageSrc): string;
+    static toHex(color: ImageColor): HexColor;
 }
 export declare class UseError<T = Record<string, any>> extends Error {
     static isUseError(error: any): error is UseError;

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

@@ -1,4 +1,4 @@
-import { Character, Sentence, Word } from "../elements/text";
+import { Character } from "../elements/character";
 import { Condition, Lambda } from "../elements/condition";
 import { Control } from "../elements/control";
 import { Image } from "../elements/image";
@@ -8,4 +8,8 @@ import { Script } from "../elements/script";
 import { Sound, SoundType } from "../elements/sound";
 import { Story } from "../elements/story";
 import { Transform } from "../elements/transform/transform";
-export { Character, Condition, Control, Image, Lambda, Menu, Scene, Script, Sentence, Sound, SoundType, Story, Transform, Word };
+import { Sentence } from "../elements/character/sentence";
+import { Word } from "../elements/character/word";
+import { Text } from "../elements/text";
+import { Pause } from "../elements/character/pause";
+export { Character, Condition, Control, Image, Lambda, Menu, Scene, Script, Sentence, Sound, SoundType, Story, Transform, Word, Text, Pause };

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

@@ -1,7 +1,7 @@
-import { ITransition } from "../elements/transition/type";
-import { Fade } from "../elements/transition/fade";
-import { FadeIn } from "../elements/transition/fadeIn";
-import { Dissolve } from "../elements/transition/dissolve";
-import { Base } from "../elements/transition/base";
-export { Fade, FadeIn, Dissolve, Base };
-export type { ITransition };
+import { IImageTransition, ITextTransition, ITransition } from "../elements/transition/type";
+import { BaseImageTransition, BaseTextTransition, BaseTransition } from "../elements/transition/baseTransitions";
+import { Fade } from "../elements/transition/imageTransitions/fade";
+import { FadeIn } from "../elements/transition/imageTransitions/fadeIn";
+import { Dissolve } from "../elements/transition/imageTransitions/dissolve";
+export { Fade, FadeIn, Dissolve, BaseTransition, BaseImageTransition, BaseTextTransition, };
+export type { ITransition, IImageTransition, ITextTransition, };

package/dist/game/nlcore/elements/character/pause.d.ts

@@ -0,0 +1,9 @@
+export type PauseConfig = {
+    duration?: number;
+};
+export type PausingShortcut = typeof Pause;
+export type Pausing = Pause | PausingShortcut;
+export declare class Pause {
+    static wait(duration: number): Pause;
+    constructor(config?: Partial<PauseConfig>);
+}

package/dist/game/nlcore/elements/character/sentence.d.ts

@@ -0,0 +1,29 @@
+import { Sound } from "../../elements/sound";
+import type { Character } from "../../elements/character";
+import { Word } from "../../elements/character/word";
+import { Color, Font } from "../../types";
+import type { ScriptCtx } from "../../elements/script";
+import { Pausing } from "../../elements/character/pause";
+export type SentenceConfig = {
+    pause?: boolean | number;
+    voice: Sound | null;
+    character: Character | null;
+} & Color & Font;
+export type SentenceDataRaw = {
+    state: SentenceState;
+};
+export type SentenceState = {
+    display: boolean;
+};
+export type SentenceUserConfig = Partial<Omit<SentenceConfig, "voice"> & {
+    voice: Sound | string | null | undefined;
+}>;
+export type DynamicWord = (ctx: ScriptCtx) => DynamicWordResult;
+export type DynamicWordResult = string | Word | Pausing | (string | Word | Pausing)[];
+export type StaticWord<T extends string | DynamicWord | Pausing = string | DynamicWord | Pausing> = string | Pausing | Word<T>;
+export type SingleWord = StaticWord | DynamicWord;
+export type SentencePrompt = SingleWord[] | SingleWord;
+export declare class Sentence {
+    constructor(text: SentencePrompt, config?: SentenceUserConfig);
+    copy(): Sentence;
+}

package/dist/game/nlcore/elements/character/word.d.ts

@@ -0,0 +1,11 @@
+import { Color, Font } from "../../types";
+import { DynamicWord } from "../../elements/character/sentence";
+import { Pausing } from "../../elements/character/pause";
+export type WordConfig = {
+    className?: string;
+    ruby?: string;
+} & Color & Font;
+export declare class Word<T extends string | DynamicWord | Pausing = string | DynamicWord | Pausing> {
+    static isWord(obj: any): obj is Word;
+    constructor(text: T, config?: Partial<WordConfig>);
+}