@strixit/storyscript 0.0.0-stage → 1.0.0

package/src/Engine/Interfaces/services/autoplayService.ts

@@ -0,0 +1,23 @@
+import {IAutoplayStep, IDemoMode} from 'storyScript';
+
+export interface IAutoplayService {
+
+    /**
+     * Start autoplay using the steps specified.
+     * @param steps The steps to autoplay.
+     * @param callback If needed, call a function when autoplay completes.
+     */
+    start: (steps: IAutoplayStep[], callback?: () => void) => void;
+
+    /**
+     * Stops autoplay in progress.
+     */
+    stop: () => void;
+
+    /**
+     * Start autoplaying the game in demo mode using the configuration specified.
+     * @param demoConfig The demo mode configuration.
+     * @param restartCallback Call a function to restart the demo when it completes.
+     */
+    startDemoMode: (demoConfig: IDemoMode, restartCallback: () => void) => void;
+}

package/src/Engine/Interfaces/services/characterService.ts

@@ -0,0 +1,35 @@
+import {
+    ICharacter,
+    ICreateCharacter,
+    ICreateCharacterAttribute,
+    ICreateCharacterAttributeEntry,
+    ICreateCharacterStep,
+    IGame,
+    IQuest
+} from 'storyScript';
+
+export interface ICharacterService {
+    getSheetAttributes(): string[];
+
+    setupCharacter(): ICreateCharacter;
+
+    setupLevelUp(): ICreateCharacter;
+
+    createCharacter(game: IGame, characterData: any): ICharacter;
+
+    levelUp(character: ICharacter): ICharacter;
+
+    limitSheetInput(value: number, attribute: ICreateCharacterAttribute, entry: ICreateCharacterAttributeEntry): void;
+
+    distributionDone(sheet: ICreateCharacter, step: ICreateCharacterStep): boolean;
+
+    isSlotUsed(character: ICharacter, slot: string): boolean;
+
+    questStatus(quest: IQuest): string;
+
+    /**
+     * Check whether all the equipment on the characters is in valid equipment slots. The equipment type may change
+     * during editing, leaving items previously equipped in invalid slots.
+     */
+    checkEquipment(): void;
+}

package/src/Engine/Interfaces/services/combatService.ts

@@ -0,0 +1,30 @@
+import {ICharacter, ICombatSetup, ICombatTurn, IEnemy, IItem} from 'storyScript';
+
+export interface ICombatService {
+    /**
+     * The function executed when combat is started.
+     */
+    initCombat(): void;
+
+    /**
+     * The function executed when the player attacks an enemy.
+     * @param combatRound The setup for this combat round
+     * @param retaliate True if the enemy can retaliate (default), false otherwise
+     */
+    fight(combatRound: ICombatSetup<ICombatTurn>, retaliate?: boolean): Promise<void> | void;
+
+    /**
+     * Gets a value indicating whether the item is selectable. True when selectable, false otherwise.
+     * @param item The item to check.
+     */
+    isSelectable(item: IItem): boolean;
+
+    /**
+     * Gets a value indicating whether an item can target the proposed target. True when so, false
+     * otherwise.
+     * @param item The item to check the target for.
+     * @param target The proposed target.
+     * @param character The character whom the item belongs to.
+     */
+    canTarget(item: IItem, target: IEnemy | ICharacter, character: ICharacter): boolean;
+}

package/src/Engine/Interfaces/services/combinationService.ts

@@ -0,0 +1,10 @@
+import { ICombinationAction } from '../combinations/combinationAction';
+import { ICombinable } from '../combinations/combinable';
+import { ICombineResult } from '../combinations/combineResult';
+
+export interface ICombinationService {
+    combinationActions: ICombinationAction[];
+    getCombineClass(tool: ICombinable): string;
+    setActiveCombination(combination: ICombinationAction): void;
+    tryCombination(target: ICombinable): ICombineResult;
+}

package/src/Engine/Interfaces/services/commandService.ts

