@strixit/storyscript 0.0.0-stage → 1.0.0

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

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

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

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

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

@@ -0,0 +1,45 @@
+import { IMapLocation } from '../../..';
+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;
+}

package/dist/src/Engine/Interfaces/maps/mapLocation.d.ts

@@ -0,0 +1,23 @@
+import { ILocation } from '../../..';
+export interface IMapLocation {
+    /**
+     * The pointer to the location. This will be replaced with the location id during runtime.
+     */
+    location: (() => ILocation) | string;
+    /**
+     * The coordinates of this location on the map. use the format '{left},{top}'.
+     */
+    coords?: string;
+    /**
+     * The specific image to show for this location, if any.
+     */
+    markerImage?: string;
+    /**
+     * The specific text to show on this location label, if any.
+     */
+    textLabel?: string;
+    /**
+     * Set during runtime to contain the HTML element of the text label or marker image.
+     */
+    markerElement?: HTMLElement;
+}

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

@@ -0,0 +1,33 @@
+import { ICharacter } from './character';
+import { IQuest } from './quest';
+export interface IParty {
+    /**
+     * The name of the party.
+     */
+    name?: string;
+    /**
+     * The members of the party.
+     */
+    characters: ICharacter[];
+    /**
+     * The amount of credits the party has, in whatever form.
+     */
+    currency?: number;
+    /**
+     * All the quests the party has accepted, both active and complete.
+     */
+    quests?: IQuest[];
+    /**
+     * The number of points scored by the party so far. This property should be managed in your game rules. The score will
+     * be used to determine the party's ranking in the high-score list on game end.
+     */
+    score?: number;
+    /**
+     * The id of the location in the game world the party is currently at.
+     */
+    currentLocationId?: string;
+    /**
+     * The id of the location in the game world the party visited before the current one.
+     */
+    previousLocationId?: string;
+}

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

@@ -0,0 +1,25 @@
+import { IEnemy } from './enemy';
+import { ITrade } from './trade';
+import { IQuest } from './quest';
+import { IConversation } from './conversations/conversation';
+/**
+ * The base properties of a character in the game the player can talk or trade with.
+ */
+export interface IPerson extends IEnemy {
+    /**
+     * True if the player can attack the character, false otherwise.
+     */
+    canAttack?: boolean;
+    /**
+     * The trade settings for the person.
+     */
+    trade?: ITrade;
+    /**
+     * The conversation options for the person.
+     */
+    conversation?: IConversation;
+    /**
+     * The quests this person has available.
+     */
+    quests?: IQuest[];
+}

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

@@ -0,0 +1,51 @@
+import { IPerson } from './person';
+import { IGame } from './game';
+/**
+ * A quest a player can complete.
+ */
+export interface IQuest {
+    /**
+     * The name of the quest as shown to the player.
+     */
+    name: string;
+    /**
+     * The id of the person the player is pursuing this quest for.
+     */
+    issuedBy?: string;
+    /**
+     * The quest status, either as a string or a function that can produce a quest status dynamically.
+     */
+    status: string | ((game: IGame, quest: IQuest, done: boolean) => string);
+    /**
+     * A function to execute when the player starts this quest.
+     * @param game The game object
+     * @param quest The quest to start
+     * @param person The person this quest is for
+     */
+    start?(game: IGame, quest: IQuest, person: IPerson): void;
+    /**
+     * A function that is called by the engine to determine whether a quest is completed.
+     * @param game The game object
+     * @param quest The quest to check the status for
+     */
+    checkDone(game: IGame, quest: IQuest): boolean;
+    /**
+     * A function to execute when the player completes this quest.
+     * @param game The game object
+     * @param quest The quest to complete
+     * @param person The person this quest is for
+     */
+    complete?(game: IGame, quest: IQuest, person: IPerson): void;
+    /**
+     * True if the player started the quest, false otherwise.
+     */
+    started?: boolean;
+    /**
+     * True if the player completed the quest, false otherwise.
+     */
+    completed?: boolean;
+    /**
+     * A custom object to track quest progress.
+     */
+    progress?: any;
+}

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

