@strixit/storyscript 0.0.0-stage → 1.0.0

package/dist/src/Engine/Interfaces/rules/explorationRules.d.ts

@@ -0,0 +1,42 @@
+import { ICharacter, ICompiledLocation, IGame, IItem } from '../../..';
+export interface IExplorationRules {
+    /**
+     * When specified, this function will be called whenever the player enters a location.
+     * @param game The active game
+     * @param location The location the player enters
+     * @param previousLocationId The id of the location the player left traveling to the new location
+     * @param travel True if the player arrived by traveling, falsy otherwise. A player can get
+     * to a location without traveling when a game is loaded, for example.
+     */
+    enterLocation?(game: IGame, location: ICompiledLocation, previousLocationId?: string, travel?: boolean): void;
+    /**
+     * When specified, this function will be called whenever the player enters leaves a location.
+     * @param game The active game
+     * @param location The location the player leaves
+     * @param newLocationId The id of the location the player travels to
+     * @param travel True if the player leaves by traveling, falsy otherwise.
+     */
+    leaveLocation?(game: IGame, location: ICompiledLocation, newLocationId?: string, travel?: boolean): void;
+    /**
+     * When specified, this function will be called to determine whether a destination should
+     * be marked as visited.
+     * @param game The active game
+     * @param location The location the destination leads to
+     */
+    hasVisitedLocation?(game: IGame, location: ICompiledLocation): boolean;
+    /**
+     * Specify this function if you want to run custom logic to set the description selector when selecting the description when
+     * entering a location. Return the selector string. This is useful if you for example want to show different descriptions at
+     * night.
+     * @param game The active game
+     */
+    descriptionSelector?(game: IGame): string;
+    /**
+     * Use this hook to run code just before the player tries to use an item. Return true if the
+     * item's use function should be run after your code has run, false otherwise.
+     * @param game The active game
+     * @param character The character using the item
+     * @param item The item about to be used
+     */
+    onUseItem?(game: IGame, character: ICharacter, item: IItem): boolean;
+}

package/dist/src/Engine/Interfaces/rules/generalRules.d.ts

@@ -0,0 +1,62 @@
+import { GameState, ICharacter, IGame, IGroupableItem, IInterfaceTexts, IItem, ITrade, PlayState } from '../../..';
+export interface IGeneralRules {
+    /**
+     * This function is called when the party's score changes. Return true if you want to toggle the level-up
+     * status afterward.
+     * @param game The active game
+     * @param change The change in score.
+     */
+    scoreChange?(game: IGame, change: number): boolean;
+    /**
+     * This function is called when the game state changes.
+     * @param game The active game
+     * @param newGameState The new game state
+     * @param oldGameState The current game state
+     * */
+    gameStateChange?(game: IGame, newGameState: GameState, oldGameState: GameState): void;
+    /**
+     * This function is called when the play state changes.
+     * @param game The active game
+     * @param newPlayState The new play state
+     * @param oldPlayState The current play state
+     * */
+    playStateChange?(game: IGame, newPlayState: PlayState, oldPlayState: PlayState): void;
+    /**
+     * Use this function if you want to run additonal logic when determining the player's final score on game end.
+     * @param game The game about to be ended
+     */
+    determineFinalScore?(game: IGame): void;
+    /**
+     * Use this function to run logic before the game is saved. You can use this to change what is saved as part
+     * of a game.
+     * @param game The game about to be saved.
+     */
+    beforeSave?(game: IGame): void;
+    /**
+     * Use this function to run logic after the game is saved. You can use this to revert changes you made in
+     * beforeSave.
+     * @param game The game about to be saved.
+     */
+    afterSave?(game: IGame): void;
+    /**
+     * Use this function to override the standard way of naming items. This is useful if you want to use a
+     * different naming for items that are grouped.
+     * @param item The item to get the name for.
+     * @param texts The interface texts.
+     */
+    getItemName?(item: IItem, texts: IInterfaceTexts): string;
+    /**
+     * Use this function if you want to use special rules for grouping items.
+     * @param character The character grouping the items.
+     * @param group The item that is the parent for the group.
+     * @param item The item to add as a member to the parent.
+     */
+    canGroupItem?(character: ICharacter, group: IGroupableItem<IItem>, item: IGroupableItem<IItem>): boolean;
+    /**
+     * Use this function if you want to run code to determine whether an item can be sold to a buyer.
+     * @param game The game object
+     * @param item The item to sell
+     * @param buyer The potential buyer
+     */
+    canBuyItem?(game: IGame, item: IItem, buyer: ITrade | ICharacter): boolean;
+}

