script-engine-lib 0.4.3 → 1.0.0-rc0

package/dist/engine/story-engine.d.ts

@@ -1,35 +0,0 @@
-import { EventDefinition } from '../interfaces';
-export interface StoryEngineOptions {
-    readonly manualTestingMode?: boolean;
-}
-export declare abstract class StoryEngineFunctions {
-    abstract onPlayerChoice(choices: readonly string[]): void;
-    abstract onDialog(text: string, speaker: string): void;
-}
-export declare enum StoryEngineState {
-    running = "running",
-    waitingForPlayerChoice = "waitingForPlayerChoice",
-    finished = "finished"
-}
-export declare class StoryEngine<EventFunctions extends StoryEngineFunctions> {
-    private eventDefinitions;
-    private jsEngine;
-    private stack;
-    private playerBranchingChoices;
-    private manualTestingMode;
-    get variables(): {
-        [key: string]: any;
-    };
-    get state(): StoryEngineState;
-    private get running();
-    constructor(eventDefinitions: Readonly<Record<string, EventDefinition>>, functions: EventFunctions, variables: {
-        [key: string]: any;
-    }, options?: StoryEngineOptions);
-    startEvent(eventId: string): void;
-    next(): void;
-    playerChoice(choice: number): void;
-    private jumpToEvent;
-    private executeAction;
-    private insertActionsToStack;
-    private validateReservedFunctions;
-}

package/dist/engine/story-engine.js

