@strixit/storyscript 0.0.0-stage → 1.0.0

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

@@ -0,0 +1,48 @@
+import { IItem } from './item';
+import { IEquipment } from './equipment';
+/**
+ * The player character in the StoryScript game.
+ */
+export interface ICharacter {
+    /**
+     * The name of the player character.
+     */
+    name: string;
+    /**
+     * The file name of the image to display for the character. The file name should be relative to the index.html file.
+     */
+    portraitFileName?: string;
+    /**
+     * The total health of the player when in top condition.
+     */
+    hitpoints: number;
+    /**
+     * The current health of the player.
+     */
+    currentHitpoints: number;
+    /**
+     * All items the player is carrying in his backpack. Note that equipped items are not in this list.
+     */
+    items: IItem[];
+    /**
+     * All items the character has that can be used during combat.
+     */
+    combatItems?: IItem[];
+    /**
+     * The items the character has equipped.
+     */
+    equipment: IEquipment;
+    /**
+     * The player's experience. This is an optional element, you should track experience in your game rules.
+     */
+    experience?: number;
+    /**
+     * The player character level. This is an optional element, you should track level and take care of level
+     * up in your game rules.
+     */
+    level?: number;
+    /**
+     * True when this is the active party character, false otherwise. This is a runtime property managed by StoryScript.
+     */
+    isActiveCharacter?: boolean;
+}

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

@@ -0,0 +1,9 @@
+import { ICharacter, ICombatTurn, ICombatWinnings, IEnemy } from '../..';
+export interface ICombatSetup<T extends ICombatTurn> extends Array<T> {
+    roundHeader: string;
+    noActionText: string;
+    round: number;
+    characters: ICharacter[];
+    enemies: IEnemy[];
+    winnings: ICombatWinnings;
+}

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

@@ -0,0 +1,37 @@
+import { ICharacter } from './character';
+import { IEnemy } from './enemy';
+import { IItem } from './item';
+export interface ICombatTurn {
+    /**
+     * The character for whom this turn is set up.
+     */
+    character: ICharacter;
+    /**
+     * The enemies and allies available for targeting to the character this turn.
+     */
+    targetsAvailable: (IEnemy | ICharacter)[];
+    /**
+     * The target selected by the character during the previous turn.
+     */
+    previousTarget: IEnemy | ICharacter;
+    /**
+     * The target selected by the character this turn.
+     */
+    target: IEnemy | ICharacter;
+    /**
+     * True when the target was defeated this turn, false otherwise.
+     */
+    targetDefeated: boolean;
+    /**
+     * The items available to the character this turn.
+     */
+    itemsAvailable: IItem[];
+    /**
+     * The item selected by the character during the previous turn.
+     */
+    previousItem?: IItem;
+    /**
+     * The item selected by the character this turn.
+     */
+    item?: IItem;
+}

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

@@ -0,0 +1,6 @@
+import { IEnemy, IItem } from '../..';
+export interface ICombatWinnings {
+    currency: number;
+    itemsWon: IItem[];
+    enemiesDefeated: IEnemy[];
+}

package/dist/src/Engine/Interfaces/combinations/activeCombination.d.ts

@@ -0,0 +1,14 @@
+import { ICombinationAction, ICombinable } from '../../..';
+/**
+ * The currently active combination when playing the game.
+ */
+export interface IActiveCombination {
+    /**
+     * The action type of the currently active combination.
+     */
+    selectedCombinationAction: ICombinationAction;
+    /**
+     * The currently selected tool of the combination.
+     */
+    selectedTool: ICombinable;
+}

package/dist/src/Engine/Interfaces/combinations/combinable.d.ts

@@ -0,0 +1,18 @@
+import { ICombinations } from '../../..';
+/**
+ * Defines an object that can participate in combinations.
+ */
+export interface ICombinable {
+    /**
+     * The id of the object, set at runtime.
+     */
+    id?: string;
+    /**
+     * The name of the object.
+     */
+    name: string;
+    /**
+     * The combinations this object type can participate in.
+     */
+    combinations?: ICombinations<ICombinable>;
+}