@@ -0,0 +1,75 @@
+import {IAction, IBarrier, IBarrierAction, IDestination, IFeature, IItem, ILocation, IPerson} from 'storyScript';
+
+export interface ICommandService {
+    /**
+     * Go to the location specified. If you set the saveProgress flag to false, the game progress will NOT be saved.
+     * @param location The location to travel to.
+     * @param saveProgress Omit if you want to save the game progress, set to false if you don't want to save.
+     */
+    go: (location: (() => ILocation) | string, saveProgress?: boolean) => void;
+
+    /**
+     * Talk to the specified person at the current location.
+     * @param person The person to talk to
+     */
+    talk: (person: () => IPerson) => void;
+
+    /**
+     * Answer to the specified node. If no reply is specified, the default reply will be used.
+     * @param node
+     * @param reply
+     */
+    answer: (node: string, reply?: string) => void;
+
+    /**
+     * Set the specified combination as the active one.
+     * @param combination The combination to set as the active one.
+     */
+    selectCombination: (combination: string) => void;
+
+    /**
+     * Set the specified feature as the currently active tool.
+     * @param feature The feature to make the currently active tool.
+     */
+    setTool: (feature: (() => IFeature) | string) => void;
+
+    /**
+     * Try the combination specified on the target, optionally using the tool.
+     * @param combination The combination to try.
+     * @param target The target to try the combination on.
+     * @param tool The tool to use in the combination.
+     */
+    combine: (combination: string, target: (() => IFeature) | string, tool?: (() => IFeature) | string) => void;
+
+    /**
+     * Use the action specified at the current location.
+     * @param action The action to use
+     */
+    useAction: (action: string | [string, IAction]) => void;
+
+    /**
+     * Use the barrier action specified on the barrier and destination at the current location.
+     * @param destination The destination the barrier is on
+     * @param barrier The barrier to use the action on
+     * @param action The barrier action to use
+     */
+    useBarrierAction: (destination: string | IDestination, barrier: string | [string, IBarrier], action: string | [string, IBarrierAction]) => void;
+
+    /**
+     * Trade with the specified person or object at the current location.
+     * @param trade The person or object to trade with.
+     */
+    trade: (trade: string | (() => IPerson)) => void;
+
+    /**
+     * Buy the specified item from the current trader
+     * @param item The item to buy
+     */
+    buy: (item: (() => IItem)) => void;
+
+    /**
+     * Sell the specified item to the current trader
+     * @param item The item to sell
+     */
+    sell: (item: (() => IItem)) => void;
+}

package/src/Engine/Interfaces/services/conversationService.ts

@@ -0,0 +1,7 @@
+import {IConversationNode, IConversationReply, IPerson} from 'storyScript';
+
+export interface IConversationService {
+    talk(person: IPerson): void;
+
+    answer(node: IConversationNode, reply: IConversationReply): void;
+}

package/src/Engine/Interfaces/services/dataSerializer.ts

@@ -0,0 +1,4 @@
+export interface IDataSerializer {
+    createSerializableClone(values: any, clone?: any): any;
+    restoreObjects (loaded: any): any;
+}

package/src/Engine/Interfaces/services/dataService.ts

@@ -0,0 +1,39 @@
+import {IGame} from 'storyScript';
+
+export interface IDataService {
+    /**
+     * Save the specified object using the save key.
+     * @param key The key to use to identity this saved state.
+     * @param value The value to save.
+     */
+    save<T>(key: string, value: T): void;
+
+    /**
+     * Loads an object from the specified save key.
+     * @param key The key to use to identity the saved state.
+     */
+    load<T>(key: string): T;
+
+    /**
+     * Remove an object from storage using the save key.
+     * @param key The key to use to identity the saved state.
+     */
+    remove(key: string): void;
+
+    /**
+     * Save the game state, using the default state save key or the one supplied.
+     * @param game The game to save
+     * @param name The name of the save game to create.
+     */
+    saveGame(game: IGame, name?: string): void;
+
+    /**
+     * Gets all the keys of the saved states for the game.
+     */
+    getSaveKeys(): string[];
+
+    /**
+     * True if there is a saved game state for the game, false otherwise.
+     */
+    hasGameState(): boolean;
+}

package/src/Engine/Interfaces/services/dataSynchronizer.ts

@@ -0,0 +1,9 @@
+export interface IDataSynchronizer {
+    synchronizeEntityData (
+        entity: any, 
+        pristineEntity?: any,
+        parentEntity?: any,
+        pristineParentEntity?: any,
+        parentProperty?: string
+    ): void;
+}

package/src/Engine/Interfaces/services/gameService.ts

@@ -0,0 +1,17 @@
+import {IDemoMode, IGame, PlayState} from 'storyScript';
+
+export interface IGameService {
+    init(): void;
+
+    initDemo(demoConfig: IDemoMode): void;
+
+    startNewGame(characterData: any): void;
+
+    reset(): void;
+
+    restart(skipIntro?: boolean): void;
+
+    loadGame(name: string): void;
+
+    watchPlayState(callBack: (game: IGame, newPlayState: PlayState, oldPlayState: PlayState) => void): void;
+}

package/src/Engine/Interfaces/services/index.ts

