@strixit/storyscript 0.0.0-stage → 1.0.0

package/src/Engine/Services/ItemService.ts

@@ -0,0 +1,294 @@
+import {
+    EquipmentType,
+    ICharacter,
+    IEnemy,
+    IGame,
+    IGroupableItem,
+    IInterfaceTexts,
+    IItem,
+    IItemService,
+    IRules,
+    removeItemFromItemsAndEquipment
+} from 'storyScript';
+import {getEquipmentType} from "src/Engine/utilityFunctions";
+
+export class ItemService implements IItemService {
+
+    constructor(private _game: IGame, private _rules: IRules, private _texts: IInterfaceTexts) {
+    }
+
+    getItemName = (item: IItem): string => {
+        if (!item) {
+            return undefined;
+        }
+
+        if (this._rules.general.getItemName) {
+            return this._rules.general.getItemName(item, this._texts);
+        }
+
+        const groupableItem = item as IGroupableItem<IItem>
+
+        if (!groupableItem.members?.length) {
+            return item.name;
+        }
+
+        return this._texts.format(groupableItem.groupName, [(groupableItem.members.length + 1).toString()]);
+    }
+
+    pickupItem = (character: ICharacter, item: IItem): boolean => {
+        const isCombining = this._game.combinations?.activeCombination;
+
+        if (isCombining) {
+            this._game.combinations.tryCombine(item)
+            return false;
+        }
+
+        if (this._rules.character.beforePickup && !this._rules.character.beforePickup(this._game, character, item)) {
+            return false;
+        }
+
+        this._game.currentLocation.items.delete(item);
+        character.items.add(item);
+
+        return true;
+    }
+
+    canGroupItem = (character: ICharacter, group: IGroupableItem<IItem>, item: IGroupableItem<IItem>): boolean => {
+        if (!item || !item.isGroupable || item.members?.length) {
+            return false;
+        }
+
+        if (group) {
+            if (!group.isGroupable) {
+                return false;
+            }
+
+            if ((group.members?.length ?? 0) >= group.maxSize - 1) {
+                return false;
+            }
+
+            if (group.id !== item.id && (!group.groupTypes || group.groupTypes.indexOf(item.id) === -1)) {
+                return false;
+            }
+        }
+
+        const anyGroupableItem = character.items.find(i => {
+            if (i === item) {
+                return false;
+            }
+
+            const groupable = i as IGroupableItem<IItem>;
+            return groupable.isGroupable && (!groupable.maxSize || ((groupable.members?.length ?? 0) < groupable.maxSize - 1))
+        });
+
+        if (!anyGroupableItem) {
+            return false;
+        }
+
+        if (this._rules.general.canGroupItem) {
+            return this._rules.general.canGroupItem(character, group, item);
+        }
+
+        return true;
+    };
+
+    groupItem = (character: ICharacter, group: IGroupableItem<IItem>, item: IGroupableItem<IItem>): boolean => {
+        if (group && group !== item) {
+            group.members ??= [];
+            group.members.add(item);
+            character.items.delete(item);
+            return true;
+        }
+
+        return false;
+    }
+
+    splitItemGroup = (character: ICharacter, item: IGroupableItem<IItem>): void => {
+        if (item?.members?.length > 0) {
+            item.members.forEach((item: IItem) => {
+                character.items.add(item);
+            });
+
+            item.members = undefined;
+        }
+    }
+
+    useItem = (character: ICharacter, item: IItem, target?: IEnemy): Promise<void> | void => {
+        const useItem = (this._rules.exploration?.onUseItem?.(this._game, character, item) && item.use) ?? item.use;
+
+        if (useItem) {
+            const promise = item.use(this._game, character, item, target);
+
+            return Promise.resolve(promise).then(() => {
+                if (item.charges !== undefined) {
+                    if (!isNaN(item.charges)) {
+                        item.charges--;
+                    }
+
+                    if (item.charges <= 0) {
+                        removeItemFromItemsAndEquipment(character, item);
+                    }
+                }
+            });
+        }
+    }
+
+    isEquippable = (item: IItem, character?: ICharacter): boolean => {
+        if (item.equipmentType === EquipmentType.Miscellaneous) {
+            return false;
+        }
+
+        if (this._rules.character.canEquip) {
+            return this._rules.character.canEquip(item, character);
+        }
+
+        return true;
+    };
+
+    equipItem = (character: ICharacter, item: IItem): boolean => {
+        const equipmentTypes = Array.isArray(item.equipmentType) ? <EquipmentType[]>item.equipmentType : [<EquipmentType>item.equipmentType];
+
+        const slotsAvailable = this.makeSlotAvailable(character, item, equipmentTypes);
+
+        if (slotsAvailable.length === 0) {
+            return false;
+        }
+
+        if (this._rules.character.beforeEquip) {
+            if (!this._rules.character.beforeEquip(this._game, character, item)) {
+                return false;
+            }
+        }
+
+        if (item.equip) {
+            if (!item.equip(character, item, this._game)) {
+                return false;
+            }
+        }
+
+        for (const n in slotsAvailable) {
+            character.equipment[slotsAvailable[n]] = item;
+        }
+
+        character.items.splice(character.items.indexOf(item), 1);
+        return true;
+    }
+
+    unequipItem = (character: ICharacter, item: IItem): boolean => {
+        return this.unequip(character, item);
+    }
+
+    canDrop = (item: IItem): boolean => {
+        let canDrop: boolean;
+
+        if (typeof item.canDrop === 'function') {
+            canDrop = item.canDrop(this._game, item);
+        } else if (item.canDrop === undefined) {
+            canDrop = true;
+        } else {
+            canDrop = item.canDrop;
+        }
+
+        return canDrop
+    };
+
+    dropItem = (character: ICharacter, item: IItem): void => {
+        if (!item) {
+            return;
+        }
+
+        let drop = true;
+
+        if (this._rules.character.beforeDrop) {
+            drop = this._rules.character.beforeDrop(this._game, character, item);
+        }
+
+        if (drop) {
+            character.items.delete(item);
+            this._game.currentLocation.items.add(item);
+        }
+    }
+
+    private makeSlotAvailable(character: ICharacter, item: IItem, equipmentTypes: EquipmentType[]): string[] {
+        if (!item.usesMultipleSlots) {
+            return this.findAvailableSlot(character, equipmentTypes);
+        }
+
+        const availableSlots: string[] = [];
+
+        for (const n in equipmentTypes) {
+            const type = getEquipmentType(equipmentTypes[n]);
+            const slotItem = character.equipment[type];
+
+            if (slotItem) {
+                const unequipped = this.unequip(character, slotItem);
+
+                if (!unequipped) {
+                    return [];
+                }
+            }
+
+            availableSlots.push(type);
+        }
+
+        return availableSlots;
+    }
+
+    private findAvailableSlot(character: ICharacter, equipmentTypes: EquipmentType[]) {
+        // If the item uses only one of the slots specified, see if a slot is available first.
+        const occupiedSlots: string[] = [];
+        const emptySlots: string[] = [];
+
+        for (const n in equipmentTypes) {
+            const type = getEquipmentType(equipmentTypes[n]);
+
+            if (character.equipment[type]) {
+                occupiedSlots.push(type);
+            } else {
+                emptySlots.push(type);
+            }
+        }
+
+        if (emptySlots.length === 0) {
+            const slotToUnequip = occupiedSlots[occupiedSlots.length - 1];
+            const unequipped = this.unequip(character, character.equipment[slotToUnequip]);
+            return !unequipped ? [] : [slotToUnequip];
+        }
+
+        return [emptySlots[0]];
+    }
+
+    private unequip = (character: ICharacter, equippedItem: IItem): boolean => {
+        if (!equippedItem) {
+            return true;
+        }
+
+        if (this._rules.character.beforeUnequip) {
+            if (!this._rules.character.beforeUnequip(this._game, character, equippedItem)) {
+                return false;
+            }
+        }
+
+        if (equippedItem.unequip) {
+            if (!equippedItem.unequip(character, equippedItem, this._game)) {
+                return false;
+            }
+        }
+
+        if (equippedItem?.equipmentType && character.items.indexOf(equippedItem) < 0) {
+            character.items.push(equippedItem);
+        }
+
+        const slotsToUnEquip = Array.isArray(equippedItem.equipmentType)
+            ? equippedItem.equipmentType
+            : [equippedItem.equipmentType];
+
+        slotsToUnEquip.forEach(t => {
+            const itemType = getEquipmentType(t);
+            const slotItem = character.equipment[itemType];
+            character.equipment[itemType] = slotItem === equippedItem ? null : slotItem;
+        });
+
+        return true;
+    }
+}

