narrat 2.0.0-test-2 → 2.0.1

package/dist/plugins/NarratPlugin.d.ts

@@ -0,0 +1,11 @@
+import { NarratPluginObject } from '../exports/plugins';
+export declare class NarratPlugin<T = any> implements NarratPluginObject<T> {
+    onPageLoaded(): void;
+    onNarratSetup(): void;
+    onAppMounted(): void;
+    onAssetsLoaded(): void;
+    onGameSetup(): void;
+    onGameStart(): void;
+    onGameMounted(): void;
+    onGameDismounted(): void;
+}

package/dist/stores/audio-store.d.ts

@@ -0,0 +1,12 @@
+export interface AudioState {
+    currentMusic?: string;
+    musicHowlId?: number;
+}
+export declare type AudioSave = Omit<AudioState, 'musicHowlId'>;
+export declare const useAudio: import("pinia").StoreDefinition<"audio", AudioState, {}, {
+    stopMusic(): void;
+    setMusic(music: string, soundId: number): void;
+    generateSaveData(): AudioSave;
+    loadSaveData(data: AudioSave): void;
+    reset(): void;
+}>;

package/dist/stores/dialog-store.d.ts

@@ -0,0 +1,31 @@
+export declare type AddDialogParams = Omit<DialogKey, 'id' | 'interactive'> & {
+    interactive?: boolean;
+};
+export interface DialogKey {
+    speaker: string;
+    text: string;
+    pose?: string;
+    choices?: DialogChoice[];
+    textField?: boolean;
+    interactive: boolean;
+    id: string;
+}
+export interface DialogChoice {
+    choice: string;
+    originalIndex: number;
+    allowed: boolean;
+}
+declare type DialogState = {
+    dialog: DialogKey[];
+};
+export declare type DialogSave = DialogState;
+export declare const useDialogStore: import("pinia").StoreDefinition<"dialog", DialogState, {
+    currentDialog(): DialogKey;
+}, {
+    generateSaveData(): DialogSave;
+    loadSaveData(data: DialogSave): void;
+    addDialog(dialog: AddDialogParams): void;
+    clearDialog(): void;
+    reset(): void;
+}>;
+export {};

package/dist/stores/hud-stats-store.d.ts

@@ -0,0 +1,22 @@
+import { HudStatConfig } from '../config';
+export interface HudStatsState {
+    [key: string]: HudStat;
+}
+export interface HudStat {
+    value: number;
+}
+export interface HudState {
+    hudStats: HudStatsState;
+}
+export declare type HudSave = HudState;
+export declare const useHud: import("pinia").StoreDefinition<"hud", HudState, {}, {
+    setupHudStats(stats: {
+        [key: string]: HudStatConfig;
+    }): void;
+    setStat(stat: string, value: number): void;
+    addStat(stat: string, value: number): void;
+    getStat(stat: string): HudStat;
+    getStatValue(stat: string): number;
+    generateSaveData(): HudSave;
+    loadSaveData(data: HudSave): void;
+}>;

package/dist/stores/inventory-store.d.ts

@@ -0,0 +1,37 @@
+import { ItemData } from '../config';
+export interface ItemState {
+    amount: number;
+    id: string;
+}
+export interface InventoryState {
+    /** Note: Items are an object so that it's easy to access specific items in game scripts.
+     * One side effect of this is that the order items appear in isn't technicaclly guaranteed.
+     * It also means there can only be one "stack" of an item at a time */
+    items: {
+        [key: string]: ItemState;
+    };
+    interactionTags: {
+        [key: string]: {
+            blockedInteraction: boolean;
+        };
+    };
+}
+export declare type InventorySave = InventoryState;
+export declare const useInventory: import("pinia").StoreDefinition<"inventory", InventoryState, {}, {
+    generateSaveData(): InventorySave;
+    loadSaveData(save: InventorySave): void;
+    setupItems(items: {
+        [key: string]: ItemData;
+    }): void;
+    hasItem(itemId: string, amount?: number): boolean;
+    getExistingItem(id: string): ItemState | undefined;
+    getItemAmount(id: string): number;
+    add(item: ItemState): void;
+    enableInteraction(tag?: string): void;
+    disableInteraction(tag?: string): void;
+    onScriptStart(): void;
+    onScriptEnd(): void;
+    isInteractionTagBlocked(tag?: string): boolean;
+    remove(item: ItemState): void;
+    deleteItem(id: string): void;
+}>;

