@strixit/storyscript 0.0.0-stage → 1.0.0

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

@@ -0,0 +1,40 @@
+import { ILocation } from './location';
+import { IPerson } from './person';
+import { IItem } from './item';
+import { IQuest } from './quest';
+import { IFeature } from './feature';
+import { IEnemy } from './enemy';
+import { IMap } from './maps/map';
+/**
+ * All definitions created for a StoryScript the game.
+ */
+export interface IDefinitions {
+    /**
+     * The locations available in the game world.
+     */
+    locations: (() => ILocation)[];
+    /**
+     * The available maps of the world.
+     */
+    maps: (() => IMap)[];
+    /**
+     * The features present in the game world.
+     */
+    features: (() => IFeature)[];
+    /**
+     * The enemies present in the game world.
+     */
+    enemies: (() => IEnemy)[];
+    /**
+     * The persons roaming the game world.
+     */
+    persons: (() => IPerson)[];
+    /**
+     * The items that can be found in the game world.
+     */
+    items: (() => IItem)[];
+    /**
+     * The quests the player can pursue in the game world.
+     */
+    quests: (() => IQuest)[];
+}

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

@@ -0,0 +1,31 @@
+import { IBarrier } from './barrier';
+import { ILocation } from './location';
+/**
+ * The base properties for a destination reachable from a location.
+ */
+export interface IDestination {
+    /**
+     * The name of the destination to show to the player.
+     */
+    name: string;
+    /**
+     * The css class to add to the destination so it can be styled.
+     */
+    style?: string;
+    /**
+     * True if the destination is inactive and not visible, false otherwise.
+     */
+    inactive?: boolean;
+    /**
+     * The barriers that are blocking travel to the new location.
+     */
+    barriers?: [string, IBarrier][];
+    /**
+     * The location that this destination leads to.
+     */
+    target: (() => ILocation) | string;
+    /**
+     * True if the location this destination leads to was visited before by the player, false otherwise.
+     */
+    visited?: boolean;
+}

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

@@ -0,0 +1,10 @@
+export interface IDynamicStyle {
+    /**
+     * The selector for the element to style dynamically.
+     */
+    elementSelector: string;
+    /**
+     * The styles to apply as name/value pairs. E.g. ['margin-top', '50px'];
+     */
+    styles: string[][];
+}

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

@@ -0,0 +1,46 @@
+import { IFeature } from './feature';
+import { IItem } from './item';
+import { IGame } from './game';
+/**
+ * Defines the base properties for an enemy in the game.
+ */
+export interface IEnemy extends IFeature {
+    /**
+     * The details about this enemy as displayed to the player. If you use an HTML-page to describe the enemy, the contents of that HTML-page
+     * will be used to set this property at run-time.
+     */
+    description?: string;
+    /**
+     * The health of the enemy.
+     */
+    hitpoints: number;
+    /**
+     * The current health of the enemy, tracked by StoryScript at runtime.
+     */
+    currentHitpoints?: number;
+    /**
+     * The amount of credits the enemy has, in whatever form.
+     */
+    currency?: number;
+    /**
+     * The items the enemy is carrying.
+     */
+    items?: IItem[];
+    /**
+     * When this flag is set to true, the enemy is not shown to the player, cannot be attacked and will not block the player from travelling.
+     * Useful to only conditionally make enemies present on a location.
+     */
+    inactive?: boolean;
+    /**
+     * When specified, this function will be called when the enemy is attacked by the player.
+     * @param game The game object
+     * @param enemy The attacked enemy
+     */
+    onAttack?(game: IGame, enemy: IEnemy): void;
+    /**
+     * When specified, this function will be called when the enemy's health is reduced to 0 or less.
+     * @param game The game object
+     * @param enemy The defeated enemy
+     */
+    onDefeat?(game: IGame, enemy: IEnemy): void;
+}

package/dist/src/Engine/Interfaces/enumerations/actionStatus.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Used to set the availability of actions to the player.
+ */
+export declare enum ActionStatus {
+    /**
+     * The action shows up for the player and is selectable.
+     */
+    Available = "Available",
+    /**
+ * The action shows up for the player but is not selectable. Useful to show actions that could be performed if additional criteria
+ * had been met (e.g. the character needs to be stronger to break down a door).
+ */
+    Disabled = "Disabled",
+    /**
+     * The action is not shown to the player. Useful for actions that are only conditionally available.
+     */
+    Unavailable = "Unavailable"
+}