package/dist/src/Engine/Interfaces/combinations/combinationAction.d.ts

@@ -0,0 +1,41 @@
+import { ICombinable, ICombinationMatchResult, IGame } from '../../..';
+/**
+ * Combination actions that can be tried in the game, e.g. throwing an object at another object.
+ */
+export interface ICombinationAction {
+    /**
+     * The text to display for the action in the interface (e.g. 'Look' for 'Look at')
+     */
+    text: string;
+    /**
+     * The preposition to use for the action, e.g. 'at' for 'Look at'. Some actions do not need a preposition, like pull.
+     */
+    preposition?: string;
+    /**
+     * True if the action requires a tool, false otherwise. E.g. 'Look at' does not require a tool
+     * (you can just look at something) while 'Throw at' obviously does require something being thrown.
+     */
+    requiresTool?: boolean;
+    /**
+     * The text to show to the player, or a function returning this text, when a combination attempt for this action fails.
+     * @param game The game object
+     * @param tool The tool for the combination
+     * @param target The target of the combination
+     */
+    failText?: string | ((game: IGame, tool: ICombinable, target: ICombinable) => string);
+    /**
+     * Set this to true to make this action the default. A player doesn't need to select it first to use it. If no combination
+     * is active when the player selects a feature, this action will be used.
+     */
+    isDefault?: boolean;
+    /**
+     * Set this to use a picture for your combinations in addition to a text. For visual features, this will display the picture
+     * as mouse cursor when a cursor is available or on top of the features for touch devices.
+     */
+    picture?: string;
+    /**
+     * Set this to have a default match action available. This is useful if you want to have default behaviour for one particular
+     * type of action (e.g. Look at).
+     */
+    defaultMatch?(game: IGame, target: ICombinable, tool: ICombinable): string | ICombinationMatchResult;
+}

package/dist/src/Engine/Interfaces/combinations/combinationMatchResult.d.ts

@@ -0,0 +1,14 @@
+export interface ICombinationMatchResult {
+    /**
+     * The result text of the combination match.
+     */
+    text: string;
+    /**
+     * If true, remove the tool feature after the match is made.
+     */
+    removeTool?: boolean;
+    /**
+     * If true, remove the target feature after the match is made.
+     */
+    removeTarget?: boolean;
+}

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

@@ -0,0 +1,17 @@
+import { ICombinable, ICombine, IGame } from '../../..';
+/**
+ * A list of combinations that can be used on an object.
+ */
+export interface ICombinations<T extends ICombinable> {
+    /**
+     * The combinations available.
+     */
+    combine: ICombine<T>[];
+    /**
+     * The text to show to the player, or a function returning this text, when a combination attempt on this object fails.
+     * @param game The game object
+     * @param target The target of the combination.
+     * @param tool The tool for the combination.
+     */
+    failText?: string | ((game: IGame, target: ICombinable, tool: ICombinable) => string);
+}

package/dist/src/Engine/Interfaces/combinations/combine.d.ts

@@ -0,0 +1,22 @@
+import { ICombinable, ICombinationMatchResult, IGame } from '../../..';
+/**
+ * A combination definition.
+ */
+export interface ICombine<T extends ICombinable> {
+    /**
+     * The tool for this combination.
+     */
+    tool?: T;
+    /**
+     * The type of the combination, which should match an ICombination text.
+     */
+    combinationType: string;
+    /**
+     * The function to execute when a combination is successful. Return the success text. When omitted,
+     * the default match for the combination type will be invoked (when specified).
+     * @param game The game object
+     * @param target The target of the combination
+     * @param tool The tool for the combination
+     */
+    match?(game: IGame, target: ICombinable, tool: ICombinable): string | ICombinationMatchResult;
+}

package/dist/src/Engine/Interfaces/combinations/combineResult.d.ts