package/dist/stores/main-store.d.ts

@@ -0,0 +1,276 @@
+import { GameSave } from '../types/game-save';
+import { AppOptions, Config } from '../config';
+export interface ErrorState {
+    text: string;
+}
+interface MainState {
+    ready: boolean;
+    playing: boolean;
+    errors: ErrorState[];
+    playTime: {
+        start: number;
+        previousPlaytime: number;
+    };
+    options: AppOptions;
+    flowState: 'menu' | 'playing';
+    modal: string | false;
+    paused: boolean;
+}
+export interface MainSaveData {
+    playTime: number;
+}
+export declare const useMain: import("pinia").StoreDefinition<"main", MainState, {}, {
+    setup(scriptPaths: string[], config: Config): Promise<void>;
+    startMachine(): void;
+    startGame(): Promise<void>;
+    loadGame(saveFile: string): Promise<void>;
+    playerAnswered(choice: number | string): void;
+    menuReturn(): void;
+    createError(text: string): void;
+    clearErrors(): void;
+    setFlowState(flowState: 'menu' | 'playing'): void;
+    openModal(modal: string): void;
+    closeModal(): void;
+    toggleMenu(): void;
+    pause(): void;
+    unpause(): void;
+    setOptions(options: AppOptions): void;
+    startPlaying(): void;
+    reset(): void;
+    generateSaveData(): MainSaveData;
+    loadSaveData(data: MainSaveData): void;
+    saveGame(): void;
+    setLoadedData(save: GameSave): void;
+    getAllStates(): {
+        main: any & {
+            ready: boolean;
+            playing: boolean;
+            errors: {
+                text: string;
+            }[];
+            playTime: {
+                start: number;
+                previousPlaytime: number;
+            };
+            options: {
+                logging: boolean;
+                debug: boolean;
+            };
+            flowState: 'menu' | 'playing';
+            modal: string | false;
+            paused: boolean;
+        } & import("pinia")._StoreWithState<"main", MainState, {}, any> & import("pinia")._StoreWithGetters<{}> & import("pinia").PiniaCustomProperties<string, import("pinia").StateTree, import("pinia")._GettersTree<import("pinia").StateTree>, import("pinia")._ActionsTree>;
+        screens: import("pinia").Store<"screens", {
+            currentScreen: string;
+            buttons: import("./screens-store").ButtonsState;
+        }, {}, {
+            setScreen(screen: string): void;
+            setButtons(buttons: {
+                [key: string]: import("../config").ButtonConfig;
+            }): void;
+            changeButton(button: string, newValue: boolean): void;
+            generateSaveData(): import("./screens-store").ScreenState;
+            loadSaveData(data: import("./screens-store").ScreenState): void;
+        }>;
+        skills: import("pinia").Store<"skills", import("./skills").Skills, {}, {
+            setupSkillCheck(skillCheck: import("./skills").SkillCheckState, id: string): void;
+            passSkillCheck(skillCheckId: string, hide?: boolean | undefined): void;
+            failSkillCheck(skillCheckId: string, hide?: boolean | undefined): void;
+            generateSaveData(): import("./skills").Skills;
+            getSkillCheck(id: string): import("./skills").SkillCheckState;
+            createSkillCheckState(): import("./skills").SkillCheckState;
+            loadSaveData(data: import("./skills").Skills): void;
+            setupSkills(skills: {
+                [key: string]: import("../config").SkillData;
+            }): void;
+            addXp(skill: string, xp: number): void;
+            incrementSkill(skill: string, amount: number): void;
+            levelledUp(skill: string): void;
+        }>;
+        dialog: import("pinia").Store<"dialog", {
+            dialog: import("./dialog-store").DialogKey[];
+        }, {
+            currentDialog(): import("./dialog-store").DialogKey;
+        }, {
+            generateSaveData(): {
+                dialog: import("./dialog-store").DialogKey[];
+            };
+            loadSaveData(data: {
+                dialog: import("./dialog-store").DialogKey[];
+            }): void;
+            addDialog(dialog: import("./dialog-store").AddDialogParams): void;
+            clearDialog(): void;
+            reset(): void;
+        }>;
+        vm: import("pinia").Store<"vm", import("./vm-store").VMState, {
+            currentStack(state: {
+                lastChoiceCommand?: {
+                    args: (import("../types/parser").Parser.Primitive | {
+                        code: string;
+                        command: {
+                            commandType: string;
+                            operator: string;
+                            args: (import("../types/parser").Parser.Primitive | any)[];
+                            options: import("../types/parser").Parser.DefaultArg;
+                            staticOptions: {};
+                        };
+                        fileName: string;
+                        line: number;
+                    })[];
+                    commandType: string;
+                    options: import("../types/parser").Parser.DefaultArg;
+                    code: string;
+                    staticOptions: {};
+                    operator: string;
+                    line: number;
+                    fileName: string;
+                } | undefined;
+                stack: {
+                    currentIndex: number;
+                    branchData: {
+                        branch: {
+                            code: string;
+                            command: {
+                                commandType: string;
+                                operator: string;
+                                args: (import("../types/parser").Parser.Primitive | any)[];
+                                options: import("../types/parser").Parser.DefaultArg;
+                                staticOptions: {};
+                            };
+                            fileName: string;
+                            line: number;
+                        }[];
+                        args?: string[] | undefined;
+                    };
+                    label: string;
+                    scope: {
+                        [key: string]: any;
+                    };
+                    onComplete?: ((result: any) => void) | undefined;
+                    returnValue: any;
+                }[];
+                script: import("../types/parser").Parser.ParsedScript;
+                data: import("./vm-store").DataState;
+                lastLabel: string;
+                currentScope: {
+                    [key: string]: any;
+                };
+            } & import("pinia").PiniaCustomStateProperties<import("./vm-store").VMState>): {
+                currentIndex: number;
+                branchData: {
+                    branch: {
+                        code: string;
+                        command: {
+                            commandType: string;
+                            operator: string;
+                            args: (import("../types/parser").Parser.Primitive | any)[];
+                            options: import("../types/parser").Parser.DefaultArg;
+                            staticOptions: {};
+                        };
+                        fileName: string;
+                        line: number;
+                    }[];
+                    args?: string[] | undefined;
+                };
+                label: string;
+                scope: {
+                    [key: string]: any;
+                };
+                onComplete?: ((result: any) => void) | undefined;
+                returnValue: any;
+            };
+            currentLine(): import("../types/parser").Parser.ParsedExpression<import("../types/parser").Parser.DefaultArg, {}> | undefined;
+        }, {
+            generateSaveData(): import("./vm-store").VMSave;
+            loadSaveData(data: import("./vm-store").VMSave): void;
+            resetScope(): void;
+            setReturnValue(value: any): void;
+            removeFromScope(vars: string[]): void;
+            addScopedVariable(key: string, value: any): void;
+            extendScope(scope: {
+                [key: string]: any;
+            }): void;
+            loadScripts(scriptPaths: string[]): Promise<void>;
+            start(): void;
+            setLastLabel(label: string): void;
+            reset(): void;
+            setScript(script: import("../types/parser").Parser.ParsedScript): void;
+            overrideData(data: import("./vm-store").DataState): void;
+            setStack(stack: import("./vm-store").SetStackOptions): void;
+            stackOptionsToStack(stack: import("./vm-store").SetStackOptions): import("./vm-store").MachineStack;
+            setData(path: string, value: any): void;
+            addInstruction(path: string, value: any): void;
+            addStack(newStackOptions: import("./vm-store").AddStackOptions): Promise<void>;
+            nextLine(): Promise<any>;
+            previousStack(): Promise<any>;
+            finishGame(): void;
+            runLine(): Promise<void>;
+            runLabelFunction(label: string, ...args: any[]): Promise<unknown>;
+            runCustomStack(stack: import("./vm-store").AddStackOptions): void;
+            runLabel(label: string, ...args: any[]): void;
+        }>;
+        hud: import("pinia").Store<"hud", import("./hud-stats-store").HudState, {}, {
+            setupHudStats(stats: {
+                [key: string]: import("../config").HudStatConfig;
+            }): void;
+            setStat(stat: string, value: number): void;
+            addStat(stat: string, value: number): void;
+            getStat(stat: string): import("./hud-stats-store").HudStat;
+            getStatValue(stat: string): number;
+            generateSaveData(): import("./hud-stats-store").HudState;
+            loadSaveData(data: import("./hud-stats-store").HudState): void;
+        }>;
+        audio: import("pinia").Store<"audio", import("./audio-store").AudioState, {}, {
+            stopMusic(): void;
+            setMusic(music: string, soundId: number): void;
+            generateSaveData(): import("./audio-store").AudioSave;
+            loadSaveData(data: import("./audio-store").AudioSave): void;
+            reset(): void;
+        }>;
+        rendering: import("pinia").Store<"rendering", import("./rendering-store").RenderingState, {}, {
+            updateScreenSize(width: number, height: number, textWidth: number): void;
+        }>;
+        notifications: import("pinia").Store<"notifications", import("./notification-store").NotificationsState, {}, {
+            addNotification(text: string): Promise<void>;
+            deleteNotification(id: string): void;
+        }>;
+        inventory: import("pinia").Store<"inventory", import("./inventory-store").InventoryState, {}, {
+            generateSaveData(): import("./inventory-store").InventoryState;
+            loadSaveData(save: import("./inventory-store").InventoryState): void;
+            setupItems(items: {
+                [key: string]: import("../config").ItemData;
+            }): void;
+            hasItem(itemId: string, amount?: number | undefined): boolean;
+            getExistingItem(id: string): import("./inventory-store").ItemState | undefined;
+            getItemAmount(id: string): number;
+            add(item: import("./inventory-store").ItemState): void;
+            enableInteraction(tag?: string | undefined): void;
+            disableInteraction(tag?: string | undefined): void;
+            onScriptStart(): void;
+            onScriptEnd(): void;
+            isInteractionTagBlocked(tag?: string | undefined): boolean;
+            remove(item: import("./inventory-store").ItemState): void;
+            deleteItem(id: string): void;
+        }>;
+        quests: import("pinia").Store<"quests", import("./quest-log").QuestLogState, {}, {
+            getQuest(questId: string): import("./quest-log").QuestState;
+            getObjective(questId: string, objectiveId: string): import("./quest-log").ObjectiveState;
+            setupQuests(quests: {
+                [key: string]: import("../config").QuestData;
+            }): void;
+            startQuest(questId: string): void;
+            startObjective(questId: string, objectiveId: string): void;
+            completeObjective(questId: string, objectiveId: string): void;
+            completeQuest(questId: string, ending?: string | undefined): void;
+            isQuestCompleted(questId: string): boolean;
+            isObjectiveCompleted(questId: string, objectiveId: string): boolean;
+            isQuestStarted(questId: string): boolean;
+            isObjectiveStarted(questId: string, objectiveId: string): boolean;
+            removeQuest(id: string): void;
+            generateSaveData(): import("./quest-log").QuestLogState;
+            loadSaveData(data: import("./quest-log").QuestLogState): void;
+        }>;
+    };
+    overrideStates(override: any): void;
+}>;
+export {};

