bard-legends-framework 0.11.0 → 0.12.1

package/dist/pixi/pixi-definitions.js

@@ -0,0 +1,37 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BlendMode = exports.DEFAULT_RESOLUTION = void 0;
+const Pixi = __importStar(require("pixi.js"));
+exports.DEFAULT_RESOLUTION = 2;
+var BlendMode;
+(function (BlendMode) {
+    BlendMode[BlendMode["Normal"] = 0] = "Normal";
+    BlendMode[BlendMode["Add"] = 1] = "Add";
+    BlendMode[BlendMode["Screen"] = 3] = "Screen";
+    BlendMode[BlendMode["Luminosity"] = 16] = "Luminosity";
+    BlendMode[BlendMode["ColorDodge"] = 7] = "ColorDodge";
+})(BlendMode || (exports.BlendMode = BlendMode = {}));
+//# sourceMappingURL=pixi-definitions.js.map

package/dist/pixi/services/keyboard/keyboard.d.ts

@@ -4,8 +4,8 @@ export declare class KeyboardService {
     readonly keyPressed: import("actions-lib").Notifier<string>;
     readonly _keyReleased: Action<string>;
     readonly keyReleased: import("actions-lib").Notifier<string>;
-    private listOfPressedKeys;
-    private listOfJustPressedKeys;
+    private _listOfPressedKeys;
+    private _listOfJustPressedKeys;
     constructor();
     isKeyDown(key: string): boolean;
     isKeyJustPressed(key: string): boolean;

package/dist/pixi/services/keyboard/keyboard.js

@@ -19,31 +19,31 @@ let KeyboardService = class KeyboardService {
         this.keyPressed = this._keyPressed.notifier;
         this._keyReleased = new actions_lib_1.Action();
         this.keyReleased = this._keyReleased.notifier;
-        this.listOfPressedKeys = new Set();
-        this.listOfJustPressedKeys = new Set();
+        this._listOfPressedKeys = new Set();
+        this._listOfJustPressedKeys = new Set();
         window.addEventListener('keydown', event => {
-            this.listOfPressedKeys.add(event.key);
-            this.listOfJustPressedKeys.add(event.key);
+            this._listOfPressedKeys.add(event.key);
+            this._listOfJustPressedKeys.add(event.key);
             !event.repeat && this._keyPressed.trigger(event.key);
         });
         window.addEventListener('keyup', event => {
-            this.listOfPressedKeys.delete(event.key);
+            this._listOfPressedKeys.delete(event.key);
             this._keyReleased.trigger(event.key);
         });
         window.addEventListener('blur', () => {
-            this.listOfPressedKeys.clear();
+            this._listOfPressedKeys.clear();
         });
         game_entities_1.UpdateCycle.afterSceneUpdateAction
             .subscribe(() => {
-            this.listOfJustPressedKeys.clear();
+            this._listOfJustPressedKeys.clear();
         })
             .attachToRoot();
     }
     isKeyDown(key) {
-        return this.listOfPressedKeys.has(key);
+        return this._listOfPressedKeys.has(key);
     }
     isKeyJustPressed(key) {
-        return this.listOfJustPressedKeys.has(key);
+        return this._listOfJustPressedKeys.has(key);
     }
 };
 exports.KeyboardService = KeyboardService;

package/dist/pixi/services/mouse/mouse-target-focus.service.d.ts