package/dist/src/Engine/Interfaces/enumerations/actionType.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Used to differentiate between actions visually (e.g. color).
+ */
+export declare enum ActionType {
+    Regular = "Regular",
+    Check = "Check",
+    Combat = "Combat",
+    Trade = "Trade"
+}

package/dist/src/Engine/Interfaces/enumerations/equipmentType.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Used to specify what part of the player body the item is meant for, if any. You can specify the equipment slots used in your game as an object
+ * on the character class of your game. Note that items may belong to more than one type, e.g. two-handed weapons that require both the left and
+ * right hand to use.
+ */
+export declare enum EquipmentType {
+    /**
+     * Items worn on the head, ranging from diadem to helmets covering the entire head.
+     */
+    Head = "Head",
+    /**
+     * Items worn around the neck, like amulets.
+     */
+    Amulet = "Amulet",
+    /**
+     * Items worn on the torso and upper arms.
+     */
+    Body = "Body",
+    /**
+     * Items worn on the hands, like gloves.
+     */
+    Hands = "Hands",
+    /**
+     * Items that can be used in the non-dominant hand.
+     */
+    LeftHand = "LeftHand",
+    /**
+     * Small items worn around the finger on the non-dominant hand.
+     */
+    LeftRing = "LeftRing",
+    /**
+     * Items that can be used in the dominant hand.
+     */
+    RightHand = "RightHand",
+    /**
+     * Small items worn around the finger on the dominant hand.
+     */
+    RightRing = "RightRing",
+    /**
+     * Items worn on the legs.
+     */
+    Legs = "Legs",
+    /**
+     * Items like boots that are used for walking but may also offer additional protection.
+     */
+    Feet = "Feet",
+    /**
+     * All other type of items. Miscellaneous items cannot be equipped.
+     */
+    Miscellaneous = "Miscellaneous"
+}

package/dist/src/Engine/Interfaces/enumerations/gameState.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Used to determine the UI to show to the player, e.g. the intro or exploration screen.
+ */
+export declare enum GameState {
+    Intro = "Intro",
+    CreateCharacter = "CreateCharacter",
+    Play = "Play",
+    LevelUp = "LevelUp",
+    GameOver = "GameOver",
+    Victory = "Victory"
+}

package/dist/src/Engine/Interfaces/enumerations/playState.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Used to determine the situational UI to show to the player, e.g. the menu or trade screen.
+ */
+export declare enum PlayState {
+    Menu = "Menu",
+    Combat = "Combat",
+    Trade = "Trade",
+    Conversation = "Conversation",
+    Description = "Description"
+}

package/dist/src/Engine/Interfaces/enumerations/targetType.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Used to determine whether an item usable in combat can be used on enemies or party characters.
+ */
+export declare enum TargetType {
+    Ally = "Ally",
+    AllyOrSelf = "AllyOrSelf",
+    Enemy = "Enemy",
+    Self = "Self"
+}

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

@@ -0,0 +1,43 @@
+import { IItem } from './item';
+export interface IEquipment {
+    /**
+     * Items worn on the head, ranging from diadem to helmets covering the entire head.
+     */
+    head?: IItem;
+    /**
+     * Items worn around the neck, like amulets.
+     */
+    amulet?: IItem;
+    /**
+     * Items worn on the torso and upper arms.
+     */
+    body?: IItem;
+    /**
+     * Items worn on the hands, like gloves.
+     */
+    hands?: IItem;
+    /**
+     * Items that can be used in the non-dominant hand.
+     */
+    leftHand?: IItem;
+    /**
+     * Small items worn around the finger on the non-dominant hand.
+     */
+    leftRing?: IItem;
+    /**
+     * Items that can be used in the dominant hand.
+     */
+    rightHand?: IItem;
+    /**
+     * Small items worn around the finger on the dominant hand.
+     */
+    rightRing?: IItem;
+    /**
+     * Items worn on the legs.
+     */
+    legs?: IItem;
+    /**
+     * Items like boots that are used for walking but may also offer additional protection.
+     */
+    feet?: IItem;
+}

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

