@strixit/storyscript 0.0.0-stage → 1.0.0

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

@@ -0,0 +1,47 @@
+import {ICreateCharacter, ICreateCharacterAttribute, ICreateCharacterQuestion, IParty} from 'storyScript';
+
+/**
+ * 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/src/Engine/Interfaces/customCursor.ts

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

package/src/Engine/Interfaces/defaultEquipment.ts

@@ -0,0 +1,32 @@
+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 class DefaultEquipment implements IEquipment {
+    constructor() {
+        this.head = null;
+        this.amulet = null;
+        this.body = null;
+        this.hands = null;
+        this.leftHand = null;
+        this.leftRing = null;
+        this.rightHand = null;
+        this.rightRing = null;
+        this.legs = null;
+        this.feet = null;
+    }
+
+    head: IItem;
+    amulet: IItem;
+    body: IItem;
+    hands: IItem;
+    leftHand: IItem;
+    leftRing: IItem;
+    rightHand: IItem;
+    rightRing: IItem;
+    legs: IItem;
+    feet: IItem;
+}

package/src/Engine/Interfaces/definitions.ts

@@ -0,0 +1,48 @@
+import { ILocation } from './location';
+import { IAction } from './action';
+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/src/Engine/Interfaces/destination.ts

@@ -0,0 +1,37 @@
+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/src/Engine/Interfaces/dynamicStyle.ts

@@ -0,0 +1,11 @@
+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/src/Engine/Interfaces/enemy.ts

@@ -0,0 +1,54 @@
+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/src/Engine/Interfaces/enumerations/actionStatus.ts

@@ -0,0 +1,20 @@
+/**
+ * Used to set the availability of actions to the player.
+ */
+export 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/src/Engine/Interfaces/enumerations/actionType.ts

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

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

@@ -0,0 +1,61 @@
+/**
+ * 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 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/src/Engine/Interfaces/enumerations/gameState.ts

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

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

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

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

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

package/src/Engine/Interfaces/equipment.ts

@@ -0,0 +1,44 @@
+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/src/Engine/Interfaces/feature.ts

@@ -0,0 +1,43 @@
+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/src/Engine/Interfaces/featureCollection.ts

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

package/src/Engine/Interfaces/game.ts

@@ -0,0 +1,201 @@
+import {
+    GameState,
+    IAutoplayService,
+    ICharacter,
+    ICombatSetup,
+    ICombatTurn,
+    ICommandService,
+    ICompiledLocation,
+    ICreateCharacter,
+    IFeature,
+    IGameCombinations,
+    IHelpers,
+    ILocation,
+    IMap,
+    IParty,
+    IPerson,
+    ISoundPlayer,
+    IStatistics,
+    ITrade,
+    PlayState,
+    ScoreEntry
+} from 'storyScript';
+
+/**
+ * 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/src/Engine/Interfaces/gameEvents.ts

@@ -0,0 +1,11 @@
+import {IGame} from 'storyScript';
+
+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
+}