@@ -1,175 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.StoryEngine = exports.StoryEngineState = exports.StoryEngineFunctions = void 0;
-const helpers_lib_1 = require("helpers-lib");
-class StoryEngineFunctions {
-}
-exports.StoryEngineFunctions = StoryEngineFunctions;
-var StoryEngineState;
-(function (StoryEngineState) {
-    StoryEngineState["running"] = "running";
-    StoryEngineState["waitingForPlayerChoice"] = "waitingForPlayerChoice";
-    StoryEngineState["finished"] = "finished";
-})(StoryEngineState || (exports.StoryEngineState = StoryEngineState = {}));
-class StoryEngine {
-    get variables() {
-        return this.jsEngine.variables;
-    }
-    get state() {
-        if (this.playerBranchingChoices) {
-            return StoryEngineState.waitingForPlayerChoice;
-        }
-        else if (this.running) {
-            return StoryEngineState.running;
-        }
-        else {
-            return StoryEngineState.finished;
-        }
-    }
-    get running() {
-        return !this.stack.isEmpty;
-    }
-    constructor(eventDefinitions, functions, variables, options) {
-        this.stack = new helpers_lib_1.Stack();
-        this.manualTestingMode = false;
-        this.validateReservedFunctions(functions);
-        this.manualTestingMode = options?.manualTestingMode ? true : false;
-        this.eventDefinitions = eventDefinitions;
-        this.jsEngine = new helpers_lib_1.JSEngine(functions, variables);
-    }
-    startEvent(eventId) {
-        if (!this.stack.isEmpty) {
-            throw new Error(`StoryEngine: Existing event haven't been concluded yet.`);
-        }
-        this.jumpToEvent(eventId);
-    }
-    next() {
-        if (this.stack.isEmpty) {
-            throw new Error(`StoryEngine: There is no active event to iterate.`);
-        }
-        if (this.state !== StoryEngineState.running) {
-            throw new Error(`StoryEngine: The engine is not in running state. Next action cannot be executed. State: ${this.state}`);
-        }
-        let action = this.stack.pop();
-        this.executeAction(action);
-    }
-    playerChoice(choice) {
-        if (!this.playerBranchingChoices) {
-            throw new Error(`StoryEngine: No player branching choices available.`);
-        }
-        let selectedActions = this.playerBranchingChoices[choice];
-        if (!selectedActions) {
-            throw new Error(`StoryEngine: Invalid player choice.`);
-        }
-        this.insertActionsToStack(selectedActions);
-        this.playerBranchingChoices = undefined;
-        if (this.running) {
-            this.next();
-        }
-    }
-    jumpToEvent(eventId) {
-        let eventDefinition = this.eventDefinitions[eventId];
-        if (!eventDefinition) {
-            throw new Error(`StoryEngine: Event definition not found: ${eventId}`);
-        }
-        this.insertActionsToStack(eventDefinition.actions);
-    }
-    executeAction(action) {
-        switch (action.type) {
-            case 'command':
-                this.jsEngine.execute(action.value);
-                break;
-            case 'dialog': {
-                let dialogItem = action.value;
-                this.jsEngine.functions.onDialog(this.jsEngine.string(dialogItem.text), dialogItem.speaker);
-                break;
-            }
-            case 'jumpToEvent': {
-                this.jumpToEvent(action.value);
-                if (this.running) {
-                    this.next();
-                }
-                break;
-            }
-            case 'branchByCondition': {
-                let branches = action.value;
-                let selectedBranch = branches.find(branch => {
-                    if (branch.condition) {
-                        return this.jsEngine.boolean(branch.condition);
-                    }
-                    else {
-                        return true;
-                    }
-                });
-                if (!selectedBranch) {
-                    throw new Error(`StoryEngine: No branch is fulfilled the condition in branchByCondition action.`);
-                }
-                else {
-                    this.insertActionsToStack(selectedBranch.actions);
-                }
-                if (this.running) {
-                    this.next();
-                }
-                break;
-            }
-            case 'branchByChance': {
-                let validBranches = action.value.filter(branch => {
-                    if (branch.condition) {
-                        return this.jsEngine.boolean(branch.condition);
-                    }
-                    else {
-                        return true;
-                    }
-                });
-                if (validBranches.length === 0) {
-                    throw new Error(`StoryEngine: No branch is fulfilled the condition in branchByChance action.`);
-                }
-                else if (this.manualTestingMode) {
-                    this.playerBranchingChoices = validBranches.map(branch => branch.actions);
-                    this.jsEngine.functions.onPlayerChoice(validBranches.map(branch => branch.label));
-                }
-                else {
-                    let selectedActions = helpers_lib_1.Random.pickRandomElementWithWeight(validBranches.map(branch => ({
-                        value: branch.actions,
-                        weight: helpers_lib_1.Comparator.isString(branch.weight) ? this.jsEngine.number(branch.weight) : branch.weight
-                    })));
-                    this.insertActionsToStack(selectedActions);
-                    if (this.running) {
-                        this.next();
-                    }
-                }
-                break;
-            }
-            case 'branchByPlayerChoice': {
-                let validBranches = action.value.filter(branch => {
-                    if (branch.condition) {
-                        return this.jsEngine.boolean(branch.condition);
-                    }
-                    else {
-                        return true;
-                    }
-                });
-                if (validBranches.length === 0) {
-                    throw new Error(`StoryEngine: No branch is fulfilled the condition in branchByPlayerChoice action.`);
-                }
-                else {
-                    this.playerBranchingChoices = validBranches.map(branch => branch.actions);
-                    this.jsEngine.functions.onPlayerChoice(validBranches.map(branch => this.jsEngine.string(branch.text)));
-                }
-                break;
-            }
-            default:
-                throw new Error(`StoryEngine: Unknown action type: ${action.type}`);
-        }
-    }
-    insertActionsToStack(actions) {
-        this.stack.add(...actions);
-    }
-    validateReservedFunctions(functions) {
-        if (helpers_lib_1.JSEngine.isJSEngineFunction(functions.onPlayerChoice)) {
-            throw new Error(`StoryEngine: onPlayerChoice function shall not be decorated as a JSEngineFunction.`);
-        }
-    }
-}
-exports.StoryEngine = StoryEngine;
-//# sourceMappingURL=story-engine.js.map

package/dist/engine/story-engine.test.d.ts

@@ -1 +0,0 @@
-export {};