@strixit/storyscript 0.0.0-stage → 1.0.0

package/src/Engine/Services/CombatService.ts

@@ -0,0 +1,266 @@
+import {
+    GameState,
+    ICharacter,
+    ICombatService,
+    ICombatSetup,
+    ICombatTurn,
+    IEnemy,
+    IGame,
+    IInterfaceTexts,
+    IItem,
+    IRules,
+    PlayState,
+    TargetType,
+} from 'storyScript';
+import {StateProperties} from "src/Engine/stateProperties";
+import {addUniqueId} from "src/Engine/arrayAndFunctionExtensions";
+
+export class CombatService implements ICombatService {
+    constructor(private readonly _game: IGame, private readonly _rules: IRules, private readonly _texts: IInterfaceTexts) {
+    }
+
+    initCombat = (): void => {
+        this._game.combatLog.length = 0;
+        this._rules.combat?.initCombat?.(this._game, this._game.currentLocation);
+        this.initCombatRound(true);
+        this._game.playState = PlayState.Combat;
+        this._game.combat.enemies.forEach(enemy => enemy.onAttack?.(this._game, enemy));
+    }
+
+    fight = (combat: ICombatSetup<ICombatTurn>, retaliate?: boolean): Promise<void> | void => {
+        if (!this._rules.combat?.fight) {
+            return;
+        }
+
+        const promise = this._rules.combat.fight(this._game, combat, retaliate);
+
+        return Promise.resolve(promise).then(() => {
+            combat.forEach((s, i) => {
+                const defeated = (s.item?.targetType === TargetType.Enemy || (<any>s.target)?.type === TargetType.Enemy.toLowerCase())
+                    && s.target?.currentHitpoints <= 0
+                    && (s.targetDefeated === undefined || s.targetDefeated);
+
+                if (defeated) {
+                    this.enemyDefeated(combat, this._game.party.characters[i], s.target);
+                }
+            });
+
+            if (this._game.party.characters.filter(c => c.currentHitpoints > 0).length == 0) {
+                this._game.playState = null;
+                this._game.state = GameState.GameOver;
+            }
+
+            if (combat.enemies.filter(c => c.currentHitpoints >= 0).length == 0) {
+                return;
+            }
+
+            this.initCombatRound(false);
+        });
+    }
+
+    isSelectable = (item: IItem): boolean => item?.selectable || item?.selectable === undefined;
+
+    canTarget = (item: IItem, target: IEnemy | ICharacter, character: ICharacter) => {
+        const type = (<any>target).type;
+        let canTarget = false;
+
+        if (type === 'enemy') {
+            canTarget = item.targetType === TargetType.Enemy;
+        } else {
+            switch (item.targetType) {
+                case TargetType.Ally:
+                    canTarget = target !== character;
+                    break;
+                case TargetType.Self:
+                    canTarget = target === character;
+                    break;
+                case TargetType.AllyOrSelf:
+                    canTarget = true;
+                    break;
+            }
+        }
+
+        if (!canTarget || !item.canTarget) {
+            return canTarget;
+        }
+
+        return item.canTarget(this._game, item, target);
+    }
+
+    private readonly initCombatRound = (newFight: boolean) => {
+        this._game.combat = newFight ? <ICombatSetup<ICombatTurn>>[] : this._game.combat;
+
+        if (!this._game.combat.enemies) {
+            this._game.combat.enemies = [];
+
+            const enemiesPerType = <Record<string, number[]>>{};
+            const activeEnemies = this._game.currentLocation.enemies.filter(e => !e.inactive);
+
+            activeEnemies.forEach((e: any, i) => {
+                enemiesPerType[e.id] ??= [];
+                e.index = enemiesPerType[e.id].length + 1;
+                enemiesPerType[e.id].push(i);
+            });
+
+            activeEnemies.forEach(e => {
+                // Add a unique id here so we can track multiple enemies of the same type.
+                // Combat will end only when the enemies are defeated, at which point they will
+                // be assigned a unique id anyway.
+                addUniqueId(e);
+                const name = this.getTargetName(enemiesPerType, e);
+                const copy = {...e};
+                copy.name = name;
+                copy.currentHitpoints = copy.hitpoints;
+                this._game.combat.enemies.push(copy);
+            });
+        }
+
+        this._game.combat.round = newFight ? 1 : ++this._game.combat.round;
+        this._game.combat.roundHeader = this._texts.format(this._texts.combatRound, [this._game.combat.round.toString()]);
+        this._game.combat.noActionText = this._texts.noCombatAction;
+        const enemies = this._game.combat.enemies = this._game.combat.enemies.filter(e => e.currentHitpoints > 0);
+        const characters = this._game.combat.characters = this._game.party.characters;
+
+        characters.forEach((c, i) => {
+            const allies = characters.filter(a => a != c);
+            const items = this.getItems(c, enemies, allies);
+
+            // Remember the last item used and enemy attacked and select them when they are still valid.
+            let previousItem = this._game.combat[i]?.item;
+            previousItem = this.isSelectable(previousItem) ? previousItem : undefined;
+            const previousTarget = this._game.combat[i]?.target;
+            let newItem = (previousItem && items.find(i => i === previousItem)) ?? items.filter(i => this.isSelectable(i))[0];
+            let {targets, newTarget} = this.getTarget(newItem, enemies, allies, previousTarget, previousItem);
+
+            if (!newTarget) {
+                newItem = items.filter(i => this.isSelectable(i) && (!i.canTarget || (newTarget && i.canTarget(this._game, newItem, newTarget))))[0];
+                ({
+                    targets,
+                    newTarget
+                } = this.getTarget(newItem, enemies, allies, this._game.combat[i]?.target, previousItem));
+                newTarget ??= targets[0];
+            }
+
+            this._game.combat[i] = <ICombatTurn>{
+                character: c,
+                targetsAvailable: enemies.concat(allies),
+                previousTarget: previousTarget,
+                target: newTarget,
+                itemsAvailable: items,
+                previousItem: previousItem,
+                item: newItem
+            };
+        });
+
+        this._rules.combat?.initCombatRound?.(this._game, this._game.combat);
+    }
+
+    private readonly getItems = (character: ICharacter, enemies: IEnemy[], allies: ICharacter[]) => {
+        const items = character.combatItems ?? [];
+
+        Object.keys(character.equipment).forEach(k => {
+            const item = <IItem>character.equipment[k];
+
+            if ((item?.useInCombat || item?.targetType) && items.indexOf(item) === -1) {
+                items.push(item)
+            }
+        });
+
+        items.forEach(i => {
+            if (this._rules.combat.itemIsSelectable) {
+                i.selectable = this._rules.combat.itemIsSelectable(this._game, i);
+            }
+
+            if (!i.canTarget) {
+                return;
+            }
+
+            i.selectable = false;
+            let targets;
+
+            switch (i.targetType) {
+                case TargetType.Enemy: {
+                    targets = enemies;
+                    break;
+                }
+                case TargetType.Ally: {
+                    targets = allies;
+                    break;
+                }
+                case TargetType.AllyOrSelf: {
+                    targets = allies.concat([character]);
+                    break;
+                }
+                case TargetType.Self: {
+                    targets = [character];
+                    break;
+                }
+            }
+
+            for (let x = 0; x < targets.length; x++) {
+                const target = targets[x];
+                if (i.canTarget(this._game, i, target)) {
+                    i.selectable = true;
+                    return;
+                }
+            }
+        });
+
+        items.sort((a: IItem, b: IItem) => b.targetType?.localeCompare(a.targetType) || a.name.localeCompare(b.name));
+        return items;
+    }
+
+    private readonly getTarget =
+        (newItem: IItem, enemies: IEnemy[], allies: ICharacter[], previousTarget: IEnemy | ICharacter, previousItem?: IItem):
+            { targets: IEnemy[] | ICharacter[], newTarget?: IEnemy | ICharacter } => {
+            let targetType = newItem?.targetType ?? TargetType.Enemy;
+            let targets = targetType === TargetType.Enemy ? enemies : allies;
+            let newTarget = newItem === previousItem && previousTarget ?
+                targets.find(i => i === previousTarget && (!newItem?.canTarget || newItem.canTarget(this._game, newItem, i)))
+                : undefined;
+            return {targets, newTarget};
+        }
+
+    private readonly getTargetName = (enemiesPerType: Record<string, number[]>, target: any): string => {
+        const ofSameType = enemiesPerType[target.id];
+
+        if (ofSameType.length === 1) {
+            return target.name;
+        }
+
+        return this._texts.format(this._texts.enemyCombatName, [target.name, target.index.toString()]);
+    }
+
+    private readonly enemyDefeated = (combat: ICombatSetup<ICombatTurn>, character: ICharacter, enemy: IEnemy): void => {
+        combat.winnings ??= {
+            currency: 0,
+            itemsWon: [],
+            enemiesDefeated: []
+        };
+
+        if (enemy.items) {
+            const items = [...enemy.items];
+
+            items.forEach((item: IItem) => {
+                if (!this._rules.combat?.beforeDrop || this._rules.combat.beforeDrop(this._game, character, enemy, item)) {
+                    enemy.items.delete(item);
+                    this._game.currentLocation.items.add(item);
+                    combat.winnings.itemsWon.push(item);
+                }
+            });
+        }
+
+        if (enemy.currency) {
+            this._game.party.currency ??= 0;
+            this._game.party.currency += enemy.currency || 0;
+            combat.winnings.currency += enemy.currency || 0;
+        }
+
+        this._game.statistics.enemiesDefeated ??= 0;
+        this._game.statistics.enemiesDefeated += 1;
+        combat.winnings.enemiesDefeated.push(enemy);
+        this._game.currentLocation.enemies.delete(enemy[StateProperties.Id]);
+        this._rules.combat?.enemyDefeated?.(this._game, character, enemy);
+        enemy.onDefeat?.(this._game, enemy);
+    }
+}

