@strixit/storyscript 0.0.0-stage → 1.0.0

package/src/Engine/ServiceFactory.ts

@@ -0,0 +1,167 @@
+import {
+    AutoplayService,
+    CharacterService,
+    CombatService,
+    CombinationService,
+    CommandService,
+    ConversationService,
+    DataSerializer,
+    DataService,
+    DataSynchronizer,
+    GameService,
+    HelperService,
+    ItemService,
+    LocalStorageService,
+    LocationService,
+    SoundService,
+    TradeService
+} from './Services/index';
+
+import {
+    gameEvents,
+    IAutoplayService,
+    ICharacterService,
+    ICombatService,
+    ICombinationService,
+    ICommandService,
+    IConversationService,
+    IDataSerializer,
+    IDataService,
+    IDataSynchronizer,
+    IDefinitions,
+    IGame,
+    IGameService,
+    IInterfaceTexts,
+    IItemService,
+    IRules,
+    ISoundService,
+    ITradeService
+} from 'storyScript';
+
+export class ServiceFactory {
+    private static _instance: ServiceFactory;
+    private static _initialized: boolean = false;
+    private readonly _texts: IInterfaceTexts;
+    private readonly _rules: IRules;
+    private readonly _definitions: IDefinitions
+    private readonly _registeredEntities: Record<string, Record<string, any>>;
+    private readonly _dataSerializer: IDataSerializer;
+    private readonly _dataSynchronizer: IDataSynchronizer;
+    private readonly _dataService: IDataService;
+    private _game: IGame = <IGame>{};
+    private _gameService: IGameService;
+    private _conversationService: IConversationService;
+    private _combinationService: ICombinationService;
+    private _combatService: ICombatService;
+    private _soundService: ISoundService;
+    private _characterService: ICharacterService;
+    private _itemService: IItemService;
+    private _tradeService: ITradeService;
+    private _autoPlayService: IAutoplayService;
+    private _commandService: ICommandService;
+
+    constructor(
+        nameSpace: string,
+        definitions: IDefinitions,
+        registeredEntities: Record<string, Record<string, any>>,
+        rules: IRules,
+        texts: IInterfaceTexts
+    ) {
+        this._texts = texts;
+        this._rules = rules;
+        this._definitions = definitions;
+        this._registeredEntities = registeredEntities;
+        const localStorageService = new LocalStorageService();
+        this._dataSerializer = new DataSerializer(this._registeredEntities);
+        this._dataSynchronizer = new DataSynchronizer(this._registeredEntities);
+        this._dataService = new DataService(localStorageService, this._dataSerializer, this._dataSynchronizer, this._rules, nameSpace);
+        ServiceFactory._instance = this;
+    }
+
+    get AvailableLocations() {
+        return Object.values(this._registeredEntities.locations).map(l => {
+            return {id: l.id, name: l.name}
+        });
+    };
+
+    static readonly GetInstance = () => ServiceFactory._instance;
+
+    /**
+     * Initialize the game object and the services. Pass in a game object when it should be controlled
+     * by the UI framework. Vue needs this.
+     * @param game The game object.
+     */
+    init = (game?: IGame) => {
+        this._game = game ?? <IGame>{};
+        this._itemService = new ItemService(this._game, this._rules, this._texts);
+        this._tradeService = new TradeService(this._itemService, this._game, this._rules, this._texts, this._definitions);
+        this._conversationService = new ConversationService(this._game, this._rules);
+        this._combatService = new CombatService(this._game, this._rules, this._texts);
+
+        this._soundService = new SoundService(this._game, this._rules);
+        this._characterService = new CharacterService(this._dataService, this._game, this._rules);
+        const locationService = new LocationService(this._definitions, this._rules, this._game, gameEvents);
+        this._combinationService = new CombinationService(this._game, this._rules, this._texts);
+        this._autoPlayService = new AutoplayService(this._game, this._rules);
+        this._commandService = new CommandService(locationService, this._conversationService, this._tradeService, this._combinationService, this._dataService, this._game);
+
+        this._gameService = new GameService
+        (
+            this._dataService,
+            locationService,
+            this._characterService,
+            this._combinationService,
+            this._soundService,
+            this._rules,
+            this._game,
+            this._texts
+        );
+
+        gameEvents.setGame(this._game);
+        this._game.autoplay = this._autoPlayService;
+        this._game.commands = this._commandService;
+        this._game.helpers = new HelperService(this._game, this._definitions);
+
+        ServiceFactory._initialized = true;
+    }
+
+    GetGame = (): IGame => this.Get(this._game);
+
+    GetRules = (): IRules => this.Get(this._rules);
+
+    GetTexts = (): IInterfaceTexts => this.Get(this._texts);
+
+    GetGameService = (): IGameService => this.Get(this._gameService);
+
+    GetTradeService = (): ITradeService => this.Get(this._tradeService);
+
+    GetConversationService = (): IConversationService => this.Get(this._conversationService);
+
+    GetCharacterService = (): ICharacterService => this.Get(this._characterService);
+
+    GetCombinationService = (): ICombinationService => this.Get(this._combinationService);
+
+    GetDataService = (): IDataService => this.Get(this._dataService);
+
+    GetDataSerializer = (): IDataSerializer => this.Get(this._dataSerializer);
+
+    GetDataSynchronizer = (): IDataSynchronizer => this.Get(this._dataSynchronizer);
+
+    GetCombatService = (): ICombatService => this.Get(this._combatService);
+
+    GetSoundService = (): ISoundService => this.Get(this._soundService);
+
+    GetItemService = (): IItemService => this.Get(this._itemService);
+
+    GetAutoplayService = (): IAutoplayService => this.Get(this._autoPlayService);
+
+    GetCommandService = (): ICommandService => this.Get(this._commandService);
+
+    private Get<T>(service: T): T {
+        if (!ServiceFactory._initialized) {
+            throw new Error('ServiceFactory is not initialized!');
+        }
+
+        return service;
+    }
+}