@@ -0,0 +1,18 @@
+export interface ICombineResult {
+    /**
+     * The result text of the combination attempt.
+     */
+    text: string;
+    /**
+     * True if a successful match was made, false otherwise.
+     */
+    success: boolean;
+    /**
+     * If true, remove the tool feature after the match is made.
+     */
+    removeTool?: boolean;
+    /**
+     * If true, remove the target feature after the match is made.
+     */
+    removeTarget?: boolean;
+}

package/dist/src/Engine/Interfaces/combinations/gameCombinations.d.ts

@@ -0,0 +1,40 @@
+import { IActiveCombination, ICombinable, ICombineResult } from '../../..';
+export interface IGameCombinations {
+    /**
+     * Holds the currently selected combination action during rum-time. This will be undefined or null when the player
+     * is not trying a combination.
+     */
+    activeCombination: IActiveCombination;
+    /**
+     * The result from the last attempted combination.
+     */
+    combinationResult: {
+        /**
+         * Indicates whether the combination is done.
+         */
+        done: boolean;
+        /**
+         * The combination result text.
+         */
+        text: string;
+        /**
+         * The features to remove.
+         */
+        featuresToRemove: string[];
+        /**
+         * Resets the combination result.
+         */
+        reset(): void;
+    };
+    /**
+     * Get the class name to use for the current combine state.
+     * @param tool The tool of the combination. Pass this in to get the class name for the tool element. Pass nothing to
+     * get the class name for the tool button bar.
+     */
+    getCombineClass(tool: ICombinable): string;
+    /**
+     * Try the combination the player has created.
+     * @param target The target of the combination
+     */
+    tryCombine(target: ICombinable): ICombineResult;
+}

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

@@ -0,0 +1,33 @@
+import { ILocation } from './location';
+/**
+ * A location compiled for runtime.
+ */
+export interface ICompiledLocation extends ILocation {
+    /**
+     * The id of the location.
+     */
+    id: string;
+    /**
+     * The current description shown to the player for this location.
+     */
+    description: string;
+    /**
+     * True if the player has visited this location, false otherwise.
+     */
+    hasVisited?: boolean;
+    /**
+     * All the descriptions available for this location, per description key.
+     */
+    descriptions?: {
+        [key: string]: string;
+    };
+    /**
+     * The file path for the picture to show for this location. It is read from the location's HTML file's
+     * picture tag if present.
+     */
+    picture?: string;
+    /**
+     * Messages logged to this location.
+     */
+    log?: string[];
+}

package/dist/src/Engine/Interfaces/conversations/conversation.d.ts

@@ -0,0 +1,44 @@
+import { IConversationLogEntry, IConversationNode, IGame, IPerson } from '../../..';
+/**
+ * A conversation between the player and a person. The nodes are loaded at run-time from the HTML file of the person.
+ */
+export interface IConversation {
+    /**
+     * The title of the conversation as shown to the player.
+     */
+    title?: string;
+    /**
+     * True if reply options that the player cannot choose are to be displayed but unselectable, false to just hide them.
+     */
+    showUnavailableReplies?: boolean;
+    /**
+     * The actions that can be triggered from the conversation.
+     */
+    actions?: [string, (game: IGame, person: IPerson) => void][];
+    /**
+     * The nodes that make up this conversation. Loaded from the person HTML at runtime.
+     */
+    nodes?: IConversationNode[];
+    /**
+     * The name of the node to start the conversation with. Set at runtime.
+     */
+    startNode?: string;
+    /**
+     * The node currently active in the conversation.
+     */
+    activeNode?: IConversationNode;
+    /**
+     * A log of the conversation so far.
+     */
+    conversationLog?: IConversationLogEntry[];
+    /**
+     * A semicolon separated list set at runtime of replies that can be selected only once and have been selected by the player.
+     */
+    singleRepliesChosen?: string;
+    /**
+     * When specified, this function will be used to determine what conversation node to set as the active node.
+     * @param game The game object
+     * @param person The person the player is having the conversation with
+     */
+    selectActiveNode?(game: IGame, person: IPerson): IConversationNode;
+}

package/dist/src/Engine/Interfaces/conversations/conversationLogEntry.d.ts

