@strixit/storyscript 0.0.0-stage → 1.0.0

package/src/Engine/Services/SoundService.ts

@@ -0,0 +1,54 @@
+import {IGame, IRules, ISoundPlayer, ISoundService, selectStateListEntry} from 'storyScript';
+
+export class SoundService implements ISoundService {
+    private _musicStopped: boolean = false;
+
+    constructor(private _game: IGame, private _rules: IRules) {
+    }
+
+    getSounds = (): ISoundPlayer => {
+        return {
+            startMusic: this.startMusic,
+            stopMusic: this.stopMusic,
+            playSound: this.playSound,
+            soundQueue: new Map<number, { value: string, playing: boolean, completeCallBack?: () => void }>,
+            playedAudio: []
+        }
+    }
+
+    getCurrentMusic = (): string => {
+        if (this._musicStopped || !this._rules.setup?.playList || Object.keys(this._rules.setup.playList).length === undefined) {
+            return null;
+        }
+
+        return selectStateListEntry(this._game, this._rules.setup.playList);
+    }
+
+    private startMusic = (): boolean => this._musicStopped = false;
+
+    private stopMusic = (): boolean => this._musicStopped = true;
+
+    private playSound = (fileName: string, completeCallBack?: () => void): void => {
+        this._game.sounds.soundQueue.set(this.createHash(fileName + Math.floor(Math.random() * 1000)), {
+            value: fileName,
+            playing: false,
+            completeCallBack: completeCallBack
+        });
+    }
+
+    private createHash(value: string): number {
+        let hash = 0;
+
+        if (!value || value.length == 0) {
+            return hash;
+        }
+
+        for (let i = 0; i < value.length; i++) {
+            const char = value.charCodeAt(i);
+            hash = ((hash << 5) - hash) + char;
+            hash = hash & hash; // Convert to 32bit integer
+        }
+
+        return hash;
+    }
+}

package/src/Engine/Services/TradeService.ts

