@strixit/storyscript 0.0.0-stage → 1.0.0

package/src/Engine/Interfaces/groupableItem.ts

@@ -0,0 +1,37 @@
+import {IItem} from './item';
+
+/**
+ * An interface for items that can be combined with others of the same type to create an item group. This is
+ * useful if you want to prevent cluttering the player inventory with many items of the same type. A GroupableItem is
+ * itself an item, so the first item in the group is used as the parent and additional items are added to the members
+ * array.
+ */
+export interface IGroupableItem<T extends IItem> extends IItem {
+    /**
+     * This flag is always set to true for groupable items. It is used to separate groupable items from regular items.
+     */
+    isGroupable: boolean;
+
+    /**
+     * The name to show for the group of items. Use a placeholder to specify where the number of items in the group
+     * should be shown. E.g. '{0} rocks'.
+     */
+    groupName: string;
+
+    /**
+     * If this number is set, a group of these items can contain no more than this number of items. This is counting
+     * the parent and the members.
+     */
+    maxSize?: number;
+
+    /**
+     * Specify the items that can be grouped together with this one. If omitted, only items of the same type can be
+     * grouped.
+     */
+    groupTypes?: ((() => IGroupableItem<T>) | string)[];
+
+    /**
+     * The items that belong to this group.
+     */
+    members?: IGroupableItem<T>[];
+}

package/src/Engine/Interfaces/helpers.ts

@@ -0,0 +1,55 @@
+import { IItem } from './item';
+import { IEnemy } from './enemy';
+
+export interface IHelpers {
+    /**
+     * Roll a number of dice to get a number.
+     * @param compositeOrSides The number and type of dice (e.g. 3d6) or the number of sides of the dice (e.g.) 6
+     * @param dieNumber The number of dice, if not using the composite option
+     * @param bonus The bonus to add to the result.
+     */
+    rollDice(compositeOrSides: string | number, dieNumber?: number, bonus?: number): number;
+
+    /**
+     * Calculate the bonus the character is granted by the items he is carrying.
+     * @param person The player character or the person to calculate the bonus for.
+     * @param type The player attribute to get the bonus for (e.g. attack)
+     */
+    calculateBonus(person: { items?: IItem[], equipment?: {} }, type: string): number;
+
+    /**
+     * Get a random enemy to add to the game.
+     * @param selector A selector function to limit the list of enemies that can be returned at random (for example a function that excludes ghosts)
+     */
+    randomEnemy(selector?: (enemy: IEnemy) => boolean): IEnemy;
+
+    /**
+     * Get a random item to add to the game.
+     * @param selector A selector function to limit the list of items that can be returned at random (for example a function that excludes magic items)
+     */
+    randomItem(selector?: (item: IItem) => boolean): IItem;
+
+    /**
+     * Gets a specific item to add to the game.
+     * @param selector The id of the item to add
+     */        
+    getItem(selector: string): IItem;
+
+    /**
+     * Gets a specific enemy to add to the game.
+     * @param selector The id of the enemy to add
+     */        
+    getEnemy(selector: string): IEnemy;
+
+    /**
+     * Gets an item from the party, checking all character equipment and backpacks.
+     * @param item  The item to get from the party
+     */
+    getItemFromParty(item: string | (() => IItem)): IItem;
+
+    /**
+     * Removes an item from the party, checking all character equipment and backpacks.
+     * @param item  The item to remove from the party
+     */
+    removeItemFromParty(item: IItem | (() => IItem)): void;
+}

package/src/Engine/Interfaces/index.ts