@@ -0,0 +1,37 @@
+import { ICombinable } from './combinations/combinable';
+import { Sprite } from './sprite';
+/**
+ * A feature of a location, which can be anything the player can interact with using combinations.
+ */
+export interface IFeature extends ICombinable {
+    /**
+     * The description of the feature. Used when features are added to locations
+     * at run-time.
+     */
+    description?: string;
+    /**
+     * The coordinates of this feature when using image maps for visual features.
+     */
+    coords?: string;
+    /**
+     * The shape of this feature when using image maps for visual features.
+     */
+    shape?: string;
+    /**
+     * The file path for the picture to show. When using image maps for visual features, the picture will
+     * be shown on top of the image map for this feature. The path should be relative to the resources folder.
+     * Use either a picture OR an animation.
+     */
+    picture?: string;
+    /**
+     * The animation settings for this feature. When using image maps for visual features, the animation will
+     * be shown on top of the image map for this feature. Use either a picture OR an animation.
+     */
+    animation?: Sprite;
+    /**
+     * This flag controls whether the feature can be interacted with. When not set, it defaults to true. Only when
+     * explicitly set to false can the feature not be interacted with. Non-interactive features can be used to for
+     * example enrich the game in visual adventure games.
+     */
+    interactive?: boolean;
+}

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

@@ -0,0 +1,7 @@
+import { IFeature } from './feature';
+/**
+ * A collection of features of a location.
+ */
+export interface IFeatureCollection extends Array<IFeature> {
+    collectionPicture?: string;
+}

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

@@ -0,0 +1,148 @@
+import { GameState, IAutoplayService, ICharacter, ICombatSetup, ICombatTurn, ICommandService, ICompiledLocation, ICreateCharacter, IFeature, IGameCombinations, IHelpers, ILocation, IMap, IParty, IPerson, ISoundPlayer, IStatistics, ITrade, PlayState, ScoreEntry } from '../..';
+/**
+ * The StoryScript main game object.
+ */
+export interface IGame {
+    /**
+     * The sheet to create a character for the game.
+     */
+    createCharacterSheet?: ICreateCharacter;
+    /**
+     * The player's adventuring party.
+     */
+    party: IParty;
+    /**
+     * The active party character.
+     */
+    activeCharacter: ICharacter;
+    /**
+     * All the locations in the game world.
+     */
+    locations: Record<string, ICompiledLocation> & {
+        get?(id?: string | (() => ILocation) | ICompiledLocation): ICompiledLocation;
+    };
+    /**
+     * All the maps of the game world.
+     */
+    maps: Record<string, IMap> & {
+        get?(id?: string | (() => IMap)): IMap;
+    };
+    /**
+     * The location in the game world the player is currently at.
+     */
+    currentLocation: ICompiledLocation;
+    /**
+     * The location in the game world the player visited before the current one.
+     */
+    previousLocation: ICompiledLocation;
+    /**
+     * The map of the part of the world the player is currently at, if any.
+     */
+    currentMap?: IMap;
+    /**
+     * The high score log for the game.
+     */
+    highScores: ScoreEntry[];
+    /**
+     * A log containing descriptions of player actions during the game.
+     */
+    actionLog: string[];
+    /**
+     * A log containing descriptions of player actions during combat in the game.
+     */
+    combatLog: string[];
+    /**
+     * The current state of the game.
+     */
+    state: GameState;
+    /**
+     * The current state of play of the game.
+     */
+    playState: PlayState;
+    /**
+     * True if the game has started, meaning the user has passed the title screen. False otherwise.
+     */
+    started: boolean;
+    /**
+     * The person the player is currently interacting with.
+     */
+    person: IPerson;
+    /**
+     * The trade object or person the player is currently trading with.
+     */
+    trade: ITrade;
+    /**
+     * The description currently shown to the player.
+     */
+    currentDescription: {
+        /**
+         * The description title.
+         */
+        title: string;
+        /**
+         * The type of the entity for which the description is shown.
+         */
+        type: string;
+        /**
+         * The feature of which to show the description.
+         */
+        item: IFeature;
+    };
+    /**
+     * True if a game is being loaded, false otherwise.
+     */
+    loading: boolean;
+    combinations: IGameCombinations;
+    /**
+     * The custom properties for the game world.
+     */
+    worldProperties: any;
+    /**
+     * The root UI element. You can use this to interact with the UI if you need to.
+     */
+    UIRootElement: HTMLElement;
+    /**
+     * The statistics for this game.
+     */
+    statistics: IStatistics;
+    /**
+     * Helper functions to make programming the game easier.
+     */
+    helpers: IHelpers;
+    /**
+     * The sound player for the game.
+     */
+    sounds: ISoundPlayer;
+    /**
+     * The autoplay service to autoplay (parts of) your game and run your game in demo mode.
+     */
+    autoplay: IAutoplayService;
+    /**
+     * True if autoplay is in progress, false otherwise.
+     */
+    autoplaying: boolean;
+    /**
+     * The command service for programmatic access to your game's interactions.
+     */
+    commands: ICommandService;
+    /**
+     * The setup for the next combat round. This object is used to track
+     * which character attacks which enemy using what item or weapon.
+     */
+    combat: ICombatSetup<ICombatTurn>;
+    /**
+     * Logs a message to the location log.
+     * @param message The message to log
+     */
+    logToLocationLog(message: string): void;
+    /**
+     * Logs a message to the action log.
+     * @param message The message to log
+     */
+    logToActionLog(message: string): void;
+    /**
+     * Logs a message to the combat log.
+     * @param message The message to log
+     */
+    logToCombatLog(message: string): void;
+}

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

