@strixit/storyscript 0.0.0-stage → 1.0.0

package/src/Engine/utilityFunctions.ts

@@ -0,0 +1,238 @@
+import {EquipmentType, IItem, ILocation, IParty}from 'storyScript';
+import {StateProperties} from "./stateProperties";
+
+const functionRenameRegex =  /\$.+/i;
+
+export function compareString(left: string, right: string): boolean {
+    if ((left === undefined && right === undefined) || (left === null && right === null)) {
+        return true;
+    } else if ((left === null || left === undefined) || (right === null || right === undefined)) {
+        return false;
+    }
+
+    return left.toLowerCase() === right.toLowerCase();
+}
+
+export function getId(id: Function | string) {
+    let actualId: string;
+
+    if (typeof id === 'function') {
+        // This is a workaround with function names changing when building for production.
+        // With Vite 7, we have e.g. Start becoming Start$2.
+        /* v8 ignore next 3 */
+        actualId = id.name.replace(functionRenameRegex, '');
+    } else {
+        actualId = id;
+    }
+
+    return actualId?.toLowerCase();
+}
+
+export function isDataRecord(item: any[]): boolean {
+    // Check for either object or function values, as tuples are used to store actions as objects and functions now.
+    return item?.length && item.length === 2 && typeof (item[0]) === 'string' && (typeof (item[1]) === 'object' || typeof (item[1]) === 'function');
+}
+
+export function getKeyPropertyNames(item: any, includeUniqueIds?: boolean): { first: string, second: string } {
+    if (item === undefined) {
+        return {first: null, second: null};
+    }
+
+    if (isDataRecord(item)) {
+        return {first: '0', second: null};
+    }
+
+    let firstKeyProperty = includeUniqueIds && item[StateProperties.Id] !== undefined ? <string>StateProperties.Id : null;
+    firstKeyProperty ??= item.id !== undefined ? 'id' : null;
+    firstKeyProperty ??= item.target !== undefined ? 'target' : null;
+    firstKeyProperty ??= item.tool !== undefined ? 'tool' : null;
+    let secondKeyProperty = item.type !== undefined ? 'type' : null;
+    secondKeyProperty ??= item.combinationType !== undefined ? 'combinationType' : null;
+
+    return {first: firstKeyProperty, second: secondKeyProperty};
+}
+
+export function propertyMatch(first: any, second: any): boolean {
+    if (first === undefined || second === undefined) {
+        return false;
+    }
+
+    let {first: firstProperty, second: secondProperty} = getKeyProperties(first, second);
+
+    if (firstProperty && secondProperty) {
+        return getValue(first[firstProperty]) === getValue(second[firstProperty])
+            && getValue(first[secondProperty]) === getValue(second[secondProperty]);
+    }
+
+    if (firstProperty || secondProperty) {
+        return (firstProperty && getValue(first[firstProperty]) === getValue(second[firstProperty])) ||
+            (secondProperty && getValue(first[secondProperty]) === getValue(second[secondProperty]));
+    }
+
+    return false;
+}
+
+export function getPlural(name: string): string {
+    let plural: string;
+
+    if (name.endsWith('y')) {
+        plural = name.substring(0, name.length - 1) + 'ies';
+    } else if (name.endsWith('s')) {
+        plural = name;
+    } else {
+        plural = name + 's';
+    }
+
+    return plural;
+}
+
+export function getSingular(name: string): string {
+    let singular: string;
+
+    if (name.endsWith('ies')) {
+        singular = name.substring(0, name.length - 3) + 'y';
+    } else if (name.endsWith('e')) {
+        singular = name
+    } else {
+        singular = name.substring(0, name.length - 1);
+    }
+
+    return singular;
+}
+
+export function parseHtmlDocumentFromString(document: string) {
+    const parser = new DOMParser();
+    return parser.parseFromString(document, 'text/html');
+}
+
+export function addHtmlSpaces(text: string): string {
+    if (!text) {
+        return null;
+    }
+
+    if (text.substring(0, 1).trim() !== '' && !text.startsWith('&nbsp;')) {
+        text = '&nbsp;' + text;
+    }
+
+    if (text.substring(text.length - 1, 1).trim() !== '' && text.substring(text.length - 6, 6) !== '&nbsp;') {
+        text = text + '&nbsp;';
+    }
+
+    return text;
+}
+
+export function isEmpty(object: any, property?: string) {
+    const objectToCheck = property ? object[property] : object;
+
+    if (objectToCheck) {
+        return Array.isArray(objectToCheck) ? objectToCheck.length === 0 : Object.keys(objectToCheck).length === 0;
+    }
+
+    return true;
+}
+
+export function equals<T extends { id?: string } | ILocation>(entity: T | string, definition: () => T): boolean {
+    const id = (entity as { id?: string })?.id ?? getId(entity as Function);
+    return id ? compareString(id, definition.name) : false;
+}
+
+export function hasItem(party: IParty, item: IItem | string): boolean {
+    let hasItem = false;
+
+    // Check item available. Item list first, equipment second.
+    party.characters.forEach(c => {
+        if (hasItem) {
+            return;
+        }
+
+        hasItem = c.items.get(item) !== undefined;
+
+        if (hasItem) {
+            return;
+        }
+        
+        for (const i in c.equipment) {
+            const slotItem = <IItem>c.equipment[i];
+            hasItem = slotItem && compareString(slotItem.id, (item as IItem)?.id ?? item as string);
+
+            if (hasItem) {
+                return;
+            }
+        }
+    });
+    
+    return hasItem;
+}
+
+export function createPromiseForCallback<T>(callBack: Function): { promise: Promise<T>, promiseCallback: () => void } {
+    let resolveFunc = null;
+
+    const promiseCallback = () => {
+        const callBackResult = callBack();
+        Promise.resolve(callBackResult).then(() => {
+            resolveFunc?.();
+        });
+    }
+
+    const promiseFunc = function (resolve: any) {
+        resolveFunc = resolve;
+    }
+
+    const promise = new Promise<T>(promiseFunc);
+
+    return {promise, promiseCallback};
+}
+
+export function wait(timeInMs: number, callBack: Function): Promise<void> {
+    const {promise, promiseCallback} = createPromiseForCallback<void>(callBack);
+
+    setTimeout(() => {
+        promiseCallback();
+    }, timeInMs);
+
+    return promise;
+}
+
+export function interval(intervalTimeInMs: number, repeat: number, intervalCallback: Function, finalCallback?: Function): Promise<void> {
+    const {promise, promiseCallback} = createPromiseForCallback<void>(finalCallback ?? (() => {
+    }));
+
+    let count = 0;
+
+    const interval = setInterval(() => {
+        count++;
+        intervalCallback();
+
+        if (count >= repeat) {
+            clearInterval(interval);
+
+            if (finalCallback) {
+                setTimeout(() => {
+                    promiseCallback();
+                }, intervalTimeInMs);
+            } else {
+                promiseCallback();
+            }
+        }
+    }, intervalTimeInMs);
+
+    return promise;
+}
+
+export function getEquipmentType(slot: EquipmentType | string): string {
+    const type = EquipmentType[slot] ?? slot;
+    return type.substring(0, 1).toLowerCase() + type.substring(1);
+}
+
+function getKeyProperties(pristine: any, current: any): { first?: string, second?: string } {
+    const {first: pristineFirst, second: pristineSecond} = getKeyPropertyNames(pristine, true);
+    const {first: currentFirst, second: currentSecond} = getKeyPropertyNames(current, true);
+    return {
+        first: pristineFirst && currentFirst ? pristineFirst : null,
+        second: pristineSecond && currentSecond ? pristineSecond : null
+    };
+}
+
+function getValue(value: any): string {
+    return typeof value === 'function' ? value.name.toLowerCase() : value;
+}