@@ -0,0 +1,158 @@
+import type {IInterfaceTexts} from './interfaceTexts'
+import type {IRules} from './rules/rules'
+import type {IGame} from './game'
+import type {IParty} from './party'
+import type {ICharacter} from './character'
+import type {ICombatTurn} from './combatTurn'
+import type {ICombatSetup} from './combatSetup'
+import type {IEquipment} from './equipment'
+import type {IAction} from './action'
+import type {IFeature} from './feature'
+import type {IFeatureCollection} from './featureCollection'
+import type {IItem} from './item'
+import type {IGroupableItem} from './groupableItem';
+import type {IEnemy} from './enemy'
+import type {IPerson} from './person'
+import type {ITrade} from './trade'
+import type {IKey} from './key'
+import type {IQuest} from './quest'
+import type {ILocation} from './location'
+import type {ICompiledLocation} from './compiledLocation'
+import type {IDestination} from './destination'
+import type {IBarrier} from './barrier'
+import type {IBarrierAction} from './barrierAction'
+import type {IHelpers} from './helpers'
+import {DefaultEquipment} from './defaultEquipment'
+import type {ICombinable} from './combinations/combinable';
+import type {ICombine} from './combinations/combine';
+import type {ICombinations} from './combinations/combinations';
+import type {IActiveCombination} from './combinations/activeCombination';
+import type {ICombinationAction} from './combinations/combinationAction';
+import type {ICombineResult} from './combinations/combineResult';
+import type {ICombinationMatchResult} from './combinations/combinationMatchResult';
+import type {ICreateCharacter} from './createCharacter/createCharacter';
+import type {ICreateCharacterStep} from './createCharacter/createCharacterStep';
+import type {ICreateCharacterQuestion} from './createCharacter/createCharacterQuestion';
+import type {ICreateCharacterQuestionEntry} from './createCharacter/createCharacterQuestionEntry';
+import type {ICreateCharacterAttribute} from './createCharacter/createCharacterAttribute';
+import type {ICreateCharacterAttributeEntry} from './createCharacter/createCharacterAttributeEntry';
+import type {IConversation} from './conversations/conversation';
+import type {IConversationNode} from './conversations/conversationNode';
+import type {IConversationReply} from './conversations/conversationReply';
+import type {IConversationLogEntry} from './conversations/conversationLogEntry';
+import type {ICustomCursor} from './customCursor';
+import type {ICombatWinnings} from './combatWinnings';
+import type {IAutoplayStep} from "./autoplayStep";
+import type {ISetupRules} from './rules/setupRules';
+import type {IGeneralRules} from './rules/generalRules';
+import type {ICharacterRules} from './rules/characterRules';
+import type {IExplorationRules} from './rules/explorationRules';
+import type {ICombatRules} from './rules/combatRules';
+import type {IEncounterRules} from "./rules/encounterRules";
+import type {ICombinationRules} from "./rules/combinationRules";
+import type {ITitleScreen} from "./rules/titleScreen";
+import type {ISoundPlayer} from "./soundPlayer";
+import type {IDemoMode} from "./rules/demoMode";
+import type {IDynamicStyle} from './dynamicStyle';
+import type {IStatistics} from './statistics';
+import type {IDefinitions} from './definitions';
+import type {IGameEvents} from './gameEvents';
+import type {ISaveGame} from "./saveGame";
+import type {IStock} from "./stock";
+import type {IGameCombinations} from "./combinations/gameCombinations";
+import {EquipmentType} from './enumerations/equipmentType';
+import {PlayState} from './enumerations/playState';
+import {GameState} from './enumerations/gameState';
+import {ActionType} from './enumerations/actionType';
+import {ActionStatus} from './enumerations/actionStatus';
+import {TargetType} from './enumerations/targetType';
+import {ScoreEntry} from './scoreEntry';
+
+import {IMap} from './maps/map';
+import {IMapLocation} from './maps/mapLocation';
+import {Sprite} from './sprite';
+import {StateList, StateListEntry} from './stateList';
+
+export type {
+    IInterfaceTexts,
+    IRules,
+    IGame,
+    IParty,
+    ICharacter,
+    ICombatTurn,
+    ICombatSetup,
+    IEquipment,
+    IAction,
+    IItem,
+    IGroupableItem,
+    IFeature,
+    IFeatureCollection,
+    IEnemy,
+    IKey,
+    ILocation,
+    ICompiledLocation,
+    IDestination,
+    IBarrier,
+    IBarrierAction,
+    IPerson,
+    ITrade,
+    IQuest,
+    IHelpers,
+    ICreateCharacter,
+    ICreateCharacterStep,
+    ICreateCharacterQuestion,
+    ICreateCharacterQuestionEntry,
+    ICreateCharacterAttribute,
+    ICreateCharacterAttributeEntry,
+    ICombinable,
+    ICombine,
+    ICombinations,
+    IActiveCombination,
+    ICombinationAction,
+    IGameCombinations,
+    ICombineResult,
+    ICombinationMatchResult,
+    IConversation,
+    IConversationNode,
+    IConversationReply,
+    IConversationLogEntry,
+    IDefinitions,
+    IDynamicStyle,
+    IStatistics,
+    IMap,
+    IMapLocation,
+    ICustomCursor,
+    ICombatWinnings,
+    Sprite,
+    IAutoplayStep,
+    ISetupRules,
+    IGeneralRules,
+    ICharacterRules,
+    IExplorationRules,
+    ICombatRules,
+    IEncounterRules,
+    ICombinationRules,
+    ITitleScreen,
+    IDemoMode,
+    IGameEvents,
+    ISaveGame,
+    ISoundPlayer,
+    IStock
+}
+
+export {
+    DefaultEquipment,
+    EquipmentType,
+    PlayState,
+    GameState,
+    ActionStatus,
+    ActionType,
+    TargetType,
+    ScoreEntry,
+    StateList,
+    StateListEntry
+}
+
+export * from '../Actions/index';
+export * from '../Interfaces/services/index';
+export * from '../EntityCreatorFunctions'