@@ -0,0 +1,7 @@
+import { IGame } from '../..';
+export interface IGameEvents {
+    register(eventName: string, throwWhenAlreadyRegistered: boolean): void;
+    subscribe(eventName: string | string[], handler: (game: IGame, eventArguments: {}) => void, throwIfUnknown?: boolean): void;
+    publish(eventName: string, eventArguments: any): void;
+    setGame(game: IGame): void;
+}

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

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

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

@@ -0,0 +1,78 @@
+import { IInterfaceTexts } from './interfaceTexts';
+import { IRules } from './rules/rules';
+import { IGame } from './game';
+import { IParty } from './party';
+import { ICharacter } from './character';
+import { ICombatTurn } from './combatTurn';
+import { ICombatSetup } from './combatSetup';
+import { IEquipment } from './equipment';
+import { IAction } from './action';
+import { IFeature } from './feature';
+import { IFeatureCollection } from './featureCollection';
+import { IItem } from './item';
+import { IGroupableItem } from './groupableItem';
+import { IEnemy } from './enemy';
+import { IPerson } from './person';
+import { ITrade } from './trade';
+import { IKey } from './key';
+import { IQuest } from './quest';
+import { ILocation } from './location';
+import { ICompiledLocation } from './compiledLocation';
+import { IDestination } from './destination';
+import { IBarrier } from './barrier';
+import { IBarrierAction } from './barrierAction';
+import { IHelpers } from './helpers';
+import { DefaultEquipment } from './defaultEquipment';
+import { ICombinable } from './combinations/combinable';
+import { ICombine } from './combinations/combine';
+import { ICombinations } from './combinations/combinations';
+import { IActiveCombination } from './combinations/activeCombination';
+import { ICombinationAction } from './combinations/combinationAction';
+import { ICombineResult } from './combinations/combineResult';
+import { ICombinationMatchResult } from './combinations/combinationMatchResult';
+import { ICreateCharacter } from './createCharacter/createCharacter';
+import { ICreateCharacterStep } from './createCharacter/createCharacterStep';
+import { ICreateCharacterQuestion } from './createCharacter/createCharacterQuestion';
+import { ICreateCharacterQuestionEntry } from './createCharacter/createCharacterQuestionEntry';
+import { ICreateCharacterAttribute } from './createCharacter/createCharacterAttribute';
+import { ICreateCharacterAttributeEntry } from './createCharacter/createCharacterAttributeEntry';
+import { IConversation } from './conversations/conversation';
+import { IConversationNode } from './conversations/conversationNode';
+import { IConversationReply } from './conversations/conversationReply';
+import { IConversationLogEntry } from './conversations/conversationLogEntry';
+import { ICustomCursor } from './customCursor';
+import { ICombatWinnings } from './combatWinnings';
+import { IAutoplayStep } from './autoplayStep';
+import { ISetupRules } from './rules/setupRules';
+import { IGeneralRules } from './rules/generalRules';
+import { ICharacterRules } from './rules/characterRules';
+import { IExplorationRules } from './rules/explorationRules';
+import { ICombatRules } from './rules/combatRules';
+import { IEncounterRules } from './rules/encounterRules';
+import { ICombinationRules } from './rules/combinationRules';
+import { ITitleScreen } from './rules/titleScreen';
+import { ISoundPlayer } from './soundPlayer';
+import { IDemoMode } from './rules/demoMode';
+import { IDynamicStyle } from './dynamicStyle';
+import { IStatistics } from './statistics';
+import { IDefinitions } from './definitions';
+import { IGameEvents } from './gameEvents';
+import { ISaveGame } from './saveGame';
+import { IStock } from './stock';
+import { 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';