@@ -0,0 +1,176 @@
+import {
+    gameEvents,
+    IAction,
+    ICharacter,
+    IDefinitions,
+    IGame,
+    IGroupableItem,
+    IInterfaceTexts,
+    IItem,
+    IItemService,
+    IPerson,
+    IRules,
+    ITrade,
+    ITradeService,
+    PlayState,
+    randomList
+} from 'storyScript';
+import {StateProperties} from "src/Engine/stateProperties";
+
+const tradeEvent = 'trade';
+
+export class TradeService implements ITradeService {
+    private _activeTrader: IPerson;
+
+    constructor(private readonly _itemService: IItemService, private readonly _game: IGame, private readonly _rules: IRules, private readonly _texts: IInterfaceTexts, private readonly _definitions: IDefinitions) {
+        gameEvents.register(tradeEvent);
+        gameEvents.subscribe(tradeEvent, (game, data: [string, IAction]) => {
+            const trader = game.currentLocation.trade.find(t => t.id === data[0]);
+            this.trade(trader);
+        });
+    }
+
+    trade = (trade: IPerson | ITrade): void => {
+        const isPerson = trade && trade['type'] === 'person';
+        const person = <IPerson>trade;
+
+        if (isPerson) {
+            this._activeTrader = this._game.person = person;
+            this._game.trade = person.trade;
+            this._game.trade.currency = person.currency ?? 0;
+
+            if (!this._game.trade.name) {
+                this._game.trade.name = this._texts.format(this._texts.trade, [person.name]);
+            }
+        } else {
+            trade.currency ??= 0;
+            this._activeTrader = <IPerson>{currency: trade.currency};
+            this._game.trade = trade;
+            this._game.trade.ownItemsOnly = false;
+        }
+
+        this.initTrade();
+        this._game.playState = PlayState.Trade;
+    }
+
+    canPay = (item: IItem, buyer: ITrade | ICharacter, seller: ITrade | ICharacter): boolean => {
+        if (this._rules.general.canBuyItem && !this._rules.general.canBuyItem(this._game, item, buyer)) {
+            return false;
+        }
+
+        const trader = buyer as ITrade;
+        const currency = trader.buy ? trader.currency : this._game.party.currency;
+        const price = this.actualPrice(item, buyer, seller);
+        return (price !== undefined && currency !== undefined && currency >= price) || price === 0;
+    };
+
+    actualPrice = (item: IItem, buyer: ITrade | ICharacter, seller: ITrade | ICharacter): number => {
+        let resolvedModifier: number;
+        const buyerTrade = buyer as ITrade;
+        const sellerTrade = seller as ITrade;
+        const modifier = buyerTrade.sell?.priceModifier ?? sellerTrade.buy?.priceModifier;
+
+        if (modifier === undefined) {
+            resolvedModifier = 1;
+        } else if (typeof modifier === 'function') {
+            resolvedModifier = (<((game: IGame) => number)>modifier)(this._game)
+        } else {
+            resolvedModifier = modifier;
+        }
+
+        const members = <IItem[]>(item as IGroupableItem<IItem>).members;
+        const values = members ? members.concat([item]).map(m => m.value) : [item.value];
+        const totalValue = values.reduce((t, c) => t + c, 0);
+        return Math.round(totalValue * resolvedModifier);
+    }
+
+    displayPrice = (item: IItem, actualPrice: number): string => actualPrice > 0 ? this._texts.format(this._texts.stockItemDisplayText, [this._itemService.getItemName(item), actualPrice.toString(), this._texts.currency]) : this._itemService.getItemName(item);
+
+    buy = (item: IItem, trade: ITrade): boolean => {
+        if (!this.canPay(item, this._game.activeCharacter, trade)) {
+            return false;
+        }
+
+        const price = this.actualPrice(item, this._game.activeCharacter, trade);
+        trade.currency += price;
+        this._game.party.currency -= price;
+        this._activeTrader.currency = trade.currency;
+        trade.buy.items.delete(item);
+        this._game.activeCharacter.items.add(item);
+
+        if (trade.onBuy) {
+            trade.onBuy(this._game, item);
+        }
+
+        return true;
+    }
+
+    sell = (item: IItem, trade: ITrade): boolean => {
+        if (!this.canPay(item, trade, this._game.activeCharacter)) {
+            return false;
+        }
+
+        const price = this.actualPrice(item, trade, this._game.activeCharacter);
+        trade.currency -= price;
+        this._game.party.currency += price;
+        this._activeTrader.currency = trade.currency;
+        this._game.activeCharacter.items.delete(item);
+        trade.sell.items.delete(item);
+        trade.buy.items.add(item);
+
+        if (trade.onSell) {
+            trade.onSell(this._game, item);
+        }
+
+        return true;
+    }
+
+    private initTrade = (): ITrade => {
+        const trader = this._game.trade;
+
+        if (!trader) {
+            return null;
+        }
+
+        let itemsForSale: IItem[];
+
+        if (trader.buy.items) {
+            itemsForSale = trader.buy.items.slice();
+        } else if (trader[StateProperties.Triggered]) {
+            itemsForSale = []
+        }
+
+        const buySelector = (item: IItem) => {
+            return trader.buy.itemSelector(this._game, item);
+        };
+
+        // When visiting a trader for the first time and he has an initCollection function set, set the items for sale.
+        if (trader.buy.initCollection?.(this._game, trader) || !itemsForSale) {
+            const collection = <any>(trader.ownItemsOnly ? this._game.person.items : this._definitions.items);
+            itemsForSale = randomList<IItem>(collection, trader.buy.maxItems, buySelector);
+            trader[StateProperties.Triggered] = true;
+        }
+
+        const sellSelector = (item: IItem) => {
+            return trader.sell.itemSelector(this._game, item);
+        };
+
+        const itemsToSell = randomList<IItem>(this._game.activeCharacter.items, trader.sell.maxItems, sellSelector);
+        trader.buy.items ??= []
+
+        // Filter existing items using the buy selector, also when edits are made, so items that were 
+        // added before but should not be available from the trader anymore are removed. Also do apply
+        // the maxItems property on edits as well.
+        trader.buy.items.length = 0;
+        itemsForSale?.filter(buySelector).slice(0, trader.buy.maxItems).forEach(i => trader.buy.items.add(i));
+
+        trader.sell.items ??= [];
+        trader.sell.items.length = 0;
+        itemsToSell.forEach(i => trader.sell.items.push(i));
+
+        trader.buy.confirmationText ??= this._texts.buyConfirmationText;
+        trader.sell.confirmationText ??= this._texts.sellConfirmationText;
+
+        return trader;
+    }
+}