package/dist/src/Engine/Interfaces/rules/rules.d.ts

@@ -0,0 +1,31 @@
+import { ICharacterRules, ICombatRules, ICombinationRules, IEncounterRules, IExplorationRules, IGeneralRules, ISetupRules } from '../../..';
+export interface IRules {
+    /**
+     * Rules for setting up the game.
+     */
+    setup: ISetupRules;
+    /**
+     * General game rules.
+     */
+    general?: IGeneralRules;
+    /**
+     * Rules for the game character.
+     */
+    character: ICharacterRules;
+    /**
+     * Rules for exploring.
+     */
+    exploration?: IExplorationRules;
+    /**
+     * Rules for encounters.
+     */
+    encounters?: IEncounterRules;
+    /**
+     * Rules for combat.
+     */
+    combat?: ICombatRules;
+    /**
+     * Rule for combat.
+     */
+    combinations?: ICombinationRules;
+}

package/dist/src/Engine/Interfaces/rules/setupRules.d.ts

@@ -0,0 +1,56 @@
+import { IGame, ITitleScreen, StateList } from '../../..';
+export interface ISetupRules {
+    /**
+     * Specify a name of an image file in your resources folder to use that image as a custom mouse cursor.
+     * Don't use a large image, as the browser may not display it. Dimensions of 50x50 or 32x32 pixels work well.
+     */
+    customCursorImage?: string;
+    /**
+     * Set this to a positive value greater than 1 to allow the player to create a party of more than
+     * one character.
+     */
+    numberOfCharacters?: number;
+    /**
+     * Set this if you want to use a title screen.
+     */
+    titleScreen?: ITitleScreen;
+    /**
+     * Set this to true if you want to show an intro screen when the game starts.
+     */
+    intro?: boolean;
+    /**
+     * When you want to play a music file when the game is in a certain state, use this list. Use it like this:
+     playList: {
+     [Using GameState:] 'play.mp4': [GameState.Play].
+     [For multiple game states:] 'play.mp4': [GameState.Intro, GameState.Play].
+     [Using PlayState:] 'combat.mp4': [PlayState.Combat].
+     [Using Locations:] 'start.mp4': [Start].
+     [Using a custom function:] '': [game => string] (the string value returned from the function should be the music file).
+     }
+     */
+    playList?: StateList;
+    /**
+     * When you want to fade out music before starting a new piece, set this interval. The interval is in miliseconds, so specify
+     * a sufficiently large value (e.g. 250). The volume will be reduced by 10% each interval, and the new music starts when the
+     * volume of the current music reaches 0.
+     */
+    fadeMusicInterval?: number;
+    /**
+     * Run custom code to prepare the game before it begins. NOTE: this also runs when
+     * the browser reloads. If you want to run code only on the start of a new game, use
+     * gameStart instead.
+     * @param game The game about to be started
+     */
+    initGame?(game: IGame): void;
+    /**
+     * Run custom code to prepare the game before entering the start location, e.g. adding game-specific
+     * world properties to it.
+     * @param game The game about to be started
+     */
+    gameStart?(game: IGame): void;
+    /**
+     * Run custom code to prepare the game before resuming a game when loading a game.
+     * @param game The game about to be loaded
+     */
+    continueGame?(game: IGame): void;
+}

package/dist/src/Engine/Interfaces/rules/titleScreen.d.ts

