@strixit/storyscript 0.0.0-stage → 1.0.0

package/src/Engine/arrayAndFunctionExtensions.ts

@@ -0,0 +1,269 @@
+import {StateProperties} from "./stateProperties";
+import {compareString, getId, getKeyPropertyNames, isDataRecord, propertyMatch} from "./utilityFunctions";
+import {TypeProperty} from 'src/constants';
+
+const deletedCollection: string = '_deleted';
+
+if (Function.prototype.proxy === undefined) {
+    // This code has to be outside the addFunctionExtensions to have the correct function scope for the proxy.
+    Function.prototype.proxy = function (proxyFunction: Function, ...params: any[]) {
+        const originalFunction = this;
+
+        return (function () {
+            // Creating an object to attach the function to is a workaround to not
+            // trigger the TypeScript error TS2683: 'this' implicitly has type 'any'.
+            const func = {
+                func: function () {
+                    const args = [].slice.call(arguments);
+
+                    if (originalFunction) {
+                        args.splice(0, 0, this);
+                        args.splice(1, 0, originalFunction);
+                    }
+
+                    return proxyFunction.apply(this, args.concat(...params));
+                }
+            };
+
+            func.func.isProxy = true;
+            return func.func;
+        })();
+    };
+}
+
+export function addFunctionExtensions() {
+    /* v8 ignore start  */
+    if (Function.prototype.name === undefined) {
+        // This is only used by legacy browsers
+        Object.defineProperty(Function.prototype, 'name', {
+            get: function () {
+                return /function ([^(]*)/.exec(this + '')[1];
+            }
+        });
+    }
+    /* v8 ignore stop  */
+}
+
+export function addUniqueId(entity: any) {
+    if (entity[TypeProperty] && !entity[StateProperties.Id]) {
+        entity[StateProperties.Id] = crypto.randomUUID();
+    }
+}
+
+export function addArrayExtensions() {
+    if ((<any>Array.prototype).get === undefined) {
+        Object.defineProperty(Array.prototype, 'get', {
+            enumerable: false,
+            value: function (id: any) {
+                let result: any;
+
+                if (id) {
+                    result = find(id, this, false)[0];
+                } else {
+                    result = this[0];
+                }
+                
+                return result;
+            }
+        });
+    }
+
+    if ((<any>Array.prototype).all === undefined) {
+        Object.defineProperty(Array.prototype, 'all', {
+            enumerable: false,
+            value: function (id: any) {
+                return find(id, this, false).filter(r => !r[StateProperties.Deleted]);
+            }
+        });
+    }
+
+    if ((<any>Array.prototype).getDeleted === undefined) {
+        Object.defineProperty(Array.prototype, 'getDeleted', {
+            enumerable: false,
+            value: function () {
+                return this[deletedCollection] ?? [];
+            }
+        });
+    }
+
+    if ((<any>Array.prototype).add === undefined) {
+        Object.defineProperty(Array.prototype, 'add', {
+            enumerable: false,
+            writable: true,
+            value: function (entity: any) {
+                if (entity === undefined) {
+                    return;
+                }
+
+                let deleted: any;
+
+                // Add a unique id to identify the add record if it doesn't have one yet, so we can
+                // match it to a delete record when appropriate. Otherwise, try and get a matching 
+                // delete record to see whether the record originally came from this array.
+                if (entity[StateProperties.Id]) {
+                    deleted = this.getDeleted()?.find((e: {
+                        [StateProperties.Id]: string;
+                    }) => e[StateProperties.Id] === entity[StateProperties.Id]);
+                } else {
+                    addUniqueId(entity);
+                }
+
+                // If an existing delete record is found, the item was originally removed from this array.
+                // Remove the deleted record, the added flag and unique id so the original situation is
+                // restored. Otherwise, add the added flag.
+                if (deleted) {
+                    const deletedItems = this[deletedCollection];
+                    deletedItems.splice(deletedItems.indexOf(deleted), 1);
+                    delete entity[StateProperties.Id];
+                    delete entity[StateProperties.Added];
+                } else if (isDataRecord(entity)) {
+                    entity[1][StateProperties.Added] = true;
+                }
+                else {
+                    entity[StateProperties.Added] = true;
+                }
+
+                Array.prototype.push.call(this, entity);
+            }
+        });
+    }
+
+    if ((<any>Array.prototype).delete === undefined) {
+        Object.defineProperty(Array.prototype, 'delete', {
+            enumerable: false,
+            writable: true,
+            value: function (item: any) {
+                if (item === undefined) {
+                    return;
+                }
+
+                const collection = this;
+                const firstCollectionItem = collection[0];
+                
+                if (firstCollectionItem 
+                    && Array.isArray(firstCollectionItem) 
+                    && firstCollectionItem.length === 2 
+                    && typeof firstCollectionItem[0] === 'string') {
+                    item = collection.get(item);
+                }
+                
+                const index = findIndex(collection, item);
+
+                if (index === -1) {
+                    return;
+                }
+                
+                // When an id was passed in, replace the item with the actual entity so we 
+                // have the information we need to create the deletion record.
+                if (typeof item === 'string') {
+                    item = collection[index];
+                }
+
+                Array.prototype.splice.call(this, index, 1);
+                collection[deletedCollection] = collection[deletedCollection] || [];
+
+                // If a deletion record is deleted, simply move it to the deleted collection.
+                if (item[StateProperties.Deleted]) {
+                    collection[deletedCollection].push(item);
+                    return item;
+                }
+
+                // Only add a deletion record when the item is removed from the array and the
+                // item does not have the 'added' flag. Otherwise, it came from another array
+                // that has the deletion record for this item.
+                if (!item[StateProperties.Added]) {
+                    // Add a unique id to the item to track it if it doesn't have one yet.
+                    addUniqueId(item);
+
+                    const {first, second} = getKeyPropertyNames(item);
+                    let keyProps: { [x: string]: any; };
+
+                    if (first && second) {
+                        keyProps = {[first]: item[first], [second]: item[second]};
+                    } else if (first) {
+                        keyProps = {[first]: item[first]}
+                    } else {
+                        keyProps = {[second]: item[second]};
+                    }
+
+                    if (item[StateProperties.Id]) {
+                        collection[deletedCollection].push({
+                            ...keyProps,
+                            [StateProperties.Deleted]: true,
+                            [StateProperties.Id]: item[StateProperties.Id]
+                        });
+                    } else {
+                        collection[deletedCollection].push({
+                            ...keyProps,
+                            [StateProperties.Deleted]: true
+                        });
+                    }
+                }
+
+                return item;
+            }
+        });
+    }
+
+    if ((<any>Array.prototype).clear === undefined) {
+        Object.defineProperty(Array.prototype, 'clear', {
+            enumerable: false,
+            value: function () {
+                const collection = [...this];
+
+                collection.forEach(e => {
+                    this.delete(e);
+                });
+            }
+        });
+    }
+}
+
+function findIndex(collection: any[], item: any) {
+    let entry: any;
+
+    if (isDataRecord(item)) {
+        entry = collection.find(e => e[0] === item[0]);
+    } else {
+        entry = find(item, collection, false)[0];
+    }
+
+    let index: number;
+
+    if (entry === undefined) {
+        index = collection.indexOf(item);
+    } else {
+        index = collection.indexOf(entry);
+    }
+    
+    return index;
+}
+
+function find(id: any, array: any[], usePropertyMatch: boolean): any[] {
+    if (typeof id === 'object') {
+        let result = Array.prototype.filter.call(array, (x: any) => x === id);
+
+        if (result.length === 0 && usePropertyMatch) {
+            result = Array.prototype.filter.call(array, p => propertyMatch(id, p));
+        }
+
+        return result;
+    }
+
+    id = getId(id);
+
+    return Array.prototype.filter.call(array, (x: { id: string, target: Function | string } | Function) => {
+        let currentId: string | Function;
+        
+        if (typeof x === 'function') {
+            currentId = x;
+        } else if (Array.isArray(x) && x.length === 2) {
+            currentId = x[0];
+            
+        } else {
+            currentId = x.target ?? x.id;
+        }
+
+        return compareString(getId(currentId), id) || (x[StateProperties.Id] && compareString(x[StateProperties.Id], id));
+    });
+}

package/src/Engine/defaultTexts.ts

@@ -0,0 +1,162 @@
+import {IInterfaceTexts} from 'storyScript';
+
+export class DefaultTexts {
+    texts: IInterfaceTexts = {
+        equipmentHeader: 'Equipment',
+        head: 'Head',
+        amulet: 'Amulet',
+        rightHand: 'Right hand',
+        leftHand: 'Left hand',
+        body: 'Body',
+        legs: 'Legs',
+        feet: 'Feet',
+        backpack: 'Backpack',
+        equip: 'Equip',
+        use: 'Use',
+        groupItem: 'Group',
+        splitItemGroup: 'Split',
+        drop: 'Drop',
+        enemies: 'Enemies',
+        enemyHitpoints: 'Health: {0} / {1}',
+        enemyCombatName: "{0} {1}",
+        characterHitpoints: 'Health: {0} / {1}',
+        fight: 'Fight!',
+        noWeapon: 'No weapon!',
+        attack: 'Attack ',
+        attackWith: 'with ',
+        aid: 'Aid',
+        aidWith: 'with ',
+        useCombatItem: 'Use item',
+        newGame: 'New game',
+        firstCharacter: 'Create your first character',
+        secondCharacter: 'Create your second character',
+        thirdCharacter: 'Create your third character',
+        nthCharacter: 'Create your {0}th character',
+        nextCharacter: 'Next character',
+        nextQuestion: 'Next question',
+        startAdventure: 'Start adventure',
+        actions: 'Actions',
+        destinations: 'Destinations',
+        back: 'Back: ',
+        onTheGround: 'On the ground',
+        youLost: 'You lost...',
+        questFailed: 'You have failed your quest!',
+        finalScore: 'Your score: ',
+        tryAgain: 'Try again',
+        highScores: 'High Scores',
+        youWon: 'You won!',
+        congratulations: 'Congratulations! You have won the game!',
+        playAgain: 'Play again',
+        startOver: 'Start over',
+        resetWorld: 'Reset world',
+        gameName: 'Game template',
+        save: 'Save',
+        saveGame: 'Save game',
+        load: 'Load',
+        loadGame: 'Load game',
+        loading: 'Loading...',
+        youAreHere: 'You are at {0}',
+        messages: 'Messages',
+        hitpoints: 'Health',
+        currency: 'Money',
+        partyCurrency: 'Money:',
+        trade: 'Trade with {0}',
+        talk: 'Talk to {0}',
+        examine: 'Examine {0}',
+        encounters: 'Encounters',
+        closeModal: 'Close',
+        combatTitle: 'Combat',
+        combatRound: 'Combat round {0}',
+        value: 'value',
+        traderCurrency: 'Trader money: {0} {1}',
+        startCombat: 'Start combat',
+        combatWin: 'You are victorious!',
+        enemiesToFight: 'You face these foes: ',
+        useInCombat: 'Use {0}',
+        noCombatAction: 'No Combat Actions',
+        view: 'View',
+        quests: 'Quests',
+        currentQuests: 'Current',
+        completedQuests: 'Completed',
+        hands: 'Hands',
+        leftRing: 'Left ring',
+        rightRing: 'Right ring',
+        yourName: 'Name',
+        combinations: 'Combinations',
+        tryCombination: 'Try',
+        noCombination: 'You {2} the {0} {3} the {1}. Nothing happens.',
+        noCombinationNoTool: 'You {1} {2} the {0}. Nothing happens.',
+        levelUp: 'Level up',
+        completeLevelUp: 'Accept',
+        levelUpDescription: 'You reached level {0}.',
+        newSaveGame: 'New save game',
+        existingSaveGames: 'Saved games',
+        overwriteSaveGame: 'Overwrite saved game {0}?',
+        loadSaveGame: 'Load saved game {0}?',
+        characterSheet: 'Character sheet',
+        skipIntro: 'Skip intro',
+        mainMenu: 'Main menu',
+        mainMenuShort: 'Menu',
+        confirmRestart: 'Really restart?',
+        restartCancelled: 'No',
+        restartConfirmed: 'Yes',
+        cancel: 'Cancel',
+        confirmAction: 'Ok',
+        cancelAction: 'Cancel',
+        stockItemDisplayText: '{0}: {1} {2}',
+        buyConfirmationText: 'Are you sure you want to buy the {0} for {1} {2}?',
+        confirmBuy: 'Ok',
+        cancelBuy: 'Cancel',
+        sellConfirmationText: 'Are you sure you want to sell the {0} for {1} {2}?',
+        confirmSell: 'Ok',
+        cancelSell: 'Cancel',
+        currencyWon: 'Currency gained: {0}',
+        itemsTaken: 'Items taken',
+        enemiesDefeated: 'Enemies defeated',
+        backToGame: 'Back to the game',
+        conversationEnded: 'Your conversation has ended.',
+        openFullScreenMap: '>',
+        closeFullScreenMap: '<',
+        pressToShowMarkers: 'Press {0} to show location markers',
+        touchToShowMarkers: 'Press here to show location markers',
+        startGame: 'Start',
+        continueGame: 'Continue',
+        autoplayText: "Auto-playing",
+        noPlayWarning: "Please interact with the page to allow media playback!"
+    }
+
+    format = format;
+
+    titleCase = (text: string): string => text.substring(0, 1).toUpperCase() + text.substring(1);
+}
+
+export function format(template: string, tokens: string | string[]): string {
+    if (template && tokens) {
+        if (!Array.isArray(tokens)) {
+            tokens = [tokens];
+        }
+
+        tokens.forEach((t, i) => {
+            if (t === undefined) {
+                (<string[]>tokens)[i] = "{undefined}";
+            }
+        })
+
+        for (let i = 0; i < tokens.length; i++) {
+            const pattern = '[ ]{0,1}\\{' + i + '\\}[ ]{0,1}';
+            const match = new RegExp(pattern).exec(template);
+
+            if (match) {
+                const matchReplacement = match[0].replace('{' + i + '}', '');
+
+                if (tokens[i].trim && tokens[i].trim().length == 0 && matchReplacement.length > 1) {
+                    template = template.replace(match[0], ' ');
+                } else {
+                    template = template.replace('{' + i + '}', tokens[i]);
+                }
+            }
+        }
+    }
+
+    return template;
+}

package/src/Engine/gameEvents.ts

@@ -0,0 +1,51 @@
+import {IGame, IGameEvents}from 'storyScript';
+
+export class GameEvents implements IGameEvents {
+    private readonly _eventHandlers = new Map<string, ((game: IGame, eventArguments: any) => void)[]>();
+    private _game: IGame;
+    
+    register = (eventName: string): void => {
+        if (this._eventHandlers.has(eventName)) {
+            return;
+        }
+        
+        this._eventHandlers.set(eventName, []);
+    }
+    subscribe = (eventName: string | string[], handler: (game: IGame, eventArguments: any) => void, throwIfUnknown?: boolean): void => {
+        const eventNames = Array.isArray(eventName) ? eventName : [eventName];
+        
+        eventNames.forEach(e => {
+            if (!this._eventHandlers.has(e)) {
+                if (throwIfUnknown === undefined || throwIfUnknown) {
+                    throw new Error(`Event ${e} has not been registered!`);
+                }
+                else {
+                    this._eventHandlers.set(e, []);
+                }
+            }
+            
+            const handlers = this._eventHandlers.get(e);
+            handlers.push(handler);
+        });
+    }
+    
+    publish = (eventName: string, eventData?: any): void => {
+        if (!this._eventHandlers.has(eventName)) {
+            throw new Error(`Event ${eventName} has not been registered!`);
+        }
+
+        const handlers = this._eventHandlers.get(eventName);
+        
+        if (this._game) {
+            handlers.forEach(handler => handler(this._game, eventData));
+        } else {
+            console.log(`setGame has not been called for gameEvents, or it was called without passing in a game object!`);
+        }
+    }
+    
+    setGame = (game: IGame): void => {
+        this._game = game;
+    }
+}
+
+export const gameEvents = new GameEvents();

package/src/Engine/index.ts

@@ -0,0 +1,9 @@
+import {addArrayExtensions, addFunctionExtensions} from './arrayAndFunctionExtensions';
+import {ServiceFactory} from "./ServiceFactory";
+
+export {addArrayExtensions, addFunctionExtensions, ServiceFactory};
+export * from './Interfaces/index';
+export {gameEvents} from './gameEvents';
+export * from './defaultTexts';
+export * from './Services/sharedFunctions';
+export * from './utilityFunctions';

package/src/Engine/stateProperties.ts

@@ -0,0 +1,9 @@
+export const enum StateProperties {
+    Id = 'ss_uniqueId',
+    Added = 'ss_added',
+    Deleted = 'ss_deleted',
+    
+    // A marker to see that actions have been performed and should not be repeated.
+    // This is used for e.g. initializing trader stock on a first visit.
+    Triggered = 'ss_triggered'
+}