@@ -2,20 +2,20 @@ import { Action } from 'actions-lib';
 import { Vector } from 'helpers-lib';
 import { MouseService } from './mouse.service';
 export declare class MouseTargetFocusService {
-    private mouseService;
+    private _mouseService;
     readonly _onTargetFocus: Action<Vector>;
     readonly onTargetFocus: import("actions-lib").Notifier<Vector>;
     get focusedInLastFrame(): boolean;
     get lastFocusedPosition(): Vector | undefined;
-    private mouseStagePositionPrevious;
-    private peakValueChange;
-    private timePassFromLastTrigger;
-    private triggerAfterCooldown;
+    private _mouseStagePositionPrevious;
+    private _peakValueChange;
+    private _timePassFromLastTrigger;
+    private _triggerAfterCooldown;
     private _focusedInLastFrame;
     private _lastFocusedPosition;
-    constructor(mouseService: MouseService);
-    private update;
-    private check;
-    private iterateValues;
-    private getPositionChange;
+    constructor(_mouseService: MouseService);
+    private _update;
+    private _check;
+    private _iterateValues;
+    private _getPositionChange;
 }

package/dist/pixi/services/mouse/mouse-target-focus.service.js

@@ -22,58 +22,58 @@ let MouseTargetFocusService = class MouseTargetFocusService {
     get lastFocusedPosition() {
         return this._lastFocusedPosition;
     }
-    constructor(mouseService) {
-        this.mouseService = mouseService;
+    constructor(_mouseService) {
+        this._mouseService = _mouseService;
         this._onTargetFocus = new actions_lib_1.Action();
         this.onTargetFocus = this._onTargetFocus.notifier;
-        this.timePassFromLastTrigger = 0;
-        this.triggerAfterCooldown = false;
+        this._timePassFromLastTrigger = 0;
+        this._triggerAfterCooldown = false;
         this._focusedInLastFrame = false;
         this._lastFocusedPosition = undefined;
         update_cycle_1.UpdateCycle.beforeSceneUpdateAction
-            .subscribe((event) => this.update(event.delta))
+            .subscribe((event) => this._update(event.delta))
             .attachToRoot();
     }
-    update(delta) {
-        if (this.mouseStagePositionPrevious) {
-            let mousePositionChange = this.getPositionChange(this.mouseService.getStagePosition(), this.mouseStagePositionPrevious);
-            if (this.peakValueChange === undefined) {
-                this.peakValueChange = mousePositionChange;
+    _update(delta) {
+        if (this._mouseStagePositionPrevious) {
+            let mousePositionChange = this._getPositionChange(this._mouseService.getStagePosition(), this._mouseStagePositionPrevious);
+            if (this._peakValueChange === undefined) {
+                this._peakValueChange = mousePositionChange;
             }
             else {
-                this.check(mousePositionChange, delta);
+                this._check(mousePositionChange, delta);
             }
         }
-        this.mouseStagePositionPrevious = this.mouseService.getStagePosition();
+        this._mouseStagePositionPrevious = this._mouseService.getStagePosition();
     }
-    check(mousePositionChange, delta) {
-        if (this.peakValueChange - mousePositionChange > 10) {
-            this.timePassFromLastTrigger = Math.max(250, this.timePassFromLastTrigger);
-            this.triggerAfterCooldown = true;
+    _check(mousePositionChange, delta) {
+        if (this._peakValueChange - mousePositionChange > 10) {
+            this._timePassFromLastTrigger = Math.max(250, this._timePassFromLastTrigger);
+            this._triggerAfterCooldown = true;
         }
-        else if (this.timePassFromLastTrigger > 1000) {
-            this.triggerAfterCooldown = true;
+        else if (this._timePassFromLastTrigger > 1000) {
+            this._triggerAfterCooldown = true;
         }
-        let focusHappened = this.timePassFromLastTrigger >= 300 && this.triggerAfterCooldown;
-        this.iterateValues(focusHappened, mousePositionChange, delta);
+        let focusHappened = this._timePassFromLastTrigger >= 300 && this._triggerAfterCooldown;
+        this._iterateValues(focusHappened, mousePositionChange, delta);
     }
-    iterateValues(focusHappened, mousePositionChange, delta) {
-        if (focusHappened || mousePositionChange > this.peakValueChange) {
-            this.peakValueChange = mousePositionChange;
+    _iterateValues(focusHappened, mousePositionChange, delta) {
+        if (focusHappened || mousePositionChange > this._peakValueChange) {
+            this._peakValueChange = mousePositionChange;
         }
         if (focusHappened) {
-            this.triggerAfterCooldown = false;
-            this.timePassFromLastTrigger = 0;
+            this._triggerAfterCooldown = false;
+            this._timePassFromLastTrigger = 0;
             this._focusedInLastFrame = true;
-            this._lastFocusedPosition = this.mouseService.getStagePosition();
+            this._lastFocusedPosition = this._mouseService.getStagePosition();
             this._onTargetFocus.trigger(this._lastFocusedPosition);
         }
         else {
-            this.timePassFromLastTrigger += delta;
+            this._timePassFromLastTrigger += delta;
             this._focusedInLastFrame = false;
         }
     }
-    getPositionChange(positionA, positionB) {
+    _getPositionChange(positionA, positionB) {
         let changeVector = helpers_lib_1.Vector.fromTo(positionA, positionB);
         return Math.abs(changeVector.x) + Math.abs(changeVector.y);
     }

package/dist/pixi/services/mouse/mouse.service.d.ts

@@ -17,5 +17,5 @@ export declare class MouseService {
     readonly secondaryButtonState: import("actions-lib").Notifier<boolean>;
     getSecondaryButtonState(): boolean;
     constructor();
-    private startListeningMouseMove;
+    private _startListeningMouseMove;
 }

package/dist/pixi/services/mouse/mouse.service.js

@@ -14,7 +14,7 @@ const actions_lib_1 = require("actions-lib");
 const helpers_lib_1 = require("helpers-lib");
 const service_1 = require("../../../game-entities/service/service");
 const update_cycle_1 = require("../../../game-entities/update-cycle");
-const __1 = require("../..");
+const game_1 = require("../../game");
 let MouseService = class MouseService {
     get initialMouseMoveHappened() {
         return this._initialMouseMovementHappened.value;
@@ -42,7 +42,7 @@ let MouseService = class MouseService {
         this.mainButtonState = this._mainButtonState.notifier;
         this._secondaryButtonState = new actions_lib_1.Variable(false);
         this.secondaryButtonState = this._secondaryButtonState.notifier;
-        this.startListeningMouseMove();
+        this._startListeningMouseMove();
         window.addEventListener('mousedown', event => {
             if (event.button === 0) {
                 this._mainButtonState.value = true;
@@ -64,7 +64,7 @@ let MouseService = class MouseService {
             this._secondaryButtonState.value = false;
         });
     }
-    startListeningMouseMove() {
+    _startListeningMouseMove() {
         let mouseScreenPosition = helpers_lib_1.Vector.zero;
         window.addEventListener('mousemove', event => {
             mouseScreenPosition = new helpers_lib_1.Vector(event.clientX, event.clientY);
@@ -77,10 +77,10 @@ let MouseService = class MouseService {
             .attachToRoot();
         update_cycle_1.UpdateCycle.afterSceneUpdateAction
             .subscribe(() => {
-            let newStagePosition = __1.Game.instance.screenPositonToStagePosition(this._screenPosition.value);
+            let newStagePosition = game_1.Game.instance.screenPositonToStagePosition(this._screenPosition.value);
             if (newStagePosition.isEqual(this._stagePosition.value)) {
                 // Trigger pointer move event, because content might slide under the mouse cursor
-                __1.Game.instance.renderer.events['onPointerMove'](new PointerEvent('pointermove', {
+                game_1.Game.instance.renderer.events['onPointerMove'](new PointerEvent('pointermove', {
                     clientX: this._screenPosition.value.x,
                     clientY: this._screenPosition.value.y,
                     pointerType: 'mouse'

package/dist/utilities/animator/animating-content/fade-in-content.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utilities/animator/animating-content/fade-in-content.test.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const fade_in_content_1 = require("./fade-in-content");
+(0, vitest_1.describe)('Fade In Content', () => {
+    (0, vitest_1.test)('should exist', () => {
+        (0, vitest_1.expect)(fade_in_content_1.FadeInContent).toBeDefined();
+    });
+});
+//# sourceMappingURL=fade-in-content.test.js.map

package/dist/utilities/animator/animating-content/slide-in-content.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utilities/animator/animating-content/slide-in-content.test.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const slide_in_content_1 = require("./slide-in-content");
+(0, vitest_1.describe)('Slide In Content', () => {
+    (0, vitest_1.test)('should exist', () => {
+        (0, vitest_1.expect)(slide_in_content_1.SlideInContent).toBeDefined();
+    });
+});
+//# sourceMappingURL=slide-in-content.test.js.map

package/dist/utilities/animator/animations.d.ts

@@ -10,28 +10,36 @@ export declare class AnimationInterpolationFunctions {
     static easeInOut(time: number): number;
     static easeInOutCubic(t: number): number;
 }
-export declare class AnimationLineer implements AnimatorAnimation {
+declare class AnimationLineer implements AnimatorAnimation {
     start(): void;
     multiplierFunction(t: number): number;
 }
-export declare class AnimationEaseIn implements AnimatorAnimation {
+declare class AnimationEaseIn implements AnimatorAnimation {
     start(): void;
     multiplierFunction(t: number): number;
 }
-export declare class AnimationEaseOut implements AnimatorAnimation {
+declare class AnimationEaseOut implements AnimatorAnimation {
     start(): void;
     multiplierFunction(t: number): number;
 }
-export declare class AnimationEaseInOut implements AnimatorAnimation {
+declare class AnimationEaseInOut implements AnimatorAnimation {
     start(): void;
     multiplierFunction(t: number): number;
 }
-export declare class AnimationEaseInOutCubic implements AnimatorAnimation {
+declare class AnimationEaseInOutCubic implements AnimatorAnimation {
     start(): void;
     multiplierFunction(t: number): number;
 }
 export declare class AnimationFlicker implements AnimatorAnimation {
-    private timeGrid;
+    private _timeGrid;
     start(): void;
     multiplierFunction(t: number): number;
 }
+export declare class Animations {
+    static lineer: AnimationLineer;
+    static easeIn: AnimationEaseIn;
+    static easeOut: AnimationEaseOut;
+    static easeInOut: AnimationEaseInOut;
+    static easeInOutCubic: AnimationEaseInOutCubic;
+}
+export {};

package/dist/utilities/animator/animations.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AnimationFlicker = exports.AnimationEaseInOutCubic = exports.AnimationEaseInOut = exports.AnimationEaseOut = exports.AnimationEaseIn = exports.AnimationLineer = exports.AnimationInterpolationFunctions = void 0;
+exports.Animations = exports.AnimationFlicker = exports.AnimationInterpolationFunctions = void 0;
 const helpers_lib_1 = require("helpers-lib");
 class AnimationInterpolationFunctions {
     static boomerangTime(time) {
@@ -36,53 +36,57 @@ class AnimationLineer {
         return AnimationInterpolationFunctions.lineer(t);
     }
 }
-exports.AnimationLineer = AnimationLineer;
 class AnimationEaseIn {
     start() { }
     multiplierFunction(t) {
         return AnimationInterpolationFunctions.easeIn(t);
     }
 }
-exports.AnimationEaseIn = AnimationEaseIn;
 class AnimationEaseOut {
     start() { }
     multiplierFunction(t) {
         return AnimationInterpolationFunctions.easeOut(t);
     }
 }
-exports.AnimationEaseOut = AnimationEaseOut;
 class AnimationEaseInOut {
     start() { }
     multiplierFunction(t) {
         return AnimationInterpolationFunctions.easeInOut(t);
     }
 }
-exports.AnimationEaseInOut = AnimationEaseInOut;
 class AnimationEaseInOutCubic {
     start() { }
     multiplierFunction(t) {
         return AnimationInterpolationFunctions.easeInOutCubic(t);
     }
 }
-exports.AnimationEaseInOutCubic = AnimationEaseInOutCubic;
+// Because AnimationFlicker is holding a state "timeGrid", it has to be a seperate instance on where it is used
 class AnimationFlicker {
     start() {
-        this.timeGrid = new Array(10).fill(0);
+        this._timeGrid = new Array(10).fill(0);
         helpers_lib_1.Random.integerBetween(0, 9);
-        this.timeGrid[helpers_lib_1.Random.integerBetween(0, 9)] = Math.random();
+        this._timeGrid[helpers_lib_1.Random.integerBetween(0, 9)] = Math.random();
         if (Math.random() < 0.3) {
             helpers_lib_1.Random.integerBetween(0, 9);
-            this.timeGrid[helpers_lib_1.Random.integerBetween(0, 9)] = Math.random();
+            this._timeGrid[helpers_lib_1.Random.integerBetween(0, 9)] = Math.random();
         }
         if (Math.random() < 0.2) {
             helpers_lib_1.Random.integerBetween(0, 9);
-            this.timeGrid[helpers_lib_1.Random.integerBetween(0, 9)] = Math.random();
+            this._timeGrid[helpers_lib_1.Random.integerBetween(0, 9)] = Math.random();
         }
     }
     multiplierFunction(t) {
         let index = Math.floor(t * 10);
-        return this.timeGrid[index];
+        return this._timeGrid[index];
     }
 }
 exports.AnimationFlicker = AnimationFlicker;
+class Animations {
+    static { this.lineer = new AnimationLineer(); }
+    static { this.easeIn = new AnimationEaseIn(); }
+    static { this.easeOut = new AnimationEaseOut(); }
+    static { this.easeInOut = new AnimationEaseInOut(); }
+    static { this.easeInOutCubic = new AnimationEaseInOutCubic(); }
+}
+exports.Animations = Animations;
 //# sourceMappingURL=animations.js.map

package/dist/utilities/animator/animator/animator.d.ts

@@ -0,0 +1,44 @@
+import { Notifier, SingleEvent } from 'actions-lib';
+import { AnimatorAnimation } from '../animations';
+export declare enum ReAnimateHandlingType {
+    ThrowError = 1,
+    IgnoreNewAnimation = 2,
+    CompletePrevious = 3
+}
+export declare enum AnimationsCompletionHandlingType {
+    ReturnToOriginal = 1,
+    StayInCurrentState = 2,
+    JumpToEnd = 3,
+    Loop = 4
+}
+export interface AnimationOptions {
+    readonly duration: number;
+    readonly animation: AnimatorAnimation;
+    readonly reAnimateHandling: ReAnimateHandlingType;
+    readonly completionHandling: AnimationsCompletionHandlingType;
+}
+type NumericKeys<T> = {
+    [P in keyof T]: T[P] extends number ? P : never;
+}[keyof T] & string;
+export declare class Animator<T extends object = any, K extends NumericKeys<T> = NumericKeys<T>> {
+    private static _animatedObjects;
+    private static _getAnimatedObjectProperties;
+    private _target;
+    private _options;
+    private _animatedProperties;
+    private _ongoingAnimation;
+    get animating(): boolean;
+    get target(): T;
+    private _value;
+    get value(): Notifier<T>;
+    constructor(target: T & Record<K, number>, animatedProperties: K | K[], partialOptions?: Partial<AnimationOptions>);
+    animate(values: Record<K, number>, partialOptions?: Partial<AnimationOptions>): SingleEvent<void>;
+    set(values: Record<K, number>): void;
+    completeAnimation(completionHandling?: AnimationsCompletionHandlingType): void;
+    private _isAnimatingToSameValues;
+    private _setCompletionValues;
+    private _returnToStartingValues;
+    private _jumpToTargetValues;
+    private _lockAnimatedProperties;
+}
+export {};