package/dist/stores/notification-store.d.ts

@@ -0,0 +1,12 @@
+export interface NotificationState {
+    text: string;
+}
+export interface NotificationsState {
+    notifications: {
+        [key: string]: NotificationState;
+    };
+}
+export declare const useNotifications: import("pinia").StoreDefinition<"notifications", NotificationsState, {}, {
+    addNotification(text: string): Promise<void>;
+    deleteNotification(id: string): void;
+}>;

package/dist/stores/quest-log.d.ts

@@ -0,0 +1,39 @@
+import { QuestData } from '../config';
+export interface QuestLogState {
+    quests: {
+        [key: string]: QuestState;
+    };
+}
+export interface QuestState {
+    id: string;
+    state: 'hidden' | 'unlocked' | 'completed';
+    ending?: string;
+    /** Note: Objectives are an object so that it's easy to access specific objectives in game scripts.
+     * One side effect of this is that the order objectives appear in isn't technicaclly guaranteed. */
+    objectives: {
+        [key: string]: ObjectiveState;
+    };
+}
+export interface ObjectiveState {
+    id: string;
+    state: 'hidden' | 'unlocked' | 'completed';
+}
+export declare type QuestLogSave = QuestLogState;
+export declare const useQuests: import("pinia").StoreDefinition<"quests", QuestLogState, {}, {
+    getQuest(questId: string): QuestState;
+    getObjective(questId: string, objectiveId: string): ObjectiveState;
+    setupQuests(quests: {
+        [key: string]: QuestData;
+    }): void;
+    startQuest(questId: string): void;
+    startObjective(questId: string, objectiveId: string): void;
+    completeObjective(questId: string, objectiveId: string): void;
+    completeQuest(questId: string, ending?: string): void;
+    isQuestCompleted(questId: string): boolean;
+    isObjectiveCompleted(questId: string, objectiveId: string): boolean;
+    isQuestStarted(questId: string): boolean;
+    isObjectiveStarted(questId: string, objectiveId: string): boolean;
+    removeQuest(id: string): void;
+    generateSaveData(): QuestLogSave;
+    loadSaveData(data: QuestLogSave): void;
+}>;