package/src/Engine/Services/AutoplayService.ts

@@ -0,0 +1,59 @@
+import {IAutoplayService, IAutoplayStep, IDemoMode, IGame, IRules}from 'storyScript';
+
+export class AutoplayService implements IAutoplayService {
+
+    private _demoTimer: NodeJS.Timeout;
+
+    constructor(private _game: IGame, private _rules: IRules) {
+    }
+
+    start = (steps: IAutoplayStep[], callback?: () => void): void => {
+        this._game.autoplaying = true;
+        this.runAutoplayStep(steps, 0, callback);
+    }
+
+    stop = (): void => {
+        this._game.autoplaying = false;
+        clearTimeout(this._demoTimer);
+    }
+
+    startDemoMode = (demoConfig: IDemoMode, restartCallback: () => void): void => {
+        this._game.autoplaying = false;
+
+        this._demoTimer = setTimeout(() => {
+            this._game.autoplaying = true;
+            const delay = this._rules.setup?.titleScreen?.transitionDelay ?? 0;
+            const transitionDelay = (typeof delay === 'number' ? delay : parseFloat(delay)) * 1000;
+
+            const delayedCallback = () => {
+                setTimeout(() => {
+                    restartCallback();
+                }, transitionDelay);
+            }
+
+            this._demoTimer = setTimeout(() => {
+                this.runAutoplayStep(demoConfig.steps, 0, delayedCallback);
+            }, transitionDelay);
+        }, demoConfig.startDelay)
+    }
+
+    private runAutoplayStep = (steps: IAutoplayStep[], stepNumber: number, restartCallback: () => void): void => {
+        if (stepNumber >= steps.length) {
+            this._demoTimer = setTimeout(() => {
+                this._game.autoplaying = false;
+                clearTimeout(this._demoTimer);
+                restartCallback();
+            }, steps[stepNumber - 1].delay);
+
+            return;
+        }
+
+        const currentStep = steps[stepNumber];
+
+        this._demoTimer = setTimeout(() => {
+            currentStep.action(this._game);
+            stepNumber++;
+            this.runAutoplayStep(steps, stepNumber, restartCallback);
+        }, currentStep.delay);
+    }
+}

package/src/Engine/Services/CharacterService.ts