package/src/Games/_GameTemplate/character.ts

@@ -0,0 +1,31 @@
+import { ICharacter } from 'storyScript';
+import { IItem, IEquipment } from './types';
+
+export class Character implements ICharacter {
+    name: string = '';
+    hitpoints: number = 10;
+    currentHitpoints: number;
+
+    // Add character properties here.
+
+    items: IItem[] = [];
+
+    equipment: IEquipment = {};
+
+    constructor() {
+        this.equipment = {
+            // Remove the slots you don't want to use. Remove them from your IEquipment interface too!
+            head: null,
+            amulet: null,
+            body: null,
+            hands: null,
+            leftHand: null,
+            leftRing: null,
+            rightHand: null,
+            rightRing: null,
+            legs: null,
+            feet: null
+            // Add your custom slots here. Make sure they are also present in your IEquipment interface.
+        }
+    }
+}

package/src/Games/_GameTemplate/customTexts.ts

@@ -0,0 +1,8 @@
+import { IInterfaceTexts } from 'storyScript';
+
+export function CustomTexts(): IInterfaceTexts {
+        return {
+        // Add your custom texts here.
+        
+    };
+}

package/src/Games/_GameTemplate/interfaces/action.ts

@@ -0,0 +1,5 @@
+import {IAction as StoryScriptIAction} from 'storyScript';
+
+export interface IAction extends StoryScriptIAction {
+    // Add game-specific action properties here
+}