package/src/Engine/Services/CombinationService.ts

@@ -0,0 +1,197 @@
+import {
+    IActiveCombination,
+    ICombinable,
+    ICombinationAction,
+    ICombinationService,
+    ICombineResult,
+    IEnemy,
+    IFeature,
+    IGame,
+    IInterfaceTexts,
+    IItem,
+    IPerson,
+    IRules,
+    removeItemFromParty
+} from 'storyScript';
+import {compareString, getId} from 'src/Engine/utilityFunctions';
+
+export class CombinationService implements ICombinationService {
+
+    private readonly _combinationActions: ICombinationAction[] = [];
+
+    constructor(private readonly _game: IGame, private readonly _rules: IRules, private readonly _texts: IInterfaceTexts) {
+        this._combinationActions = this._rules.combinations?.combinationActions ?? [];
+    }
+
+    get combinationActions(): ICombinationAction[] {
+        return this._combinationActions;
+    }
+
+    getCombineClass = (tool: ICombinable): string => {
+        let className: string;
+
+        if (tool) {
+            className = this._game.combinations.activeCombination ?
+                this._game.combinations.activeCombination.selectedTool && this._game.combinations.activeCombination.selectedTool.id === tool.id ?
+                    'combine-active-selected'
+                    : 'combine-selectable' : '';
+        } else {
+            className = this._game.combinations.activeCombination ? 'combine-active-hide' : '';
+        }
+
+        return className;
+    }
+
+    setActiveCombination = (combination: ICombinationAction): void => {
+        this._game.combinations.combinationResult.reset();
+
+        if (!combination) {
+            return;
+        }
+
+        if (this._game.combinations.activeCombination && this._game.combinations.activeCombination.selectedCombinationAction === combination) {
+            this._game.combinations.activeCombination = null;
+            return;
+        }
+
+        combination.requiresTool = (combination.requiresTool === undefined) || combination.requiresTool === true;
+
+        this._game.combinations.activeCombination = {
+            selectedCombinationAction: combination,
+            selectedTool: null
+        };
+
+        this._game.combinations.combinationResult.text = combination.requiresTool ? combination.text : combination.text + ' ' + (combination.preposition || '');
+    }
+
+    tryCombination = (target: ICombinable): ICombineResult => {
+        let combo = this._game.combinations.activeCombination;
+        let result = <ICombineResult>{
+            success: false,
+            text: ''
+        };
+
+        if (!target || (target as IFeature).interactive === false) {
+            return result;
+        }
+
+        if (!combo) {
+            const defaultAction = this.combinationActions.filter(c => c.isDefault)[0];
+
+            if (defaultAction) {
+                combo = {
+                    selectedCombinationAction: defaultAction,
+                    selectedTool: null
+                }
+            }
+        }
+
+        if (!combo?.selectedCombinationAction) {
+            return result;
+        }
+
+        combo.selectedCombinationAction.preposition = combo.selectedCombinationAction.preposition || '';
+
+        if (combo.selectedCombinationAction.requiresTool && !combo.selectedTool) {
+            this._game.combinations.combinationResult.text = combo.selectedCombinationAction.text + ' ' + target.name + ' ' + combo.selectedCombinationAction.preposition;
+            combo.selectedTool = target;
+            return result;
+        }
+
+        result = this.performCombination(target, combo);
+
+        if (result.success) {
+            this._rules.combinations?.success?.(this._game, combo, target);
+
+            if (result.removeTarget) {
+                this.removeFeature(target);
+            }
+
+            if (result.removeTool && combo.selectedTool.id != target.id) {
+                this.removeFeature(combo.selectedTool);
+            }
+        }
+
+        this._game.combinations.combinationResult.text = result.text;
+        this._game.combinations.combinationResult.done = true;
+
+        return result;
+    }
+
+    private readonly performCombination = (target: ICombinable, combo: IActiveCombination): ICombineResult => {
+        const tool = combo.selectedTool;
+        const type = combo.selectedCombinationAction;
+        const prepositionText = combo.selectedCombinationAction.preposition ? ' ' + combo.selectedCombinationAction.preposition + ' ' : ' '
+        const text = combo.selectedCombinationAction.requiresTool ? combo.selectedCombinationAction.text + ' ' + tool.name + prepositionText + target.name :
+            combo.selectedCombinationAction.text + prepositionText + target.name;
+
+        this._game.combinations.activeCombination = null;
+
+        let combination = target.combinations?.combine ? target.combinations.combine.filter(c => {
+            const toolMatch = type.requiresTool && c.tool && this.isMatch(c.tool, tool);
+            return c.combinationType === type.text && (!type.requiresTool || toolMatch);
+        })[0] : null;
+
+        if (!combination) {
+            // For items, the order in which the combination is tried shouldn't matter.
+            const anyTool = <any>tool;
+
+            if (anyTool && anyTool.type === 'item' && target && anyTool.type === 'item') {
+                combination = tool.combinations?.combine ? tool.combinations.combine.filter(c => c.combinationType === type.text && this.isMatch(c.tool, target))[0] : null;
+            }
+        }
+
+        const result = <ICombineResult>{
+            success: false,
+            text: ''
+        };
+
+        if (combination) {
+            const matchResult = combination.match ? combination.match(this._game, target, tool)
+                : combo.selectedCombinationAction.defaultMatch ? combo.selectedCombinationAction.defaultMatch(this._game, target, tool)
+                    : undefined;
+
+            if (matchResult === undefined) {
+                const entity = <any>target;
+                throw new Error(`No match function specified for ${entity.type} ${entity.id} for action ${combination.combinationType}. Neither was a default action specified. Add one or both.`)
+            }
+
+            result.success = true;
+            result.text = typeof matchResult === 'string' ? matchResult : matchResult.text;
+            result.removeTarget = typeof matchResult !== 'string' && matchResult.removeTarget;
+            result.removeTool = typeof matchResult !== 'string' && matchResult.removeTool;
+        } else if (target.combinations?.failText) {
+            result.text = typeof target.combinations.failText === 'function' ? target.combinations.failText(this._game, target, tool) : target.combinations.failText;
+        } else if (type.failText) {
+            result.text = typeof type.failText === 'function' ? type.failText(this._game, target, tool) : type.failText;
+        } else {
+            result.text = tool ? this._texts.format(this._texts.noCombination, [tool.name, target.name, type.text, type.preposition]) : this._texts.format(this._texts.noCombinationNoTool, [target.name, type.text, type.preposition]);
+        }
+
+        result.text = text + (result.text ? ': ' + result.text : '')
+        return result;
+    }
+
+    private readonly isMatch = (combineTool: ICombinable, tool: ICombinable): boolean => {
+        const combineId = getId(combineTool.id ?? <any>combineTool);
+        return compareString(tool.id, combineId);
+    }
+
+    private readonly removeFeature = (feature: IFeature): void => {
+        // Remove the feature from all possible locations. As we use the object
+        // reference, objects of the same type should be left alone.
+        this._game.currentLocation.features?.delete(feature);
+        this._game.currentLocation.destinations?.forEach(d => {
+            d.barriers.forEach(([k, b]) => {
+                if (b === feature) {
+                    d.barriers.delete([k, b]);
+                }
+            })
+        });
+
+        removeItemFromParty(this._game.party, <IItem>feature);
+        this._game.currentLocation.items?.delete(<IItem>feature);
+        this._game.currentLocation.enemies?.delete(<IEnemy>feature);
+        this._game.currentLocation.persons?.delete(<IPerson>feature);
+    }
+}