@@ -0,0 +1,291 @@
+import {
+    GameState,
+    ICharacter,
+    ICharacterService,
+    ICreateCharacter,
+    ICreateCharacterAttribute,
+    ICreateCharacterAttributeEntry,
+    ICreateCharacterStep,
+    IDataService,
+    IGame,
+    IItem,
+    IQuest,
+    IRules
+} from 'storyScript';
+import {getEquipmentType} from '../utilityFunctions';
+
+export class CharacterService implements ICharacterService {
+    constructor(private readonly _dataService: IDataService, private readonly _game: IGame, private readonly _rules: IRules) {
+    }
+
+    getSheetAttributes = (): string[] => this._rules.character.getSheetAttributes?.() || [];
+
+    setupCharacter = (): ICreateCharacter => {
+        const sheet = (this._rules.character.getCreateCharacterSheet?.()) || {steps: []};
+        this.prepareSheet(sheet);
+        this._game.createCharacterSheet = sheet;
+        return sheet;
+    }
+
+    limitSheetInput = (value: number, attribute: ICreateCharacterAttribute, entry: ICreateCharacterAttributeEntry): void => {
+        if (!isNaN(value)) {
+            let totalAssigned = 0;
+
+            attribute.entries.forEach((innerEntry, index) => {
+                if (index !== attribute.entries.indexOf(entry)) {
+                    totalAssigned += <number>innerEntry.value || 1;
+                }
+            });
+
+            if (totalAssigned + value > attribute.numberOfPointsToDistribute) {
+                value = attribute.numberOfPointsToDistribute - totalAssigned;
+            }
+
+            entry.value = value;
+
+            if (entry.value > entry.max) {
+                entry.value = entry.max;
+            } else if (entry.value < entry.min) {
+                entry.value = entry.min;
+            }
+        } else {
+            entry.value = entry.min;
+        }
+    }
+
+    distributionDone = (sheet: ICreateCharacter, step?: ICreateCharacterStep): boolean => {
+        let done = true;
+
+        if (step) {
+            done = this.checkStep(step);
+        } else if (sheet?.steps) {
+            sheet.steps.forEach(step => {
+                done = this.checkStep(step);
+            });
+        }
+
+        return done;
+    }
+
+    createCharacter = (game: IGame, characterData: ICreateCharacter): ICharacter => {
+        let character: ICharacter;
+
+        if (this._rules.character.createCharacter) {
+
+            character = this._rules.character.createCharacter(game, characterData);
+            character.currentHitpoints = character.hitpoints;
+            this.processDefaultSettings(character, characterData);
+        } else {
+            // Set a placeholder character to keep the game logic functional when no character is used.
+            character = <any>{
+                name: null
+            };
+        }
+
+        return character;
+    }
+
+    setupLevelUp = (): ICreateCharacter => {
+        const sheet = this._rules.character.getLevelUpSheet?.();
+
+        if (sheet) {
+            this.prepareSheet(sheet);
+            this._game.createCharacterSheet = sheet;
+        }
+
+        return sheet;
+    }
+
+    levelUp = (character: ICharacter): ICharacter => {
+        const sheet = this._game.createCharacterSheet;
+
+        if (this._rules.character.levelUp?.(character, sheet)) {
+            this.processDefaultSettings(character, sheet);
+            this._dataService.saveGame(this._game);
+        }
+
+        this._game.state = GameState.Play;
+        return character;
+    }
+
+    isSlotUsed = (character: ICharacter, slot: string): boolean => {
+        if (character?.equipment) {
+            if (character.equipment[slot] === undefined) {
+                return false;
+            }
+
+            return this._rules.character?.isSlotUsed ? this._rules.character.isSlotUsed(character, slot) : true;
+        }
+
+        return false;
+    }
+
+    questStatus = (quest: IQuest): string => typeof quest.status === 'function' ? (<any>quest).status(this._game, quest, quest.checkDone(this._game, quest)) : quest.status;
+
+    checkEquipment = (): void => {
+        this._game.party.characters.forEach(c => {
+            if (c.equipment) {
+                Object.keys(c.equipment).forEach(k => {
+                    const item = <IItem>c.equipment[k];
+
+                    if (!item?.equipmentType) {
+                        return;
+                    }
+
+                    const itemType = Array.isArray(item.equipmentType) ? item.equipmentType : [item.equipmentType];
+                    let valid = true;
+
+                    if (!item.usesMultipleSlots) {
+                        valid = itemType.find(t => getEquipmentType(t) === k) !== undefined;
+                    } else {
+                        for (const i in itemType) {
+                            const slot = getEquipmentType(itemType[i]);
+                            const slotItem = c.equipment[slot];
+
+                            if (slotItem && (slotItem === item || slotItem.id === item.id)) {
+                                // When restoring data, a single item occupying multiple slots will be duplicated,
+                                // so each slot contains a separate item of the same kind. Remove the duplicates here.
+                                c.equipment[slot] = item;
+                            } else {
+                                valid = false;
+                            }
+                        }
+                    }
+
+                    if (!valid) {
+                        c.equipment[k] = null;
+                        c.items.push(item);
+                    }
+                });
+            }
+        })
+    }
+
+    private readonly prepareSheet = (sheet: ICreateCharacter): void => {
+        if (sheet.steps.length == 0) {
+            return;
+        }
+
+        sheet.currentStep = 0;
+
+        if (sheet.steps[0].questions?.[0]?.entries.length > 0) {
+            sheet.steps[0].questions[0].selectedEntry = sheet.steps[0].questions[0].entries[0];
+        }
+
+        if (sheet.steps[0].initStep) {
+            sheet.steps[0].initStep(this._game.party, sheet, sheet.steps[0], undefined);
+        }
+
+        this.setFinish(sheet);
+
+        sheet.nextStep = (data: ICreateCharacter, next: boolean) => {
+            if (next !== undefined && next !== null && !next) {
+                this.setFinish(data);
+                return;
+            }
+
+            const selector = data.steps[data.currentStep].nextStepSelector;
+            const previousStep = data.currentStep;
+
+            if (selector) {
+                data.currentStep = typeof selector === 'function' ? (<any>selector)(this._game.party, data, data.steps[data.currentStep]) : selector;
+            } else {
+                data.currentStep++;
+            }
+
+            const currentStep = data.steps[data.currentStep];
+
+            if (currentStep.initStep) {
+                currentStep.initStep(this._game.party, data, currentStep, previousStep);
+            }
+
+            if (currentStep.attributes) {
+                currentStep.attributes.forEach(attr => {
+                    attr.entries.forEach(entry => {
+                        if (entry.min) {
+                            entry.value = entry.min;
+                        }
+                    });
+                });
+            }
+
+            if (currentStep.questions) {
+                currentStep.questions.forEach(question => {
+                    if (question.entries?.length) {
+                        question.selectedEntry = question.entries[0];
+                    }
+                });
+            }
+        };
+    }
+
+    private readonly checkStep = (step: ICreateCharacterStep): boolean => {
+        let done = true;
+
+        if (step.attributes) {
+            let totalAssignedAll = 0;
+
+            step.attributes.forEach(attr => {
+                let totalAssigned = 0;
+                let textChoicesFilled = 0;
+
+                attr.entries.forEach((entry) => {
+                    if (!entry.max) {
+                        if (entry.value) {
+                            textChoicesFilled += 1;
+                        }
+                    } else {
+                        totalAssigned += <number>entry.value || 0;
+                    }
+                });
+
+                totalAssignedAll += totalAssigned;
+                done = totalAssigned === attr.numberOfPointsToDistribute || textChoicesFilled === attr.entries.length;
+            });
+
+            if (step.numberOfAttributePoints) {
+                done = totalAssignedAll === step.numberOfAttributePoints;
+            }
+        }
+
+        return done;
+    }
+
+    private readonly processDefaultSettings = (character: ICharacter, characterData: ICreateCharacter): void => {
+        if (!characterData.steps) {
+            return;
+        }
+
+        characterData.steps.forEach(step => {
+            if (step.attributes) {
+                step.attributes.forEach(attribute => {
+                    attribute.entries.forEach(entry => {
+                        if (character.hasOwnProperty(entry.attribute)) {
+                            character[entry.attribute] = entry.value;
+                        }
+                    });
+                });
+            }
+        });
+
+        characterData.steps.forEach(step => {
+            if (step.questions) {
+                step.questions.forEach(question => {
+                    if (question.selectedEntry && character.hasOwnProperty(question.selectedEntry.value)) {
+                        character[question.selectedEntry.value] += question.selectedEntry.bonus;
+                    }
+                });
+            }
+        });
+    }
+
+    private readonly setFinish = (data: ICreateCharacter): void => {
+        if (data?.steps) {
+            const activeStep = data.steps[data.currentStep];
+
+            if (activeStep.questions) {
+                activeStep.finish = activeStep.questions.filter(q => q.selectedEntry.finish).length > 0;
+            }
+        }
+    }
+}