@@ -0,0 +1,33 @@
+import type  { IAutoplayService } from './autoplayService';
+import type  { ICharacterService } from './characterService';
+import type  { ICombatService } from './combatService';
+import type  { ICombinationService } from './combinationService';
+import type  { ICommandService } from './commandService';
+import type  { IConversationService } from './conversationService';
+import type  { IDataSerializer } from './dataSerializer';
+import type  { IDataService } from './dataService';
+import type  { IDataSynchronizer } from './dataSynchronizer';
+import type  { IGameService } from './gameService';
+import type  { IItemService } from './itemService';
+import type  { ILocalStorageService } from './localStorageService';
+import type  { ILocationService } from './locationService';
+import type  { ISoundService } from './soundService';
+import type  { ITradeService } from './tradeService';
+
+export type {
+    IAutoplayService,
+    ICharacterService,
+    ICombatService,
+    ICombinationService,
+    ICommandService,
+    IConversationService,
+    IDataSerializer,
+    IDataService,
+    IDataSynchronizer,
+    IGameService,
+    IItemService,
+    ILocalStorageService,
+    ILocationService,
+    ISoundService,
+    ITradeService
+}

package/src/Engine/Interfaces/services/itemService.ts

@@ -0,0 +1,25 @@
+import {ICharacter, IEnemy, IGroupableItem, IItem} from 'storyScript';
+
+export interface IItemService {
+    getItemName(item: IItem): string;
+
+    pickupItem(character: ICharacter, item: IItem): boolean;
+
+    canGroupItem(character: ICharacter, group: IGroupableItem<IItem>, item: IGroupableItem<IItem>): boolean;
+
+    groupItem(character: ICharacter, group: IGroupableItem<IItem>, item: IGroupableItem<IItem>): boolean;
+
+    splitItemGroup(character: ICharacter, item: IGroupableItem<IItem>): void;
+
+    useItem(character: ICharacter, item: IItem, target?: IEnemy): Promise<void> | void;
+
+    isEquippable(item: IItem, character?: ICharacter): boolean;
+
+    equipItem(character: ICharacter, item: IItem): boolean;
+
+    unequipItem(character: ICharacter, item: IItem): boolean;
+
+    canDrop(item: IItem): boolean
+
+    dropItem(character: ICharacter, item: IItem): void;
+}

package/src/Engine/Interfaces/services/localStorageService.ts

@@ -0,0 +1,6 @@
+export interface ILocalStorageService {
+    get(key: string): any;
+    set(key: string, value: any): void;
+    remove(key: string): void;
+    getKeys(prefix: string): string[];
+}

package/src/Engine/Interfaces/services/locationService.ts

@@ -0,0 +1,13 @@
+import {IAction, IGame, ILocation} from 'storyScript';
+
+export interface ILocationService {
+    init(): void;
+
+    processDestinations(game: IGame): void;
+
+    loadLocationDescriptions(game: IGame): void;
+
+    changeLocation(location: string | (() => ILocation), travel: boolean, game: IGame): void;
+
+    executeAction(action: [string, IAction]): void;
+}

package/src/Engine/Interfaces/services/soundService.ts

@@ -0,0 +1,7 @@
+import {ISoundPlayer} from 'storyScript';
+
+export interface ISoundService {
+    getSounds(): ISoundPlayer;
+
+    getCurrentMusic(): string
+}

package/src/Engine/Interfaces/services/tradeService.ts

@@ -0,0 +1,15 @@
+import {ICharacter, IItem, IPerson, ITrade} from 'storyScript';
+
+export interface ITradeService {
+    trade(trade: IPerson | ITrade): void;
+
+    canPay(item: IItem, buyer: ITrade | ICharacter, seller: ITrade | ICharacter): boolean;
+
+    actualPrice(item: IItem, buyer: ITrade | ICharacter, seller: ITrade | ICharacter): number;
+
+    displayPrice(item: IItem, actualPrice: number): string;
+
+    buy(item: IItem, trade: ITrade): boolean;
+
+    sell(item: IItem, trade: ITrade): boolean;
+}

package/src/Engine/Interfaces/soundPlayer.ts

@@ -0,0 +1,30 @@
+export interface ISoundPlayer {
+    /**
+     * Start playing the currently selected music.
+     */
+    startMusic(): void;
+
+    /**
+     * Stop playing the current music.
+     */
+    stopMusic(): void;
+
+    /**
+     * Play a sound and optionally call a function when it completes. 
+     * @param fileName The sound to play.
+     * @param completeCallBack The function to call once the sound has played.
+     */
+    playSound(fileName: string, completeCallBack?: () => void): void;
+
+    /**
+     * Gets the game's sound queue, containing all the sounds that are being played or are yet
+     * to be played.
+     */
+    soundQueue: Map<number, { value: string, playing: boolean, completeCallBack?: () => void }>;
+
+    /**
+     * Contains a list of files that have been played before. This is used to play files embedded
+     * in audio elements that are set to autoplay only once.
+     */
+    playedAudio: string[];
+}

package/src/Engine/Interfaces/sprite.ts