package/src/Engine/Services/CommandService.ts

@@ -0,0 +1,197 @@
+import {
+    IAction,
+    IBarrier,
+    IBarrierAction,
+    ICombinationAction,
+    ICombinationService,
+    ICommandService,
+    IConversationService,
+    IDataService,
+    IDestination,
+    IFeature,
+    IGame,
+    IItem,
+    ILocation,
+    ILocationService,
+    IPerson,
+    ITradeService,
+    getItemFromParty
+} from 'storyScript';
+
+export class CommandService implements ICommandService {
+
+    private _combinationActions: ICombinationAction[] = [];
+
+    constructor(
+        private _locationService: ILocationService,
+        private _conversationService: IConversationService,
+        private _tradeService: ITradeService,
+        private _combinationService: ICombinationService,
+        private _dataService: IDataService,
+        private _game: IGame) {
+        this._combinationActions = this._combinationService.combinationActions;
+    }
+
+    go = (location: (() => ILocation) | string, saveProgress?: boolean): void => {
+        const travel = saveProgress !== false;
+
+        this._locationService.changeLocation(location, travel, this._game);
+
+        if (travel) {
+            this._dataService.saveGame(this._game);
+        }
+    }
+
+    talk = (person: () => IPerson): void => {
+        const partner = this._game.currentLocation.persons.get(person);
+
+        if (!partner) {
+            throw new Error(`No person ${person.name} present at location ${this._game.currentLocation.name}!`);
+        }
+
+        this._conversationService.talk(partner);
+    }
+
+    answer = (node: string, reply?: string): void => {
+        node ??= 'default';
+        const selectedNode = this._game.person.conversation.nodes.find(n => n.node?.toLowerCase() === node);
+
+        if (!selectedNode) {
+            throw new Error(`No node ${node} exists on the conversation with person ${this._game.person.name}!`);
+        }
+
+        reply = reply?.toLowerCase();
+        const selectedReply = selectedNode.replies.find(r => r.linkToNode?.toLowerCase() == reply || (r.defaultReply && !reply));
+
+        if (!selectedReply) {
+            throw new Error(`No reply ${reply} exists on conversation node ${node} of person ${this._game.person.name}!`);
+        }
+
+        this._conversationService.answer(selectedNode, selectedReply);
+    }
+
+    selectCombination = (combination: string): void => {
+        const selectedCombination = this.getCombination(combination);
+        this._combinationService.setActiveCombination(selectedCombination);
+    }
+
+    setTool = (feature: (() => IFeature) | string): void => {
+        const selectedTool = this.getFeature(feature);
+
+        if (!selectedTool) {
+            throw new Error(`No feature ${typeof feature === 'function' ? feature.name : feature} was found to set as tool!`);
+        }
+
+        this._combinationService.tryCombination(selectedTool);
+    }
+
+    combine = (combination: string, target: (() => IFeature) | string, tool?: (() => IFeature) | string): void => {
+        const selectedCombination = this.getCombination(combination);
+        const selectedTarget = this.getFeature(target);
+
+        if (!selectedTarget) {
+            throw new Error(`No target feature ${typeof target === 'function' ? target.name : target} was found to try combination ${combination}!`);
+        }
+
+        const selectedTool = tool ? this.getFeature(tool) : null;
+
+        if (tool && !selectedTool) {
+            throw new Error(`No tool feature ${typeof tool === 'function' ? tool.name : tool} was found to try combination ${combination}!`);
+        }
+
+        this._game.combinations.activeCombination = {
+            selectedCombinationAction: selectedCombination,
+            selectedTool: selectedTool
+        }
+
+        this._game.combinations.tryCombine(selectedTarget);
+    }
+
+    useAction = (action: string | [string, IAction]): void => {
+        const selectedAction = typeof action === 'string' ? this._game.currentLocation.actions.get(action) : action;
+
+        if (!selectedAction) {
+            throw new Error(`Action ${action} is not present at location ${this._game.currentLocation.name}!`);
+        }
+
+        this._locationService.executeAction(selectedAction);
+        this._dataService.saveGame(this._game)
+    }
+
+    useBarrierAction = (destination: string | IDestination, barrier: string | [string, IBarrier], action: string | [string, IBarrierAction]): void => {
+        const selectedDestination = typeof destination === 'string' ? this._game.currentLocation.destinations.get(destination) : destination;
+
+        if (!selectedDestination) {
+            throw new Error(`Destination ${destination} is not present at location ${this._game.currentLocation.name}!`);
+        }
+
+        const selectedBarrier = typeof barrier === 'string' ? selectedDestination.barriers.get(barrier) : barrier;
+
+        if (!selectedBarrier) {
+            throw new Error(`Barrier ${barrier} is not present on destination ${selectedDestination.name}!`);
+        }
+
+        const selectedAction = typeof action === 'string' ? selectedBarrier[1].actions.get(action) : action;
+
+        if (!selectedAction) {
+            throw new Error(`Action ${action} is not present at barrier ${selectedBarrier[0]}!`);
+        }
+
+        selectedAction[1].execute(this._game, selectedBarrier, selectedDestination);
+        selectedBarrier[1].actions.delete(selectedBarrier[1].actions.find(([k, _]) => k === action[0]));
+        this._dataService.saveGame(this._game)
+    }
+
+    trade = (trade: string | (() => IPerson)): void => {
+        const partner = this._game.currentLocation.trade.get(trade);
+
+        if (!partner) {
+            const tradeName = typeof trade === 'string' ? trade : trade.name;
+            throw new Error(`No trade ${tradeName} present at location ${this._game.currentLocation.name}!`);
+        }
+
+        this._tradeService.trade(partner);
+    }
+
+    buy = (item: (() => IItem)): void => {
+        const selectedItem = this._game.trade.buy.items.get(item);
+
+        if (!selectedItem) {
+            throw new Error(`Trader ${this._game.trade.name} does not have item ${item.name} for sale!`);
+        }
+
+        this._tradeService.buy(selectedItem, this._game.trade);
+    }
+
+    sell = (item: (() => IItem)): void => {
+        const selectedItem = this._game.trade.sell.items.get(item);
+
+        if (!selectedItem) {
+            throw new Error(`Item ${item.name} is not available or cannot be sold to ${this._game.trade.name}!`);
+        }
+
+        this._tradeService.sell(selectedItem, this._game.trade);
+    }
+
+    private getFeature(feature: (() => IFeature) | string) {
+        if (typeof feature === 'string') {
+            feature = feature.toLowerCase().replace(/\s/g, '');
+        }
+
+        let selectedFeature = this._game.currentLocation.features.get(feature);
+        selectedFeature ??= this._game.currentLocation.persons.get(<any>feature);
+        selectedFeature ??= this._game.currentLocation.enemies.get(<any>feature);
+        selectedFeature ??= getItemFromParty(this._game.party, <any>feature);
+        return selectedFeature;
+    }
+
+    private getCombination = (combination: string) => {
+        const selectedCombination = this._combinationActions.find(c => c.text.toLowerCase() === combination.toLowerCase());
+
+        if (!selectedCombination) {
+            throw new Error(`Combination ${combination} is not defined!`);
+        }
+
+        return selectedCombination;
+    }
+}