package/src/Engine/Interfaces/interfaceTexts.ts

@@ -0,0 +1,142 @@
+/**
+ * All game texts that can be customized.
+ */
+export interface IInterfaceTexts {
+    equipmentHeader?: string;
+    head?: string;
+    amulet?: string;
+    body?: string;
+    hands?: string;
+    rightHand?: string;
+    leftHand?: string;
+    rightRing?: string;
+    leftRing?: string;
+    legs?: string;
+    feet?: string;
+    backpack?: string;
+    equip?: string;
+    use?: string;
+    drop?: string;
+    enemies?: string;
+    fight?: string;
+    attack?: string;
+    attackWith?: string;
+    aid?: string;
+    aidWith?: string;
+    noWeapon?: string,
+    useCombatItem?: string,
+    combatRound?: string,
+    enemyHitpoints?: string,
+    enemyCombatName?: string,
+    characterHitpoints?: string,
+    newGame?: string;
+    firstCharacter?: string,
+    secondCharacter?: string,
+    thirdCharacter?: string,
+    nthCharacter?: string,
+    nextCharacter?: string,
+    yourName?: string;
+    startAdventure?: string;
+    nextQuestion?: string;
+    actions?: string;
+    destinations?: string;
+    back?: string;
+    onTheGround?: string;
+    youLost?: string;
+    questFailed?: string;
+    finalScore?: string;
+    tryAgain?: string;
+    highScores?: string;
+    youWon?: string;
+    congratulations?: string;
+    playAgain?: string;
+    startOver?: string;
+    resetWorld?: string;
+    gameName?: string;
+    saveGame?: string;
+    save?: string;
+    loadGame?: string;
+    load?: string;
+    loading?: string;
+    youAreHere?: string;
+    messages?: string;
+    hitpoints?: string;
+    currency?: string;
+    partyCurrency?: string,
+    trade?: string;
+    talk?: string;
+    examine?: string;
+    encounters?: string;
+    closeModal?: string;
+    combatTitle?: string;
+    value?: string;
+    traderCurrency?: string;
+    startCombat?: string;
+    combatWin?: string;
+    enemiesToFight?: string;
+    useInCombat?: string;
+    noCombatAction?: string;
+    view?: string;
+    quests?: string;
+    currentQuests?: string;
+    completedQuests?: string;
+    combinations?: string;
+    tryCombination?: string;
+    noCombination?: string;
+    noCombinationNoTool?: string;
+    levelUp?: string;
+    levelUpDescription?: string;
+    completeLevelUp?: string;
+    newSaveGame?: string;
+    existingSaveGames?: string;
+    overwriteSaveGame?: string;
+    loadSaveGame?: string;
+    characterSheet?: string;
+    skipIntro?: string;
+    mainMenu?: string;
+    mainMenuShort?: string;
+    confirmRestart?: string;
+    restartCancelled?: string;
+    restartConfirmed?: string;
+    cancel?: string;
+    groupItem?: string;
+    splitItemGroup?: string;
+    worldProperties?: any;
+    confirmAction?: string;
+    cancelAction?: string;
+    stockItemDisplayText?: string,
+    buyConfirmationText?: string;
+    confirmBuy?: string;
+    cancelBuy?: string;
+    sellConfirmationText?: string;
+    confirmSell?: string;
+    cancelSell?: string;
+    currencyWon?: string;
+    itemsTaken?: string;
+    enemiesDefeated?: string;
+    backToGame?: string;
+    conversationEnded?: string;
+    openFullScreenMap?: string;
+    closeFullScreenMap?: string;
+    pressToShowMarkers?: string;
+    touchToShowMarkers?: string;
+    startGame?: string;
+    continueGame?: string;
+    autoplayText?: string;
+    noPlayWarning?: string;
+
+    /**
+     * A function to build text replacing tokens in a template, e.g. 'it is {0}, {1}' with parameters 'day' and '12:00' becomes 'it is day, 12:00'.
+     * If no function is specified, a default implementation is used.
+     * @param template The text template to replace the tokens in
+     * @param tokens The tokens to add to the template
+     */
+    format?(template: string, tokens: string[]): string;
+
+    /**
+     * A function to format a text using title case, e.g. 'world map' becomes 'World Map'.
+     * If no function is specified, a default implementation is used.
+     * @param text The text to format
+     */
+    titleCase?(text: string): string;
+}