@@ -0,0 +1,27 @@
+export interface Sprite {
+    /**
+     * The path to the animation's sprite sheet. It should be relative to the resources folder.
+     */
+    sheet: string;
+
+    /**
+     * The width of each animation frame in pixels.
+     */
+    width: number;
+
+    /**
+     * The height of each animation frame in pixels.
+     */
+    height: number;
+
+    /**
+     * The number of frames to display.
+     */
+    steps: number;
+
+    /**
+     * The speed at which to display one iteration through all the animation steps, in seconds. When
+     * omitted, a default of 1 second is used.
+     */
+    speed?: number;
+}

package/src/Engine/Interfaces/stateList.ts

@@ -0,0 +1,13 @@
+import { GameState } from "./enumerations/gameState";
+import { PlayState } from "./enumerations/playState";
+import { IGame } from "./game";
+import { ILocation } from "./location";
+
+export class StateList implements Record<string, StateListEntry>
+{
+    [key: string]: (GameState | PlayState | (() => ILocation) | ((game: IGame) => string) | string)[];  
+}
+
+export class StateListEntry extends Array<(GameState | PlayState | (() => ILocation) | ((game: IGame) => string) | string)>
+{
+}

package/src/Engine/Interfaces/statistics.ts

@@ -0,0 +1,14 @@
+/**
+ * Statistics tracked during the game.
+ */
+export interface IStatistics {
+    /**
+     * The number of enemies the player defeated.
+     */
+    enemiesDefeated?: number;
+
+    /** 
+     * The number of locations the player visited 
+     * */
+    LocationsVisited?: number;
+}

package/src/Engine/Interfaces/stock.ts

@@ -0,0 +1,46 @@
+import { IItem } from './item';
+import { IGame } from './game';
+
+/**
+ * The base properties to configure a collection of items available to buy or sell.
+ */
+export interface IStock {
+    /**
+     * The text for buying or selling the items as shown to the player.
+     */
+    text: string;
+
+    /**
+     * The text to show to the player when there are no items available for buying or selling.
+     */
+    emptyText: string;
+
+    /**
+     * A number or a function to generate a number dynamically that is used to modify the price of items to buy or sell.
+     * This can be used to e.g. give players a discount when they completed quests for the trader.
+     */
+    priceModifier?: number | ((game: IGame) => number);
+
+    /**
+     * This function can be used to limit the items selected from the list of items available for the trader or the items
+     * the player has that are available for trading. Return true if the item should be included in the list, false otherwise.
+     * @param game The game object
+     * @param item The item considered for selection.
+     */
+    itemSelector?(game: IGame, item: IItem): boolean;
+
+    /**
+     * The maximum number of items to select for buying or selling using the item selector.
+     */
+    maxItems?: number;
+
+    /**
+     * The items available for buying or selling.
+     */
+    items?: IItem[];
+
+    /**
+     * The text shown to ask the user to confirm the buy or sell.
+     */
+    confirmationText?: string;
+}

package/src/Engine/Interfaces/trade.ts

@@ -0,0 +1,72 @@
+import { IItem } from './item';
+import { IStock } from './stock';
+import { IGame } from './game';
+
+/**
+ * The base properties to configure a trader of or a container for items in the game.
+ */
+export interface ITrade {
+    /**
+     * The id of the trade, set at runtime.
+     */
+    id?: string;
+
+    /**
+     * The title as shown to the player in the trade dialog. If the trade is defined
+     * for a person, omitting the name will have StoryScript use the person name for
+     * the trade.
+     */
+    name?: string;
+
+    /**
+     * The description text of the trade as shown to the player.
+     */
+    text?: string;
+
+    /**
+     * The amount of credits the trader has in whatever credits are used in the game. When the trader is a person,
+     * the person's currency property will be used to set this value.
+     */
+    currency?: number;
+
+    /**
+     * True if the items for sale by a person are selected from the items the person is carrying, false if other
+     * items in the game are also included in the collection the items are to be selected from. The selection of
+     * items is done using the initCollection function.
+     */
+    ownItemsOnly?: boolean;
+
+    /**
+     * This function is executed when the player has bought an item from the trader.
+     * @param game The game object
+     * @param item The item bought
+     */
+    onBuy?(game: IGame, item: IItem): void;
+
+    /**
+     * This function is executed when the player has sold an item to the trader.
+     * @param game The game object
+     * @param item The item sold
+     */
+    onSell?(game: IGame, item: IItem): void;
+
+    /**
+     * The collection of items the trader will buy or that can be put in the store.
+     */
+    sell?: IStock;
+
+    /**
+     * The collection of items the trader has to offer or that can be taken from the store.
+     */
+    buy?: IStock & {
+          
+        /**
+         * This function runs when initiating trade and determines whether the list of items
+         * available for buying should be refreshed. Return true to refresh the lists, false 
+         * to keep them as they were.
+         * @param game The game object
+         * @param trade The trader for which to refresh the item lists
+         */
+        initCollection?(game: IGame, trade: ITrade): boolean;
+    };
+}