package/src/Games/_GameTemplate/interfaces/combatSetup.ts

@@ -0,0 +1,7 @@
+import {ICombatSetup as StoryScriptCombatSetup} from 'storyScript';
+import {Character, ICombatTurn, IEnemy} from '../types';
+
+export interface ICombatSetup extends StoryScriptCombatSetup<ICombatTurn> {
+    characters: Character[],
+    enemies: IEnemy[],
+}

package/src/Games/_GameTemplate/interfaces/combatTurn.ts

@@ -0,0 +1,8 @@
+import { ICombatTurn as StoryScriptCombatTurn } from 'storyScript';
+import { Character, IEnemy, IItem } from '../types';
+
+export interface ICombatTurn extends StoryScriptCombatTurn {
+    character: Character;
+    target: IEnemy;
+    item?: IItem;
+}

package/src/Games/_GameTemplate/interfaces/destination.ts

@@ -0,0 +1,5 @@
+import { IDestination as StoryScriptIDestination } from 'storyScript';
+
+export interface IDestination extends StoryScriptIDestination {
+    // Add game-specific enemy properties here
+}

package/src/Games/_GameTemplate/interfaces/enemy.ts

@@ -0,0 +1,11 @@
+import { IEnemy as StoryScriptIEnemy, Enemy as StoryScriptEnemy } from 'storyScript';
+import { IFeature, IItem } from '../types';
+
+export function Enemy(entity: IEnemy): IEnemy {
+    return StoryScriptEnemy(entity);
+}
+
+export interface IEnemy extends IFeature, StoryScriptIEnemy {
+    items?: IItem[];
+    // Add game-specific enemy properties here
+}

package/src/Games/_GameTemplate/interfaces/equipment.ts

@@ -0,0 +1,5 @@
+import { IEquipment as StoryScriptIEquipment } from 'storyScript';
+
+export interface IEquipment extends StoryScriptIEquipment {
+    // Add game-specific equipment slots here
+}

package/src/Games/_GameTemplate/interfaces/feature.ts

@@ -0,0 +1,9 @@
+import { IFeature as StoryScriptIFeature, Feature as StoryScriptFeature } from 'storyScript';
+
+export function Feature(entity: IFeature): IFeature {
+    return StoryScriptFeature(entity);
+}
+
+export interface IFeature extends StoryScriptIFeature {
+    // Add game-specific item properties here
+}

package/src/Games/_GameTemplate/interfaces/game.ts

@@ -0,0 +1,22 @@
+import { IGame as StoryScriptIGame, IHelpers as StoryScriptIHelpers } from 'storyScript';
+import { IPerson, ICompiledLocation, Character, ILocation, IEnemy, IItem, IParty } from '../types';
+
+// Your game-specific game interface.
+export interface IGame extends StoryScriptIGame {
+    party: IParty,
+    activeCharacter: Character;
+    person: IPerson;
+    locations: Record<string, ICompiledLocation> & {
+        get?(id?: string | (() => ILocation) | ICompiledLocation): ICompiledLocation;
+    };
+    currentLocation: ICompiledLocation;
+    previousLocation: ICompiledLocation;
+    helpers: IHelpers;
+}
+
+export interface IHelpers extends StoryScriptIHelpers {
+    randomEnemy: (selector?: (enemy: IEnemy) => boolean) => IEnemy;
+    randomItem: (selector?: (enemy: IItem) => boolean) => IItem;
+    getEnemy: (selector: string) => IEnemy;
+    getItem: (selector: string) => IItem;
+}

package/src/Games/_GameTemplate/interfaces/interfaceTexts.ts

@@ -0,0 +1,5 @@
+import { IInterfaceTexts as StortScriptInterfaceTexts } from 'storyScript';
+
+export interface IInterfaceTexts extends StortScriptInterfaceTexts {
+    // Add game-specific interface texts here
+}