package/src/Engine/Services/LocalStorageService.ts

@@ -0,0 +1,24 @@
+import {ILocalStorageService} from 'storyScript';
+
+const StoryScriptPrefix: string = 'StoryScript_';
+
+export class LocalStorageService implements ILocalStorageService {
+    get = (key: string): any => localStorage.getItem(StoryScriptPrefix + key);
+
+    set = (key: string, value: any): void => localStorage.setItem(StoryScriptPrefix + key, value);
+
+    remove = (key: string): void => localStorage.removeItem(StoryScriptPrefix + key);
+
+    getKeys = (prefix: string): string[] => {
+        const result = [];
+        prefix = StoryScriptPrefix + prefix;
+
+        Object.keys(localStorage).forEach(k => {
+            if (k.startsWith(prefix)) {
+                result.push(k.replace(prefix, ''));
+            }
+        });
+
+        return result;
+    }
+}

package/src/Engine/Services/LocationService.ts

@@ -0,0 +1,380 @@
+import {
+    ActionType,
+    gameEvents,
+    IAction,
+    ICompiledLocation,
+    IDefinitions,
+    IDestination,
+    IGame,
+    IGameEvents,
+    IKey,
+    ILocation,
+    ILocationService,
+    IRules,
+    parseGamePropertiesInTemplate
+} from 'storyScript';
+import {addHtmlSpaces, getId, parseHtmlDocumentFromString} from 'src/Engine/utilityFunctions';
+import {getBasicFeatureData, setDestination} from "src/Engine/EntityCreatorFunctions";
+
+export class LocationService implements ILocationService {
+    constructor(
+        private readonly _definitions: IDefinitions,
+        private readonly _rules: IRules,
+        private readonly _game: IGame,
+        private readonly _gameEvents: IGameEvents,
+    ) {
+    }
+
+    init = (): void => {
+        this._game.currentLocation = null;
+        this._game.previousLocation = null;
+
+        if (!this._game.locations) {
+            // When we don't have any locations yet, we're starting a new game. Use the definitions to build
+            // all the locations. Also build the maps, if present.
+            this._game.locations = {};
+            this._definitions.locations.forEach(l => this._game.locations[getId(l)] = <ICompiledLocation>l());
+        }
+
+        if (!this._game.maps && this._definitions.maps) {
+            this._game.maps = {};
+            // When we have no maps, it could be that maps were added later and that they are not in the saved
+            // data yet. Add the maps available now.
+            this._definitions.maps?.forEach(m => this._game.maps[getId(m)] = m());
+        }
+
+        this.setupLocations();
+
+        this._gameEvents.subscribe(['add-character-items', 'delete-character-items', 'add-location-items'], (game: IGame, _) => {
+            game.currentLocation?.destinations.forEach(d => {
+                this.addKeyAction(game, d);
+            })
+        }, false);
+    }
+
+    changeLocation = (location: string | (() => ILocation), travel: boolean, game: IGame): void => {
+        // Clear the play state on travel.
+        game.playState = null;
+        this._rules.exploration?.leaveLocation?.(game, game.currentLocation, getId(location), travel);
+        this.playEvents(game, 'leaveEvents');
+
+        // If there is no location, we are starting a new game. We're done here.
+        if (!this.switchLocation(game, location)) {
+            return;
+        }
+
+        this.processDestinations(game);
+        this._game.party.currentLocationId = game.currentLocation.id;
+        this._game.party.previousLocationId = game.previousLocation?.id;
+        this._rules.exploration?.enterLocation?.(game, game.currentLocation, game.previousLocation?.id, travel);
+        this.loadLocationDescriptions(game);
+        this.initTrade(game);
+        this.playEvents(game, 'enterEvents');
+        this.markCurrentLocationAsVisited(game);
+    }
+
+    executeAction = (action: [string, IAction]): void => {
+        const execute = action[1]?.execute;
+
+        if (execute) {
+            let result = true;
+
+            if (typeof execute === 'function') {
+                const actionResult = execute(this._game);
+                result = actionResult === true;
+            } else {
+                gameEvents.publish(execute, action);
+            }
+
+            const typeAndIndex = this.getActionIndex(this._game, action);
+
+            if (!result && typeAndIndex.index !== -1) {
+                if (typeAndIndex.type === ActionType.Regular && this._game.currentLocation.actions) {
+                    const currentAction = this._game.currentLocation.actions[typeAndIndex.index];
+                    this._game.currentLocation.actions.delete(currentAction);
+                } else if (typeAndIndex.type === ActionType.Combat && this._game.currentLocation.combatActions) {
+                    const currentCombatAction = this._game.currentLocation.combatActions[typeAndIndex.index];
+                    this._game.currentLocation.combatActions.delete(currentCombatAction);
+                }
+            }
+        }
+    }
+
+    loadLocationDescriptions = (game: IGame): void => {
+        if (this.selectLocationDescription(game)) {
+            parseGamePropertiesInTemplate(game.currentLocation.description, this._game);
+            this.processTextFeatures(game.currentLocation);
+        }
+    }
+
+    initDestinations = (location: ICompiledLocation): void => {
+        // Add a proxy to the destination collection add and delete functions, to replace the target function pointers
+        // with the target id when adding or deleting destinations at runtime.
+        location.destinations.add = location.destinations.add.proxy(this.addDestination, this._game);
+
+        Object.defineProperty(location, 'activeDestinations', {
+            get: function () {
+                return location.destinations.filter(e => {
+                    return !e.inactive;
+                });
+            }
+        });
+    }
+
+    processDestinations = (game: IGame) => {
+        if (game.previousLocation?.destinations.length) {
+            // Remove the isPreviousLocation and visited markers from the previous location's destinations.
+            game.previousLocation.destinations.forEach((d: any) => {
+                delete d.isPreviousLocation;
+                delete d.visited;
+            });
+        }
+
+        if (game.currentLocation.destinations.length) {
+            // 1. Mark the previous location in the current location's destinations to allow
+            // the player to more easily backtrack his last step.
+            // 2. Mark the destination as visited when the player has already visited the location it leads to.
+            // 3. Check if the user has the key for one or more barriers at this location, and add the key actions
+            // if that is the case.
+            game.currentLocation.destinations.forEach((d: any) => {
+                if (d.target == game.previousLocation?.id) {
+                    d.isPreviousLocation = true;
+                }
+
+                const targetLocation = game.locations[d.target];
+                const visitedRule = this._rules.exploration?.hasVisitedLocation;
+
+                if (targetLocation && visitedRule) {
+                    d.visited = visitedRule(game, targetLocation);
+                } else {
+                    d.visited = targetLocation?.hasVisited;
+                }
+
+                this.addKeyAction(game, d);
+            });
+        }
+    }
+
+    private readonly setupLocations = () => {
+        Object.values(this._game.locations).forEach(l => {
+            const compiledLocation = <ICompiledLocation>l;
+            this.initDestinations(compiledLocation);
+            let selector = compiledLocation.descriptionSelector;
+
+            Object.defineProperty(compiledLocation, 'descriptionSelector', {
+                enumerable: true,
+                get: () => selector,
+                set: (value) => {
+                    selector = value;
+                    this.selectLocationDescription(this._game);
+                }
+            });
+        });
+
+        this.addLocationGet(this._game.locations);
+    }
+
+    private readonly addLocationGet = (locations: Record<string, ICompiledLocation>) => {
+        Object.defineProperty(locations, 'get', {
+            enumerable: false,
+            value: function (id?: string | (() => ILocation) | ICompiledLocation): ICompiledLocation {
+                if (!id) {
+                    return undefined;
+                }
+
+                if (typeof id === 'string') {
+                    return locations[id.toLowerCase()];
+                } else if (typeof id === 'function') {
+                    return locations[id.name.toLowerCase()];
+                } else {
+                    return locations[id.id]
+                }
+            }
+        });
+    }
+
+    private readonly switchLocation = (game: IGame, location: string | (() => ILocation)): boolean => {
+        let presentLocation: ICompiledLocation;
+
+        // If no location is specified, go to the previous location.
+        if (!location) {
+            const tempLocation = game.currentLocation;
+            game.currentLocation = game.previousLocation;
+            game.previousLocation = tempLocation;
+            presentLocation = game.currentLocation;
+        }
+        // If currently at a location, make this the previous location.
+        else if (game.currentLocation) {
+            game.previousLocation = game.currentLocation;
+        }
+
+        if (!location && !presentLocation) {
+            return false;
+        }
+
+        const key = getId(location) ?? presentLocation.id;
+        game.currentLocation = game.locations.get(key);
+        return true;
+    }
+
+    private readonly markCurrentLocationAsVisited = (game: IGame): void => {
+        if (!game.currentLocation.hasVisited) {
+            game.currentLocation.hasVisited = true;
+            game.statistics.LocationsVisited = game.statistics.LocationsVisited || 0;
+            game.statistics.LocationsVisited += 1;
+        }
+    }
+
+    private readonly initTrade = (game: IGame): void => {
+        if (game.currentLocation.trade?.length > 0) {
+            game.currentLocation.trade.forEach(t => {
+                if (!game.currentLocation.actions.find(([k, v]) => v.actionType === ActionType.Trade && k === t.id)) {
+                    game.currentLocation.actions.add([t.id, {
+                        text: t.name,
+                        actionType: ActionType.Trade,
+                        execute: 'trade'
+                    }]);
+                }
+            });
+        }
+    }
+
+    private readonly addDestination = (originalScope: any, originalFunction: Function, destination: IDestination, game: IGame): void => {
+        setDestination(destination);
+        this.addKeyAction(game, destination);
+        originalFunction.call(originalScope, destination);
+    }
+
+    private readonly playEvents = (game: IGame, eventProperty: string): void => {
+        if (!game.currentLocation?.[eventProperty]) {
+            return;
+        }
+
+        // Keep a reference to the location being processed. When the location is changed in the
+        // event, we want to still update the events in the originating location.
+        const location = game.currentLocation;
+        const events = [...location[eventProperty]];
+
+        events.forEach(e => {
+            const result = e[1]?.(game);
+
+            if (!result) {
+                location[eventProperty].delete(e);
+            }
+        });
+    }
+
+    private readonly processTextFeatures = (location: ICompiledLocation): void => {
+        if (!location.description) {
+            return;
+        }
+
+        const htmlDoc = parseHtmlDocumentFromString(location.description);
+        const featureNodes = <HTMLCollectionOf<HTMLElement>>htmlDoc.getElementsByTagName('feature');
+
+        for (const element of featureNodes) {
+            const feature = getBasicFeatureData(location, element);
+
+            // If the feature is not present in code, clean the node html as the feature is either
+            // not yet added (the feature tag is a placeholder for a feature added at runtime) or it
+            // was deleted. Clean the node html to not show the feature text in case it was deleted.
+            if (!feature) {
+                element.innerHTML = '';
+            } else {
+                feature.description = element.innerHTML || feature.description;
+                element.innerHTML = addHtmlSpaces(feature.description);
+            }
+        }
+
+        location.description = htmlDoc.body.innerHTML;
+    }
+
+
+    private readonly selectLocationDescription = (game: IGame): boolean => {
+        let selector = null;
+
+        if (!game.currentLocation.descriptions) {
+            game.currentLocation.description = null;
+            return false;
+        }
+
+        let description: string;
+        const defaultDescription = game.currentLocation.descriptions['default'] || game.currentLocation.descriptions[Object.keys(game.currentLocation.descriptions)[0]];
+
+        // A location can specify how to select the proper selection using a descriptor selection function. If it is not specified,
+        // use the default description selector function.
+        if (game.currentLocation.descriptionSelector) {
+            selector = typeof game.currentLocation.descriptionSelector == 'function' ? game.currentLocation.descriptionSelector(game) : game.currentLocation.descriptionSelector;
+            description = game.currentLocation.descriptions[selector];
+        }
+
+        if (!description && this._rules.exploration?.descriptionSelector && (selector = this._rules.exploration.descriptionSelector(game))) {
+            description = game.currentLocation.descriptions[selector];
+        }
+
+        description ??= defaultDescription;
+        game.currentLocation.description = description;
+        return true;
+    }
+
+    private readonly addKeyAction = (game: IGame, destination: IDestination) => {
+        destination.barriers?.forEach(([_, b]) => {
+            if (b.key) {
+                const key = typeof b.key === 'function' ?
+                    b.key()
+                    : <IKey>this._definitions.items.get(b.key)();
+
+                let existingAction = null;
+
+                if (b.actions) {
+                    b.actions.forEach(([k, v]) => {
+                        if (k === key.id) {
+                            existingAction = v;
+                        }
+                    });
+                } else {
+                    b.actions = [];
+                }
+
+                if (existingAction) {
+                    b.actions.splice(b.actions.indexOf(existingAction), 1);
+                }
+
+                let partyKey = null;
+
+                game.party.characters.forEach(c => {
+                    partyKey = partyKey ?? c.items.get(key.id);
+                });
+
+                const barrierKey = <IKey>(partyKey || game.currentLocation.items.get(key.id));
+
+                if (barrierKey) {
+                    b.actions.push([barrierKey.id, barrierKey.open]);
+                }
+            }
+        });
+    }
+
+    private getActionIndex = (game: IGame, action: [string, IAction]): { type: ActionType, index: number } => {
+        let index = -1;
+        let type = ActionType.Regular;
+
+        game.currentLocation.actions.forEach(([k, v], i) => {
+            if (k === action[0]) {
+                index = i;
+                type = ActionType.Regular;
+            }
+        });
+
+        if (index == -1) {
+            game.currentLocation.combatActions.forEach(([k, v], i) => {
+                if (k === action[0]) {
+                    index = i;
+                    type = ActionType.Combat;
+                }
+            });
+        }
+
+        return {type, index};
+    }
+}