@@ -0,0 +1,13 @@
+/**
+ * An entry in the conversation log.
+ */
+export interface IConversationLogEntry {
+    /**
+     * The conversation node logged.
+     */
+    lines: string;
+    /**
+     * The reply the player chose to the logged node.
+     */
+    reply: string;
+}

package/dist/src/Engine/Interfaces/conversations/conversationNode.d.ts

@@ -0,0 +1,22 @@
+import { IConversationReply } from '../../..';
+/**
+ * A node of a conversation.
+ */
+export interface IConversationNode {
+    /**
+     * The internal name of the node, used to reference it from code.
+     */
+    node: string;
+    /**
+     * The node text as shown to the player.
+     */
+    lines: string;
+    /**
+     * The possible replies of the player for this node.
+     */
+    replies: IConversationReply[];
+    /**
+     * The action triggered when this node is activated. The trigger string must equal an action in the conversation options.
+     */
+    trigger?: string;
+}

package/dist/src/Engine/Interfaces/conversations/conversationReply.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Options for a reply to a node.
+ */
+export interface IConversationReply {
+    /**
+     * True if this reply is the default reply, available to all nodes. False otherwise.
+     */
+    defaultReply?: boolean;
+    /**
+     * specifies an item or a character attribute with a minimum number required for this reply to be available.
+     */
+    requires?: string;
+    /**
+     * The text of this reply as shown to the player.
+     */
+    lines?: string;
+    /**
+     * The node that will continue the conversation if this reply is chosen.
+     */
+    linkToNode?: string;
+    /**
+     * True if the player can select the reply, false otherwise.
+     */
+    available?: boolean;
+    /**
+     * True if the player can see the reply even though it is not available to him, false otherwise.
+     */
+    showWhenUnavailable?: boolean;
+    /**
+     * The action triggered by choosing this response. The trigger string must equal an action in the conversation options.
+     */
+    trigger?: string;
+    /**
+     * The name of the quest to start when this reply is chosen.
+     */
+    questStart?: string;
+    /**
+     * The name of the quest to complete when this reply is chosen.
+     */
+    questComplete?: string;
+    /**
+     * The name of the node to set as the start node when this reply is chosen.
+     */
+    setStart?: string;
+    /**
+     * True if this reply can be chosen only once.
+     */
+    once?: boolean;
+}

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

@@ -0,0 +1,20 @@
+import { ICreateCharacterStep } from '../../..';
+/**
+ * The definition of the sheet to create a character for the game.
+ */
+export interface ICreateCharacter {
+    /**
+     * The steps in the character creation process.
+     */
+    steps: ICreateCharacterStep[];
+    /**
+     * The currently active step.
+     */
+    currentStep?: number;
+    /**
+     * The function that will select the next step in the character creation process. This function is added by the engine at run-time.
+     * @param character The character sheet filled in so far
+     * @param next True if the next step is to be triggered, false otherwise. Defaults to true.
+     */
+    nextStep?(character: ICreateCharacter, next?: boolean): void;
+}

package/dist/src/Engine/Interfaces/createCharacter/createCharacterAttribute.d.ts

@@ -0,0 +1,18 @@
+import { ICreateCharacterAttributeEntry } from '../../..';
+/**
+ * An attribute entry for a create character question.
+ */
+export interface ICreateCharacterAttribute {
+    /**
+     * The text for the attribute selection as displayed to the player.
+     */
+    question: string;
+    /**
+     * The total number to be distributed among the entries.
+     */
+    numberOfPointsToDistribute?: number;
+    /**
+     * The attributes to distribute the points for.
+     */
+    entries: ICreateCharacterAttributeEntry[];
+}

package/dist/src/Engine/Interfaces/createCharacter/createCharacterAttributeEntry.d.ts

@@ -0,0 +1,18 @@
+export interface ICreateCharacterAttributeEntry {
+    /**
+     * The attribute text as displayed to the player.
+     */
+    attribute: string;
+    /**
+     * The value of the attribute.
+     */
+    value?: number | string;
+    /**
+     * The minimum number the attribute should have.
+     */
+    min?: number;
+    /**
+     * The maximum number the attribute is allowed to have.
+     */
+    max?: number;
+}