package/src/Engine/Services/index.ts

@@ -0,0 +1,17 @@
+export { AutoplayService } from './AutoplayService';
+export { CharacterService } from './CharacterService';
+export { CombatService } from './CombatService';
+export { CombinationService } from './CombinationService';
+export { CommandService } from './CommandService';
+export { ConversationService } from './ConversationService';
+export { DataSerializer } from './DataSerializer';
+export { DataService } from './DataService';
+export { DataSynchronizer } from './DataSynchronizer';
+export { GameService } from './GameService';
+export { HelperService } from './HelperService';
+export { ItemService } from './ItemService';
+export { LocalStorageService } from './LocalStorageService';
+export { LocationService } from './LocationService';
+export { SoundService } from './SoundService';
+export { TradeService } from './TradeService';
+export * from './sharedFunctions';

package/src/Engine/Services/serializationData.ts

@@ -0,0 +1,8 @@
+export interface SerializationData {
+    clone: any;
+    key: string;
+    original: any;
+    originalValue: any;
+    pristine: any;
+    pristineValue: any;
+}

package/src/Engine/Services/sharedFunctions.ts

@@ -0,0 +1,296 @@
+import {
+    GameState,
+    ICharacter,
+    IDefinitions,
+    IGame,
+    IItem,
+    ILocation,
+    IParty,
+    PlayState,
+    StateList,
+    StateListEntry
+} from 'storyScript';
+import {compareString} from "src/Engine/utilityFunctions";
+import {getParsedDocument} from "src/Engine/EntityCreatorFunctions";
+import {DescriptionProperty} from 'src/constants';
+
+const parsedDescriptions = new Map<string, boolean>();
+
+export function hasDescription(entity: { id?: string, description?: string }): boolean {
+    if (!entity.description) {
+        return false;
+    }
+
+    if (!parsedDescriptions.get(entity.id)) {
+        const descriptionNode = getParsedDocument(DescriptionProperty, entity.description)[0];
+        parsedDescriptions.set(entity.id, descriptionNode?.innerHTML?.trim() !== '');
+    }
+
+    return parsedDescriptions.get(entity.id);
+}
+
+export function random<T>(type: string, definitions: IDefinitions, selector?: (item: T) => boolean): T {
+    const collection = definitions[type];
+
+    if (!collection) {
+        return null;
+    }
+
+    const selection = getFilteredInstantiatedCollection<T>(collection, selector);
+
+    if (selection.length == 0) {
+        return null;
+    }
+
+    const index = Math.floor(Math.random() * selection.length);
+    return selection[index];
+}
+
+export function randomList<T>(collection: T[] | ([() => T]), count: number, selector?: (item: T) => boolean): T[] {
+    const selection = getFilteredInstantiatedCollection<T>(collection, selector);
+    const results = <T[]>[];
+
+    if (count === undefined) {
+        count = selection.length;
+    }
+
+    if (selection.length > 0) {
+        while (results.length < count && results.length < selection.length) {
+            const index = Math.floor(Math.random() * selection.length);
+
+            if (results.indexOf(selection[index]) == -1) {
+                results.push(selection[index]);
+            }
+        }
+    }
+
+    return results;
+}
+
+// This allows deserializing functions added at runtime without using eval.
+// Found at https://stackoverflow.com/questions/7650071/is-there-a-way-to-create-a-function-from-a-string-with-javascript
+export function parseFunction<T extends Function>(text: string) {
+    const funcReg = /function[\s]*([a-z\d]*)(\([\s\w\d,]*\))[\s]*({[\S\s]*})/gmi;
+    const match = funcReg.exec(text);
+
+    if (match) {
+        const args = match[2].substring(1, match[2].length - 1);
+        return <T>(new Function(args, match[3]));
+    }
+
+    return null;
+}
+
+/**
+ * This function creates a new function with the callback embedded. This makes the new function safe for serialization.
+ * @param functionDefinition The main function to make safe for serialization.
+ * @param callback The callback function to embed.
+ * @returns The main function with the callback embedded.
+ */
+export function makeSerializeSafe<T extends Function>(functionDefinition: T, callback: Function): T {
+    let serialized = serializeFunction(functionDefinition);
+
+    if (callback) {
+        const functionSignature = /function(\((?:[a-zA-Z]+[, )]+)*)/.exec(serialized);
+        const functionParams = functionSignature[1];
+        const callbackSignature = Array.from(serialized.matchAll(new RegExp('([a-zA-z]+)[\?\.]{0,2}\\(' + functionParams + '\\)', 'gm')))[1];
+
+        if (callbackSignature) {
+            const callbackName = callbackSignature[1];
+            const startIndex = serialized.indexOf('{') + 1;
+            serialized = serialized.substring(0, startIndex) + `const ${callbackName} = ${serializeFunction(callback)};` + serialized.substring(startIndex);
+        }
+    }
+
+    return parseFunction<T>(serialized);
+}
+
+export function serializeFunction(value: Function) {
+    const _functionArgumentRegex = /\([a-z-A-Z0-9:, ]+\)/;
+
+    // Functions added during runtime must be serialized using the function() notation in order to be deserialized back
+    // to a function. Convert values that have an arrow notation.
+    let functionString = value.toString();
+    const argumentString = functionString.substring(0, functionString.indexOf('{'));
+
+    if (argumentString.indexOf('function') == -1) {
+        const arrowIndex = argumentString.indexOf('=>');
+
+        // The arguments regex will fail when no arguments are used in production mode. Use empty brackets in that case.
+        const args = _functionArgumentRegex.exec(functionString)?.[0] || '()';
+
+        functionString = 'function' + args + functionString.substring(arrowIndex + 2).trim();
+    }
+
+    return functionString;
+}
+
+export function parseGamePropertiesInTemplate(lines: string, game?: IGame): string {
+    const propertyRegex = /{(?:[a-zA-Z\[\]0-9]+[.]?)+}/g;
+    const indexRegex = /\[\d+]/g;
+    let result = lines;
+    let parseMatch = null;
+
+    while ((parseMatch = propertyRegex.exec(lines)) !== null) {
+        let property = <unknown>game;
+        let replacement = parseMatch[0];
+        let index = null;
+        let propertyFound = false;
+
+        parseMatch[0].replace(/{|}/g, '').split('.').forEach((e: string) => {
+            index = indexRegex.exec(e);
+
+            if (index) {
+                e = e.replace(index, '');
+                index = parseInt(index[0].replace(/\[|\]/g, ''));
+            }
+
+            if (property.hasOwnProperty(e)) {
+                property = property[e];
+                propertyFound = true;
+            } else {
+                propertyFound = false;
+            }
+
+            if (!isNaN(index) && Array.isArray(property)) {
+                property = property[index];
+            }
+        });
+
+        if (propertyFound) {
+            replacement = property;
+        }
+
+        lines = lines.replace(`${parseMatch[0]}`, '');
+        result = result.replace(`${parseMatch[0]}`, replacement);
+    }
+
+    return result;
+}
+
+export function selectStateListEntry(game: IGame, stateList: StateList) {
+    // Evaluate custom functions first.
+    const customFunctions = stateList[''];
+    let result = null;
+
+    customFunctions?.filter(f => typeof f === 'function').forEach(f => {
+        result = f(game);
+    })
+
+    if (result) {
+        return result;
+    }
+
+    // Next, get the entries in this order: Location, PlayState, GameState.
+    const filteredEntries = Object.keys(stateList)
+        .map(e => mapPlaylistEntries(game, e, stateList[e]))
+        .filter(e => e);
+
+    result = filteredEntries.map(e => selectCandidate(game, e.key, e.item))
+        .filter(i => i.order > 0)
+        .sort((a, b) => a.order - b.order)[0];
+
+    return result?.key;
+}
+
+function mapPlaylistEntries(game: IGame, key: string, entry: StateListEntry) {
+    return entry.map(i => selectCandidate(game, key, i))
+        .filter(i => i.order > 0)
+        .sort((a, b) => a.order - b.order)[0];
+}
+
+export function getItemFromParty(party: IParty, item: string | (() => IItem)): IItem {
+    let foundItem: IItem;
+
+    party.characters.forEach(c => {
+        foundItem = foundItem ?? getItemFromItemsAndEquipment(c, item);
+    });
+
+    return foundItem;
+}
+
+export function removeItemFromParty(party: IParty, item: IItem | (() => IItem)) {
+    let deleted = false;
+
+    party.characters.forEach(c => {
+        if (deleted) {
+            return;
+        }
+
+        deleted = removeItemFromItemsAndEquipment(c, item);
+    });
+}
+
+export function removeItemFromItemsAndEquipment(character: ICharacter, item: IItem | (() => IItem)): boolean {
+    let deleted = false;
+
+    if (character.items.get(item)) {
+        character.items.delete(item);
+        deleted = true;
+    }
+
+    if (character.equipment) {
+        for (const n in character.equipment) {
+            if (item === character.equipment[n]) {
+                character.equipment[n] = null;
+                deleted = true;
+            }
+
+            if (deleted) {
+                break;
+            }
+        }
+    }
+
+    return deleted;
+}
+
+function getItemFromItemsAndEquipment(character: ICharacter, item: string | (() => IItem)): IItem {
+    let foundItem = character.items.get(item);
+
+    if (foundItem) {
+        return foundItem;
+    }
+
+    if (character.equipment) {
+        for (const n in character.equipment) {
+            const currentItem = character.equipment[n] as IItem;
+
+            if ((typeof item === 'function' && currentItem.id == item.name) || (currentItem.id == item)) {
+                return character.equipment[n];
+            }
+        }
+    }
+
+    return null;
+}
+
+function getFilteredInstantiatedCollection<T>(collection: T[] | (() => T)[], selector?: (item: T) => boolean) {
+    let collectionToFilter = <T[]>[];
+
+    if (typeof collection[0] === 'function') {
+        (<[() => T]>collection).forEach((def: () => T) => {
+            collectionToFilter.push(def());
+        });
+    } else {
+        collectionToFilter = <T[]>collection;
+    }
+
+    return selector ? collectionToFilter.filter(selector) : collectionToFilter;
+}
+
+function selectCandidate(game: IGame, key: string, item: (GameState | PlayState | (() => ILocation) | ((game: IGame) => string) | string)) {
+    const functionName = (<Function>item)?.name;
+    const currentLocationId = game.currentLocation?.id;
+    let order: number;
+
+    if (item === game.state) {
+        order = 3;
+    } else if (item === game.playState) {
+        order = 2;
+    } else {
+        order = functionName && currentLocationId && compareString(functionName, currentLocationId) ? 1 : 0
+    }
+
+    return {key, item, order};
+}