@@ -0,0 +1,84 @@
+import { ICharacter, ICreateCharacter, IGame, IItem } from '../../..';
+export interface ICharacterRules {
+    /**
+     * Use this function to determine what character attributes should be shown on the character sheet. Return the names
+     * of the attributes (e.g. 'strength').
+     */
+    getSheetAttributes?(): string[];
+    /**
+     * Use this function to use custom logic whether or not to show an equipment slot. Returns true if the slot
+     * should be shown, false otherwise.
+     * @param character The character to show the slot for
+     * @param slot The slot to show.
+     */
+    isSlotUsed?(character: ICharacter, slot: string): boolean;
+    /**
+     * Use this function to specify the steps in your character creation process. Return the character creation sheet.
+     */
+    getCreateCharacterSheet?(): ICreateCharacter;
+    /**
+     * Use this function to specify the steps in your character level up process. Return the level-up sheet.
+     */
+    getLevelUpSheet?(): ICreateCharacter;
+    /**
+     * This function is called when the character sheet has been filled in and the game is about to start.
+     * You can add custom logic here to prepare your character before game start. Return the player character.
+     * @param game The game about to start
+     * @param characterData The character sheet filled in
+     */
+    createCharacter?(game: IGame, characterData: ICreateCharacter): ICharacter;
+    /**
+     * This function is called when the level-up sheet has been filled in and the game is about to continue.
+     * You can add custom logic here to process the level-up sheet before the game continues. Return true if
+     * you also want the default level-up sheet processing to run.
+     * @param character The character
+     * @param characterData The level-up sheet filled in
+     */
+    levelUp?(character: ICharacter, characterData: ICreateCharacter): boolean;
+    /**
+     * Specify this function if you want to apply custom rules to check whether a character can equip an item.
+     * If the player is not allowed to equip the item, return false.
+     * @param item The item about to be equipped
+     * @param character The player character
+     */
+    canEquip?(item: IItem, character: ICharacter): boolean;
+    /**
+     * Specify this function if you want to apply custom rules before allowing a player to equip an item. If the player
+     * is not allowed to equip the item, return false.
+     * @param game The active game
+     * @param character The player character
+     * @param item The item about to be equipped
+     */
+    beforeEquip?(game: IGame, character: ICharacter, item: IItem): boolean;
+    /**
+     * Specify this function if you want to apply custom rules before allowing a player to unequip an item. If the player
+     * is not allowed to unequip the item, return false.
+     * @param game The active game
+     * @param character The player character
+     * @param item The item about to be unequipped
+     */
+    beforeUnequip?(game: IGame, character: ICharacter, item: IItem): boolean;
+    /**
+     * Specify this function if you want to apply custom rules before a player picks up an item. Return false if the player
+     * should not pick up the item.
+     * @param game The active game
+     * @param character The player character
+     * @param item The item about to be picked up
+     */
+    beforePickup?(game: IGame, character: ICharacter, item: IItem): boolean;
+    /**
+     * Specify this function if you want to apply custom rules before a player drops an item. Return false if the player
+     * should not drop the item.
+     * @param game The active game
+     * @param character The player character
+     * @param item The item about to be dropped
+     */
+    beforeDrop?(game: IGame, character: ICharacter, item: IItem): boolean;
+    /**
+     * Specify this function if you want to do something special when a character's health changes.
+     * @param game The active game
+     * @param character The character for whom the health changes
+     * @param change The change in health points. If the player is wounded, the number will be negative.
+     */
+    hitpointsChange?(game: IGame, character: ICharacter, change: number): void;
+}

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

@@ -0,0 +1,46 @@
+import { ICharacter, ICombatSetup, ICombatTurn, ICompiledLocation, IEnemy, IGame, IItem } from '../../..';
+export interface ICombatRules {
+    /**
+     * This function allows you to add custom logic to execute before combat starts.
+     * @param game The active game
+     * @param location The current location
+     */
+    initCombat?(game: IGame, location: ICompiledLocation): void;
+    /**
+     * This function is called before each combat round starts, and allows you to override round settings.
+     * @param game The active game
+     * @param combat The setup for the next combat round
+     */
+    initCombatRound?(game: IGame, combat: ICombatSetup<ICombatTurn>): void;
+    /**
+     * This function determines the combat rules for your game. Return a promise
+     * when you want the engine to wait for your function to complete asynchronously.
+     * @param game The active game
+     * @param combatRound The setup for this combat round
+     * @param retaliate True if the enemies present can fight back, false or undefined otherwise
+     */
+    fight?(game: IGame, combatRound: ICombatSetup<ICombatTurn>, retaliate?: boolean): Promise<void> | void;
+    /**
+     * Use this function to run custom code to determine whether an item should be selectable for combat
+     * or not.
+     * @param game The active game
+     * @param item The item for which to determine whether it should be selectable
+     */
+    itemIsSelectable?(game: IGame, item: IItem): boolean;
+    /**
+     * This function will be called when an enemy is defeated.
+     * @param game The active game
+     * @param character The character defeating the enemy
+     * @param enemy The enemy just defeated
+     */
+    enemyDefeated?(game: IGame, character: ICharacter, enemy: IEnemy): void;
+    /**
+     * Specify this function if you want to apply custom rules before an enemy drops an item when defeated.
+     * Return false if the enemy should not drop the item.
+     * @param game The active game
+     * @param character The character defeating the enemy
+     * @param enemy The enemy defeated
+     * @param item The item about to be dropped
+     */
+    beforeDrop?(game: IGame, character: ICharacter, enemy: IEnemy, item: IItem): boolean;
+}

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

@@ -0,0 +1,15 @@
+import { IActiveCombination, ICombinable, ICombinationAction, IGame } from '../../..';
+export interface ICombinationRules {
+    /**
+     * If you want to use combinations in your game, you must use this property to specify the
+     * combination actions that your game uses (e.g. 'Look at', 'Use', etc.).
+     */
+    combinationActions?: ICombinationAction[];
+    /**
+     * Use this function to run code after each successful combination.
+     * @param game The game object
+     * @param combination The combination used
+     * @param target The target of the combination
+     */
+    success?: (game: IGame, combination: IActiveCombination, target: ICombinable) => void;
+}

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

@@ -0,0 +1,15 @@
+import { IAutoplayStep, IParty } from '../../..';
+export interface IDemoMode {
+    /**
+     * The number of milliseconds to wait before starting the game demo.
+     */
+    startDelay: number;
+    /**
+     * The party to use when playing the demo.
+     */
+    party: IParty;
+    /**
+     * The steps to play during the demo.
+     */
+    steps: IAutoplayStep[];
+}

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

@@ -0,0 +1,4 @@
+import { IConversationNode, IGame } from '../../..';
+export interface IEncounterRules {
+    initReplies?: (game: IGame, node: IConversationNode) => void;
+}