package/dist/src/Engine/Interfaces/createCharacter/createCharacterQuestion.d.ts

@@ -0,0 +1,18 @@
+import { ICreateCharacterQuestionEntry } from '../../..';
+/**
+ * A question for the player to answer when creating a character.
+ */
+export interface ICreateCharacterQuestion {
+    /**
+     * The question text as displayed to the player.
+     */
+    question: string;
+    /**
+     * The available replies to the question.
+     */
+    entries: ICreateCharacterQuestionEntry[];
+    /**
+     * The currently selected entry. Used during run-time.
+     */
+    selectedEntry?: ICreateCharacterQuestionEntry;
+}

package/dist/src/Engine/Interfaces/createCharacter/createCharacterQuestionEntry.d.ts

@@ -0,0 +1,22 @@
+/**
+ * An answer to a character creation question.
+ */
+export interface ICreateCharacterQuestionEntry {
+    /**
+     * The answer text as displayed to the player.
+     */
+    text: string;
+    /**
+     * The value of the entry, which should be a character attribute that the bonus will be applied to.
+     */
+    value: string;
+    /**
+     * The bonus to apply to the character attribute when this answer is chosen.
+     */
+    bonus?: number;
+    /**
+     * Set this flag to true to make this choice finish character creation.
+     * This allows building a branched character creation process.
+     */
+    finish?: boolean;
+}

package/dist/src/Engine/Interfaces/createCharacter/createCharacterStep.d.ts

@@ -0,0 +1,40 @@
+import { ICreateCharacter, ICreateCharacterAttribute, ICreateCharacterQuestion, IParty } from '../../..';
+/**
+ * The definition of a step in the character creation process.
+ */
+export interface ICreateCharacterStep {
+    /**
+     * The text describing this step in the creation process to the player.
+     */
+    description?: string;
+    /**
+     * The questions to show as part of this step.
+     */
+    questions?: ICreateCharacterQuestion[];
+    /**
+     * The attributes to show as part of this step.
+     */
+    attributes?: ICreateCharacterAttribute[];
+    /**
+     * The total numner of points to distribute over multiple attributes.
+     */
+    numberOfAttributePoints?: number;
+    /**
+     * The selector that determines what step will be activated after the current one.
+     * Either pass the number of the step or a function returning that number.
+     */
+    nextStepSelector?: number | ((party: IParty, character: ICreateCharacter, currentStep: ICreateCharacterStep) => number);
+    /**
+     * Set this flag to true to mark this step as one of the final steps in character creation.
+     * This allows building a branched character creation process.
+     */
+    finish?: boolean;
+    /**
+     * A function that executes when the step is to be displayed to the player.
+     * @param party The party created so far
+     * @param character The character sheet filled in so far
+     * @param currentStep The step about to be shown to the player
+     * @param previousStep The step just completed by the player, or undefined if the step to be displayed is the first step in the sheet.
+     */
+    initStep?(party: IParty, character: ICreateCharacter, currentStep: ICreateCharacterStep, previousStep?: number): void;
+}

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

@@ -0,0 +1,8 @@
+export interface ICustomCursor {
+    image: string;
+    dimensions: {
+        width: number;
+        height: number;
+    };
+    style: string;
+}

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

@@ -0,0 +1,19 @@
+import { IEquipment } from './equipment';
+import { IItem } from './item';
+/**
+ * This class is for internal StoryScript use only, to determine which equipment slots belong
+ * to the default ones and which are custom for a game.
+ */
+export declare class DefaultEquipment implements IEquipment {
+    constructor();
+    head: IItem;
+    amulet: IItem;
+    body: IItem;
+    hands: IItem;
+    leftHand: IItem;
+    leftRing: IItem;
+    rightHand: IItem;
+    rightRing: IItem;
+    legs: IItem;
+    feet: IItem;
+}