package/src/Games/_GameTemplate/interfaces/item.ts

@@ -0,0 +1,18 @@
+import {
+    IGroupableItem as StoryScriptIGroupableItem,
+    IItem as StoryScriptIItem,
+    Item as StoryScriptItem
+} from 'storyScript';
+import {IFeature} from '../types';
+
+export function Item<T extends IItem>(entity: T): T {
+    return StoryScriptItem(entity);
+}
+
+export interface IItem extends IFeature, StoryScriptIItem {
+    // Add game-specific item properties here
+}
+
+export interface IGroupableItem extends IItem, StoryScriptIGroupableItem<IItem> {
+    // Add game-specific item properties here
+}

package/src/Games/_GameTemplate/interfaces/key.ts

@@ -0,0 +1,10 @@
+import { IKey as StoryScriptIKey, Key as StoryScriptKey } from 'storyScript';
+import { IItem } from '../types';
+
+export function Key(entity: IKey): IKey {
+    return StoryScriptKey(entity);
+}
+
+export interface IKey extends IItem, StoryScriptIKey {
+    // Add game-specific key properties here
+}

package/src/Games/_GameTemplate/interfaces/location.ts

@@ -0,0 +1,22 @@
+import { IDestination, IEnemy, IItem, IPerson } from '../types';
+import { ILocation as StoryScriptILocation, Location as StoryScriptLocation, ICompiledLocation as StoryScriptICompiledLocation } from 'storyScript';
+
+export function Location(entity: ILocation): ILocation  {
+    return StoryScriptLocation(entity);
+}
+
+export interface ILocation extends StoryScriptILocation {
+    destinations?: IDestination[];
+    enemies?: IEnemy[];
+    items?: IItem[];
+    persons?: IPerson[];
+    // Add game-specific location properties here
+}
+
+export interface ICompiledLocation extends ILocation, StoryScriptICompiledLocation {
+    destinations?: IDestination[];
+    enemies?: IEnemy[];
+    items?: IItem[];
+    persons?: IPerson[];
+    // Add game-specific location properties here
+}

package/src/Games/_GameTemplate/interfaces/map.ts

@@ -0,0 +1,16 @@
+import { IMap as StoryScriptIMap, LocationMap as StoryScriptLocationMap, IMapLocation as StoryScriptIMapLocation } from 'storyScript';
+import {ILocation} from "./location";
+
+export function LocationMap(entity: IMap): IMap  {
+    return StoryScriptLocationMap(entity);
+}
+
+export interface IMap extends StoryScriptIMap {
+    locations: IMapLocation[];
+    // Add game-specific location properties here
+}
+
+export interface IMapLocation extends StoryScriptIMapLocation {
+    location: (() => ILocation) | string;
+    // Add game-specific location properties here
+}

package/src/Games/_GameTemplate/interfaces/party.ts

@@ -0,0 +1,8 @@
+import { IParty as StoryScriptIParty } from 'storyScript';
+import { Character, IQuest } from '../types';
+
+
+export interface IParty extends StoryScriptIParty {
+    characters: Character[];
+    quests?: IQuest[];
+}

package/src/Games/_GameTemplate/interfaces/person.ts

@@ -0,0 +1,11 @@
+import { IPerson as StoryScriptIPerson, Person as StoryScriptPerson } from 'storyScript';
+import { IEnemy, IItem, IQuest } from '../types';
+
+export function Person(entity: IPerson): IPerson {
+    return StoryScriptPerson(entity);
+}
+
+export interface IPerson extends IEnemy, StoryScriptIPerson {
+    items?: IItem[];
+    quests?: IQuest[];
+}

package/src/Games/_GameTemplate/interfaces/quest.ts

@@ -0,0 +1,9 @@
+import { IQuest as StoryScriptIQuest, Quest as StoryScriptQuest } from 'storyScript';
+
+export function Quest(entity: IQuest): IQuest {
+    return StoryScriptQuest(entity);
+}
+
+export interface IQuest extends StoryScriptIQuest {
+    // Add game-specific item properties here
+}

package/src/Games/_GameTemplate/locations/Start.html

@@ -0,0 +1,5 @@
+<description>
+    <p>
+        Your adventure starts here!
+    </p>
+</description>

package/src/Games/_GameTemplate/locations/start.ts