package/dist/stores/rendering-store.d.ts

@@ -0,0 +1,13 @@
+export interface RenderingState {
+    screenWidth: number;
+    screenHeight: number;
+    canvasWidth: number;
+    canvasHeight: number;
+    renderRatio: number;
+    topOffset: number;
+    leftOffset: number;
+    layoutMode: 'horizontal' | 'vertical';
+}
+export declare const useRenderingStore: import("pinia").StoreDefinition<"rendering", RenderingState, {}, {
+    updateScreenSize(width: number, height: number, textWidth: number): void;
+}>;

package/dist/stores/screens-store.d.ts

@@ -0,0 +1,23 @@
+import { ButtonConfig } from '../config';
+export interface ButtonsState {
+    [key: string]: {
+        enabled: boolean;
+    };
+}
+export interface ScreenState {
+    currentScreen: string;
+    buttons: ButtonsState;
+}
+export declare type ScreenSave = ScreenState;
+export declare const useScreens: import("pinia").StoreDefinition<"screens", {
+    currentScreen: string;
+    buttons: ButtonsState;
+}, {}, {
+    setScreen(screen: string): void;
+    setButtons(buttons: {
+        [key: string]: ButtonConfig;
+    }): void;
+    changeButton(button: string, newValue: boolean): void;
+    generateSaveData(): ScreenSave;
+    loadSaveData(data: ScreenSave): void;
+}>;