package/src/Engine/Interfaces/item.ts

@@ -0,0 +1,111 @@
+import {IFeature} from './feature';
+import {IEnemy} from './enemy';
+import {IGame} from './game';
+import {EquipmentType} from './enumerations/equipmentType';
+import {IEquipment} from './equipment';
+import {ICharacter} from './character';
+import {TargetType} from './enumerations/targetType';
+
+/**
+ * An item that can be found in the game and used by the character.
+ */
+export interface IItem extends IFeature {
+    /**
+     * One or more parts of the character body this item is for (or no part, in case of a miscellaneous item).
+     * Use string values only for custom equipment types.
+     */
+    equipmentType: EquipmentType | EquipmentType[] | string | string[];
+
+    /**
+     * True if the item uses all the slots specified by the equipment type array, false if it occupies only one.
+     */
+    usesMultipleSlots?: boolean;
+
+    /**
+     * Set the target type for the item if the item needs to be used on a target. For example, a weapon targets
+     * an enemy, while a healing spell will target an ally. If the target type is not specified, the item cannot
+     * be used on enemies or allies.
+     */
+    targetType?: TargetType;
+
+    /**
+     * The details about this item as displayed to the player. If you use an HTML-page to describe the item, the contents of that HTM-page
+     * will be used to set this property at run-time.
+     */
+    description?: string;
+
+    /**
+     * The number of times the item can be used before disappearing. If not specified, the item can be used indefinitely.
+     */
+    charges?: number;
+
+    /**
+     * When this flag is set to true or the function returns true and the item has a use function specified, the use action will also be
+     * available during combat.
+     */
+    useInCombat?: boolean | ((item: IItem, equipment: IEquipment) => boolean);
+
+    /**
+     * When this flag is set to false, the item is not selectable. This is used to allow items to be unselectable during combat,
+     * for example when you want items to be available only during certain rounds.
+     */
+    selectable?: boolean;
+
+    /**
+     * The value of the item in whatever credits are used in the game.
+     */
+    value?: number;
+
+    /**
+     * When this flag is set to true, the item is not shown to the player. Useful to only conditionally make items available on a location.
+     */
+    inactive?: boolean;
+
+    /**
+     * When this is a flag set to true or has a function that returns true, the item cannot be dropped by the player. This is useful to
+     * have items that should not be dropped, such as an adventure map.
+     */
+    canDrop?: boolean | ((game: IGame, item: IItem) => boolean);
+
+    /**
+     * When specified, this function will be executed when the item is equipped by the player.
+     * @param character The character equipping the item
+     * @param item The item to be equipped
+     * @param game The game object
+     */
+    equip?(character: ICharacter, item: IItem, game: IGame): boolean;
+
+    /**
+     * When specified, this function will be executed when the item is unequipped by the player.
+     * @param character The character unequipping the item
+     * @param item The item to be unequipped
+     * @param game The game object
+     */
+    unequip?(character: ICharacter, item: IItem, game: IGame): boolean;
+
+    /**
+     * When specified, this item can be used and a use action becomes available on the item. The function will be executed when the player
+     * executes this action. Return a promise if the result should be awaited.
+     * @param game The game object
+     * @param character The character that uses the item
+     * @param item The item to use
+     * @param target The target to use the item on, if any
+     */
+    use?(game: IGame, character: ICharacter, item: IItem, target?: IEnemy): Promise<void> | void;
+
+    /**
+     * When specified, this action determines whether the use action for an item will be shown.
+     * @param game The game object
+     * @param character The character that wants to use the item
+     * @param item The item to show the use action for
+     */
+    canUse?(game: IGame, character: ICharacter, item: IItem): boolean;
+
+    /**
+     * When specified, this action determines whether the item can be used on the requested target.
+     * @param game The game object
+     * @param item The item to check the target for
+     * @param target The target on which the item would be used
+     */
+    canTarget?(game: IGame, item: IItem, target: IEnemy | ICharacter): boolean;
+}

package/src/Engine/Interfaces/key.ts

@@ -0,0 +1,18 @@
+import { IItem } from './item';
+import { IBarrierAction } from './barrierAction';
+
+/**
+ * A special kind of item, that can remove a barrier.
+ */
+export interface IKey extends IItem {
+    /**
+     * Set this flag to true if the player keeps the key after using it. Otherwise, it will be removed from his
+     * inventory when used.
+     */
+    keepAfterUse?: boolean;
+
+    /**
+     * The action triggered when using the key to remove the barrier.
+     */
+    open: IBarrierAction;
+}