@@ -0,0 +1,12 @@
+import { Location } from '../types'
+import description from './Start.html?raw'
+
+export function Start() {
+    return Location({
+        name: 'Start',
+        description: description,
+        destinations: [
+            
+        ]
+    });
+}

package/src/Games/_GameTemplate/rules.ts

@@ -0,0 +1,60 @@
+import {ICharacter, ICreateCharacter, IRules} from 'storyScript';
+import {Character, ICombatSetup, IEnemy, IGame} from './types';
+
+export function Rules(): IRules {
+    return {
+        setup: {},
+
+        combinations: {
+            combinationActions: [
+                // Add combination action names here if you want to use this feature.
+            ]
+        },
+
+        general: {
+            scoreChange: (game: IGame, change: number): boolean => {
+                // Implement logic to occur when the score changes. Return true when the character gains a level.
+                return false;
+            }
+        },
+
+        character: {
+            getSheetAttributes: (): string[] => {
+                return [
+                    // Add the character attributes that you want to show on the character sheet here
+                ];
+            },
+
+            getCreateCharacterSheet: (): ICreateCharacter => {
+                return {
+                    steps: [
+                        // Add the character creation steps here, if you want to use character creation.
+                    ]
+                };
+            },
+
+            createCharacter: (game: IGame, characterData: ICreateCharacter): ICharacter => {
+                var character = new Character();
+                return character;
+            }
+        },
+
+        exploration: {},
+
+        combat: {
+            fight: (game: IGame, combatSetup: ICombatSetup, retaliate?: boolean) => {
+                retaliate = retaliate ?? retaliate;
+
+                // Implement character attack here.
+
+                if (retaliate) {
+                    game.currentLocation.enemies.filter((enemy: IEnemy) => {
+                        return enemy.currentHitpoints > 0;
+                    }).forEach(enemy => {
+                        // Implement monster attack here
+                    });
+                }
+            }
+        },
+    };
+}

package/src/Games/_GameTemplate/types.ts

@@ -0,0 +1,55 @@
+import {IParty} from './interfaces/party';
+import {IDestination} from './interfaces/destination';
+import {Feature, IFeature} from './interfaces/feature';
+import {IGroupableItem, IItem, Item} from './interfaces/item';
+import {IKey, Key} from './interfaces/key';
+import {Enemy, IEnemy} from './interfaces/enemy';
+import {IPerson, Person} from './interfaces/person';
+import {IQuest, Quest} from './interfaces/quest';
+import {ICompiledLocation, ILocation, Location} from './interfaces/location';
+import {IEquipment} from './interfaces/equipment';
+import {IGame} from './interfaces/game';
+import {CustomTexts} from './customTexts';
+import {Rules} from './rules';
+import {Character} from './character';
+import {ICombatSetup} from './interfaces/combatSetup';
+import {ICombatTurn} from './interfaces/combatTurn';
+import {IMap, IMapLocation, LocationMap} from './interfaces/map';
+import {IInterfaceTexts} from './interfaces/interfaceTexts';
+import {IAction} from './interfaces/action';
+
+export type {
+    IAction,
+    IParty,
+    IDestination,
+    IFeature,
+    IItem,
+    IGroupableItem,
+    IKey,
+    IEnemy,
+    IPerson,
+    IQuest,
+    ILocation,
+    IMap,
+    IMapLocation,
+    ICompiledLocation,
+    IEquipment,
+    IGame,
+    ICombatSetup,
+    ICombatTurn,
+    IInterfaceTexts
+}
+
+export {
+    Feature,
+    Item,
+    Key,
+    Enemy,
+    Person,
+    Quest,
+    Location,
+    LocationMap,
+    CustomTexts,
+    Rules,
+    Character
+}

package/src/Games/_GameTemplate/ui/styles/game.css

@@ -0,0 +1,3 @@
+.back-label {
+    display: none;
+}

package/src/Games/_GameTemplate/webroot/gameinfo.json

@@ -0,0 +1,10 @@
+{
+    "name": "",
+    "description": "",
+    "picture": "",
+    "sourcesIncluded": false,
+    "authors": [{
+        "name": "",
+        "email": ""
+    }]
+}

package/src/Tests/Games/_GameTemplate/specs/rules.test.ts

@@ -0,0 +1,9 @@
+import { describe, test, expect } from 'vitest';
+
+describe("Rules", function() {
+
+    test("should test one of your rules", function() {
+
+    });
+
+});