package/dist/stores/skills.d.ts

@@ -0,0 +1,36 @@
+import { SkillData } from '../config';
+export interface SkillState {
+    id: string;
+    level: number;
+    xp: number;
+}
+export interface SkillsState {
+    [key: string]: SkillState;
+}
+export interface SkillCheckState {
+    happened: boolean;
+    succeeded: boolean;
+    hidden: boolean;
+}
+export interface Skills {
+    skillChecks: {
+        [key: string]: SkillCheckState;
+    };
+    skills: SkillsState;
+}
+export declare type SkillsSave = Skills;
+export declare const useSkills: import("pinia").StoreDefinition<"skills", Skills, {}, {
+    setupSkillCheck(skillCheck: SkillCheckState, id: string): void;
+    passSkillCheck(skillCheckId: string, hide?: boolean): void;
+    failSkillCheck(skillCheckId: string, hide?: boolean): void;
+    generateSaveData(): SkillsSave;
+    getSkillCheck(id: string): SkillCheckState;
+    createSkillCheckState(): SkillCheckState;
+    loadSaveData(data: SkillsSave): void;
+    setupSkills(skills: {
+        [key: string]: SkillData;
+    }): void;
+    addXp(skill: string, xp: number): void;
+    incrementSkill(skill: string, amount: number): void;
+    levelledUp(skill: string): void;
+}>;

package/dist/stores/vm-store.d.ts