package/src/Engine/Interfaces/location.ts

@@ -0,0 +1,92 @@
+import {IGame} from './game';
+import {IAction} from './action';
+import {IFeatureCollection} from './featureCollection';
+import {IEnemy} from './enemy';
+import {IPerson} from './person';
+import {IItem} from './item';
+import {IDestination} from './destination';
+import {ITrade} from './trade';
+
+/**
+ * The base properties for a part of the game world. A StoryScript game world is made up of a collection of locations.
+ */
+export interface ILocation {
+    /**
+     * The name of the location as shown to the player.
+     */
+    name: string;
+
+    /**
+     * The location description HTML file.
+     */
+    description: string;
+
+    /**
+     * When specified, the functions in this array will be called when the player enters the location.
+     * If nothing or false is returned, the function will be removed once it completed. Return true
+     * to keep the function and call it every time the player enters the location.
+     */
+    enterEvents?: [string, (game: IGame) => void | boolean][];
+
+    /**
+     * When specified, the functions in this array will be called when the player leaves the location.
+     * If nothing or false is returned, the function will be removed once it completed. Return true
+     * to keep the function and call it every time the player leaves the location.
+     */
+    leaveEvents?: [string, (game: IGame) => void | boolean][];
+
+    /**
+     * Actions that the player can perform at this location.
+     */
+    actions?: [string, IAction][];
+
+    /**
+     * Actions that the player can perform at this location when in combat.
+     */
+    combatActions?: [string, IAction][];
+
+    /**
+     * When specified, the functions in this array will be called from text features or user code when
+     * the trigger that should activate them is activated.
+     */
+    triggeredActions?: [string, (game: IGame, activate: boolean, data: Record<string, string>) => void][];
+
+    /**
+     * When specified, this function is called to determine the selector for the description of this location. Useful for dynamically
+     * setting a location's description. If you want to have a description selector function for all locations, use the descriptionSelector
+     * function of the game rules. Return the selector string.
+     * @param game The game object
+     */
+    descriptionSelector?: ((game: IGame) => string) | string;
+
+    /**
+     * The features of this location that the player can interact with.
+     */
+    features?: IFeatureCollection;
+
+    /**
+     * The enemies that occupy this location.
+     */
+    enemies?: IEnemy[];
+
+    /**
+     * The characters at this location that the player can interact with.
+     */
+    persons?: IPerson[];
+
+    /**
+     * The items that can be found at this location.
+     */
+    items?: IItem[];
+
+    /**
+     * The other locations in the game world that can be reached from this one.
+     */
+    destinations?: IDestination[];
+
+    /**
+     * Trade objects present at this location. If you don't want to use persons to trade with, you can use this array.
+     * Useful for e.g. adding containers like chests to the game.
+     */
+    trade?: ITrade[];
+}

package/src/Engine/Interfaces/maps/map.ts

@@ -0,0 +1,55 @@
+import { IMapLocation } from 'storyScript';
+
+export interface IMap {
+    /**
+     * The name of this map.
+     */
+    name: string;
+
+    /**
+     * The image to use for this map.
+     */
+    mapImage: string;
+
+    /**
+     * The locations that are part of this map.
+     */
+    locations: IMapLocation[];
+
+    /**
+     * The image to use for the player location on the map, if any.
+     */
+    avatarImage?: string;
+
+    /**
+     * True if text markers with the location names should be shown on the map, false otherwise.
+     */
+    locationNamesAsTextMarkers: boolean;
+
+    /**
+     * The default image to use as a marker for locations on the map.
+     */
+    locationMarkerImage?: string;
+
+    /**
+     * The time it takes for transitions on the map to complete. This is used to display elements like the avatar
+     * only after all transitions are finished. Defaults to 1000 ms.
+     */
+    transitionTime?: number;
+
+    /**
+     * True if location markers on the map can be clicked to navigate to that location, falsy otherwise.
+     */
+    clickable?: boolean;
+
+    /**
+     * The JavaScript KeyboardEvent.key value to listen for before showing the location markers. If not set, the markers
+     * will be shown all the time. If set, they will show only when the specified key is pressed.
+     */
+    showMarkersOnKeyPress?: string;
+
+    /**
+     * True if you want to show a toggle behind the map name to show the map full screen in a dialog, falsy otherwise.
+     */
+    toggleFullScreen?: boolean;
+}