@@ -0,0 +1,16 @@
+import { IDemoMode } from '../../..';
+export interface ITitleScreen {
+    /**
+     * Set this flag to true if you want to show a title screen, false otherwise.
+     */
+    showTitleScreen: boolean;
+    /**
+     * Set this function to get the demo configuration if you want to autoplay a demo game.
+     */
+    getDemoMode?: () => IDemoMode;
+    /**
+     * The transition time to use to fade to the game demo from the title screen, and back out when the demo has run.
+     * Use the CSS format, e.g. '.1' or '1'.
+     */
+    transitionDelay?: string;
+}

package/dist/src/Engine/Interfaces/saveGame.d.ts

@@ -0,0 +1,33 @@
+import { ICompiledLocation } from './compiledLocation';
+import { IStatistics } from './statistics';
+import { IParty } from './party';
+import { IMap } from './maps/map';
+/**
+ * An object to save the game state.
+ */
+export interface ISaveGame {
+    /**
+     * The party to save
+     */
+    party: IParty;
+    /**
+     * The statistics to save.
+     */
+    statistics: IStatistics;
+    /**
+     * The properties of the world to save.
+     */
+    worldProperties: {};
+    /**
+     * The world locations to save.
+     */
+    world: Record<string, ICompiledLocation>;
+    /**
+     * The world maps to save.
+     */
+    maps: Record<string, IMap>;
+    /**
+     * The autoplaying audio that was started already.
+     */
+    playedAudio: [];
+}

package/dist/src/Engine/Interfaces/scoreEntry.d.ts

@@ -0,0 +1,13 @@
+/**
+ * An entry in the high score log.
+ */
+export declare class ScoreEntry {
+    /**
+     * The name of the player achieving the score.
+     */
+    name: string;
+    /**
+     * The total player score.
+     */
+    score: number;
+}

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

@@ -0,0 +1,19 @@
+import { IAutoplayStep, IDemoMode } from '../../..';
+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/dist/src/Engine/Interfaces/services/characterService.d.ts

@@ -0,0 +1,17 @@
+import { ICharacter, ICreateCharacter, ICreateCharacterAttribute, ICreateCharacterAttributeEntry, ICreateCharacterStep, IGame, IQuest } from '../../..';
+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/dist/src/Engine/Interfaces/services/combatService.d.ts

@@ -0,0 +1,26 @@
+import { ICharacter, ICombatSetup, ICombatTurn, IEnemy, IItem } from '../../..';
+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/dist/src/Engine/Interfaces/services/combinationService.d.ts

@@ -0,0 +1,9 @@
+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/dist/src/Engine/Interfaces/services/commandService.d.ts

@@ -0,0 +1,64 @@
+import { IAction, IBarrier, IBarrierAction, IDestination, IFeature, IItem, ILocation, IPerson } from '../../..';
+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/dist/src/Engine/Interfaces/services/conversationService.d.ts

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

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

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

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

@@ -0,0 +1,33 @@
+import { IGame } from '../../..';
+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/dist/src/Engine/Interfaces/services/dataSynchronizer.d.ts

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

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

@@ -0,0 +1,10 @@
+import { IDemoMode, IGame, PlayState } from '../../..';
+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/dist/src/Engine/Interfaces/services/index.d.ts

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

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

@@ -0,0 +1,14 @@
+import { ICharacter, IEnemy, IGroupableItem, IItem } from '../../..';
+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/dist/src/Engine/Interfaces/services/localStorageService.d.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/dist/src/Engine/Interfaces/services/locationService.d.ts

@@ -0,0 +1,8 @@
+import { IAction, IGame, ILocation } from '../../..';
+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/dist/src/Engine/Interfaces/services/soundService.d.ts

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

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

@@ -0,0 +1,9 @@
+import { ICharacter, IItem, IPerson, ITrade } from '../../..';
+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/dist/src/Engine/Interfaces/soundPlayer.d.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/dist/src/Engine/Interfaces/sprite.d.ts

@@ -0,0 +1,23 @@
+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/dist/src/Engine/Interfaces/stateList.d.ts

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

package/dist/src/Engine/Interfaces/statistics.d.ts

@@ -0,0 +1,13 @@
+/**
+ * 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/dist/src/Engine/Interfaces/stock.d.ts

@@ -0,0 +1,39 @@
+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;
+}