@@ -0,0 +1,148 @@
+import { Parser } from '../types/parser';
+export declare type AddStackOptions = Omit<SetStackOptions, 'label'> & {
+    label?: string;
+};
+export interface MachineStack {
+    currentIndex: number;
+    branchData: Parser.ParsedLabel;
+    label: string;
+    scope: {
+        [key: string]: any;
+    };
+    onComplete?: (result: any) => void;
+    returnValue: any;
+}
+export interface SetStackOptions {
+    currentIndex: number;
+    branchData: Parser.ParsedLabel;
+    label: string;
+    scope?: {
+        [key: string]: any;
+    };
+    onComplete?: (result: any) => void;
+    args?: any[];
+}
+export interface DataState {
+    [key: string]: any;
+}
+export interface VMState {
+    lastChoiceCommand?: Parser.Command;
+    stack: MachineStack[];
+    script: Parser.ParsedScript;
+    data: DataState;
+    lastLabel: string;
+    currentScope: {
+        [key: string]: any;
+    };
+}
+export interface VMSave {
+    lastLabel: string;
+    data: DataState;
+}
+export declare const useVM: import("pinia").StoreDefinition<"vm", VMState, {
+    currentStack(state: {
+        lastChoiceCommand?: {
+            args: (Parser.Primitive | {
+                code: string;
+                command: {
+                    commandType: string;
+                    operator: string;
+                    args: (Parser.Primitive | any)[];
+                    options: Parser.DefaultArg;
+                    staticOptions: {};
+                };
+                fileName: string;
+                line: number;
+            })[];
+            commandType: string;
+            options: Parser.DefaultArg;
+            code: string;
+            staticOptions: {};
+            operator: string;
+            line: number;
+            fileName: string;
+        } | undefined;
+        stack: {
+            currentIndex: number;
+            branchData: {
+                branch: {
+                    code: string;
+                    command: {
+                        commandType: string;
+                        operator: string;
+                        args: (Parser.Primitive | any)[];
+                        options: Parser.DefaultArg;
+                        staticOptions: {};
+                    };
+                    fileName: string;
+                    line: number;
+                }[];
+                args?: string[] | undefined;
+            };
+            label: string;
+            scope: {
+                [key: string]: any;
+            };
+            onComplete?: ((result: any) => void) | undefined;
+            returnValue: any;
+        }[];
+        script: Parser.ParsedScript;
+        data: DataState;
+        lastLabel: string;
+        currentScope: {
+            [key: string]: any;
+        };
+    } & import("pinia").PiniaCustomStateProperties<VMState>): {
+        currentIndex: number;
+        branchData: {
+            branch: {
+                code: string;
+                command: {
+                    commandType: string;
+                    operator: string;
+                    args: (Parser.Primitive | any)[];
+                    options: Parser.DefaultArg;
+                    staticOptions: {};
+                };
+                fileName: string;
+                line: number;
+            }[];
+            args?: string[] | undefined;
+        };
+        label: string;
+        scope: {
+            [key: string]: any;
+        };
+        onComplete?: ((result: any) => void) | undefined;
+        returnValue: any;
+    };
+    currentLine(): Parser.ParsedExpression<Parser.DefaultArg, {}> | undefined;
+}, {
+    generateSaveData(): VMSave;
+    loadSaveData(data: VMSave): void;
+    resetScope(): void;
+    setReturnValue(value: any): void;
+    removeFromScope(vars: string[]): void;
+    addScopedVariable(key: string, value: any): void;
+    extendScope(scope: {
+        [key: string]: any;
+    }): void;
+    loadScripts(scriptPaths: string[]): Promise<void>;
+    start(): void;
+    setLastLabel(label: string): void;
+    reset(): void;
+    setScript(script: Parser.ParsedScript): void;
+    overrideData(data: DataState): void;
+    setStack(stack: SetStackOptions): void;
+    stackOptionsToStack(stack: SetStackOptions): MachineStack;
+    setData(path: string, value: any): void;
+    addInstruction(path: string, value: any): void;
+    addStack(newStackOptions: AddStackOptions): Promise<void>;
+    nextLine(): Promise<any>;
+    previousStack(): Promise<any>;
+    finishGame(): void;
+    runLine(): Promise<void>;
+    runLabelFunction(label: string, ...args: any[]): Promise<unknown>;
+    runCustomStack(stack: AddStackOptions): void;
+    runLabel(label: string, ...args: any[]): void;
+}>;

package/dist/types/app-types.d.ts

@@ -0,0 +1,4 @@
+export interface GameConfig {
+    charactersPath: string;
+    configPath: string;
+}