bard-legends-framework 0.11.0 → 0.12.1

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

@@ -0,0 +1,60 @@
+import { Attachable, SingleEvent } from 'actions-lib';
+import { AnimatorAnimation } from '../animations';
+export interface AnimationState {
+    duration: number;
+    elapsedTime: number;
+    startingValue: number;
+    targetValue: number;
+    loop: boolean;
+    completeAnimationsHandling: CompleteAnimationsHandlingType;
+}
+export declare enum ReAnimateHandlingType {
+    throwError = "throwError",
+    ignoreNewAnimation = "ignoreNewAnimation",
+    completePrevious = "completePrevious"
+}
+export declare enum CompleteAnimationsHandlingType {
+    returnToOriginal = "returnToOriginal",
+    stayInCurrentState = "stayInCurrentState",
+    jumpToEnd = "jumpToEnd"
+}
+export interface AnimationOptions {
+    duration?: number;
+    animation?: AnimatorAnimation;
+    loop?: boolean;
+    reAnimateHandling?: ReAnimateHandlingType;
+    completeAnimationsHandling?: CompleteAnimationsHandlingType;
+}
+export declare class Animator<T extends Record<string, any>> extends Attachable {
+    private target;
+    private static animatedObjects;
+    private effectOn;
+    private defaultDuration;
+    private defaultAnimation;
+    private defaultLoop;
+    private defaultReAnimateHandling;
+    private defaultCompleteAnimationsHandling;
+    private onChangeCallback?;
+    private onCompleteCallback?;
+    private running;
+    private propertyStates;
+    private updateCycleSubscription;
+    get animating(): boolean;
+    constructor(target: T, effectOn: string | string[], options?: AnimationOptions);
+    onChange(callback: (target: T) => void): Animator<T>;
+    onComplete(callback: (key: string, value: number) => void): Animator<T>;
+    destroy(): void;
+    getAnimationStateOfKey(key: string): AnimationState | undefined;
+    pauseAnimations(): void;
+    resumeAnimations(): void;
+    completeAnimations(completeAnimationsHandling?: CompleteAnimationsHandlingType): void;
+    set(values: Record<string, any>): void;
+    animate(values: Record<string, any>, options?: AnimationOptions): SingleEvent;
+    private completeAnimationOfProperty;
+    private getCompleteFunctionOfOngoingAnimations;
+    private update;
+    private subscribeUpdateCycle;
+    private unsubscribeUpdateCycle;
+    private checkPropertyValidity;
+    private triggerOnChange;
+}

package/dist/utilities/animator/animator_old/animator.js

@@ -0,0 +1,337 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Animator = exports.CompleteAnimationsHandlingType = exports.ReAnimateHandlingType = void 0;
+const actions_lib_1 = require("actions-lib");
+const helpers_lib_1 = require("helpers-lib");
+const update_cycle_1 = require("../../../game-entities/update-cycle");
+const animations_1 = require("../animations");
+var ReAnimateHandlingType;
+(function (ReAnimateHandlingType) {
+    ReAnimateHandlingType["throwError"] = "throwError";
+    ReAnimateHandlingType["ignoreNewAnimation"] = "ignoreNewAnimation";
+    ReAnimateHandlingType["completePrevious"] = "completePrevious";
+})(ReAnimateHandlingType || (exports.ReAnimateHandlingType = ReAnimateHandlingType = {}));
+var CompleteAnimationsHandlingType;
+(function (CompleteAnimationsHandlingType) {
+    CompleteAnimationsHandlingType["returnToOriginal"] = "returnToOriginal";
+    CompleteAnimationsHandlingType["stayInCurrentState"] = "stayInCurrentState";
+    CompleteAnimationsHandlingType["jumpToEnd"] = "jumpToEnd";
+})(CompleteAnimationsHandlingType || (exports.CompleteAnimationsHandlingType = CompleteAnimationsHandlingType = {}));
+const DEFAULT_DURATION = 200;
+const DEFAULT_ANIMATION = animations_1.Animations.lineer;
+const DEFAULT_LOOP = false;
+const DEFAULT_RE_ANIMATE_HANDLING = ReAnimateHandlingType.throwError;
+const DEFAULT_COMPLETE_ANIMATIONS_HANDLING = CompleteAnimationsHandlingType.stayInCurrentState;
+class Animator extends actions_lib_1.Attachable {
+    static { this.animatedObjects = new Map(); }
+    get animating() {
+        return this.propertyStates.size > 0;
+    }
+    constructor(target, effectOn, options = {}) {
+        super();
+        this.target = target;
+        this.effectOn = new Set();
+        this.running = true;
+        this.propertyStates = new Map();
+        if (!helpers_lib_1.Comparator.isObject(target)) {
+            this.attachToRoot();
+            throw new Error(`Animator: target is not an object! Target: "${target}"`);
+        }
+        this.effectOn = helpers_lib_1.Comparator.isArray(effectOn) ? new Set(effectOn) : new Set([effectOn]);
+        let animatedObjectProperties = Animator.animatedObjects.get(target);
+        if (!animatedObjectProperties) {
+            animatedObjectProperties = new Set();
+            Animator.animatedObjects.set(target, animatedObjectProperties);
+        }
+        for (let key of this.effectOn) {
+            if (animatedObjectProperties.has(key)) {
+                this.attachToRoot();
+                throw new Error(`Animator: target property is already animated! Target: "${JSON.stringify(target, undefined, 2)}", Property: "${key}"`);
+            }
+            animatedObjectProperties.add(key);
+        }
+        this.defaultDuration = options.duration ?? DEFAULT_DURATION;
+        this.defaultAnimation = options.animation ?? DEFAULT_ANIMATION;
+        this.defaultLoop = options.loop ?? DEFAULT_LOOP;
+        this.defaultReAnimateHandling = options.reAnimateHandling ?? DEFAULT_RE_ANIMATE_HANDLING;
+        this.defaultCompleteAnimationsHandling = options.completeAnimationsHandling ?? DEFAULT_COMPLETE_ANIMATIONS_HANDLING;
+        for (let key of this.effectOn) {
+            if (!helpers_lib_1.Comparator.hasProperty(target, key)) {
+                this.attachToRoot();
+                throw new Error(`Animator: target does not have property. Target property: "${key}"`);
+            }
+            else if (!helpers_lib_1.Comparator.isNumber(target[key])) {
+                this.attachToRoot();
+                throw new Error(`Animator: target property is not a number. Target property: "${key}"`);
+            }
+        }
+    }
+    onChange(callback) {
+        if (this.onChangeCallback) {
+            this.attachToRoot();
+            throw new Error('Animator: onChangeCallback is already set!');
+        }
+        this.onChangeCallback = callback;
+        return this;
+    }
+    onComplete(callback) {
+        if (this.onCompleteCallback) {
+            this.attachToRoot();
+            throw new Error('Animator: onCompleteCallback is already set!');
+        }
+        this.onCompleteCallback = callback;
+        return this;
+    }
+    destroy() {
+        if (!this.destroyed) {
+            super.destroy();
+            this.onChangeCallback = undefined;
+            this.onCompleteCallback = undefined;
+            this.defaultAnimation = DEFAULT_ANIMATION;
+            this.propertyStates.clear();
+            let animatedObjectProperties = Animator.animatedObjects.get(this.target);
+            for (let key of this.effectOn) {
+                animatedObjectProperties.delete(key);
+            }
+            if (animatedObjectProperties.size <= 0) {
+                Animator.animatedObjects.delete(this.target);
+            }
+            this.target = undefined;
+        }
+    }
+    getAnimationStateOfKey(key) {
+        let propertyState = this.propertyStates.get(key);
+        if (propertyState) {
+            return {
+                duration: propertyState.duration,
+                elapsedTime: propertyState.elapsedTime,
+                startingValue: propertyState.startingValue,
+                targetValue: propertyState.targetValue,
+                loop: propertyState.loop,
+                completeAnimationsHandling: propertyState.completeAnimationsHandling
+            };
+        }
+    }
+    pauseAnimations() {
+        this.running = false;
+    }
+    resumeAnimations() {
+        this.running = true;
+    }
+    completeAnimations(completeAnimationsHandling) {
+        let triggerOnChange = false;
+        for (let [key, value] of this.propertyStates) {
+            let completeAnimationsHandlingFinal = completeAnimationsHandling ?? value.completeAnimationsHandling;
+            if (completeAnimationsHandlingFinal === CompleteAnimationsHandlingType.returnToOriginal) {
+                if (this.target[key] !== value.startingValue) {
+                    triggerOnChange = true;
+                    this.target[key] = value.startingValue;
+                }
+            }
+            else if (completeAnimationsHandlingFinal === CompleteAnimationsHandlingType.jumpToEnd) {
+                if (this.target[key] !== value.targetValue) {
+                    triggerOnChange = true;
+                    this.target[key] = value.targetValue;
+                }
+            }
+            this.completeAnimationOfProperty(value.propertyName, value.completionCallback);
+        }
+        triggerOnChange && this.triggerOnChange();
+    }
+    set(values) {
+        let keys = Object.keys(values);
+        for (let i = 0; i < keys.length; i++) {
+            this.checkPropertyValidity(keys[i]);
+        }
+        let complete = this.getCompleteFunctionOfOngoingAnimations(values);
+        let triggerOnChange = false;
+        for (let i = 0; i < keys.length; i++) {
+            let key = keys[i];
+            triggerOnChange = triggerOnChange || this.target[key] !== values[key];
+            this.target[key] = values[key];
+        }
+        complete();
+        triggerOnChange && this.triggerOnChange();
+    }
+    animate(values, options = {}) {
+        if (this.destroyed) {
+            return actions_lib_1.SingleEvent.instant();
+        }
+        let valueKeys = Object.keys(values);
+        for (let i = 0; i < valueKeys.length; i++) {
+            this.checkPropertyValidity(valueKeys[i]);
+        }
+        let complete = this.getCompleteFunctionOfOngoingAnimations(values, options.reAnimateHandling);
+        // Recalculate valueKeys after checkOngoingAnimations, as it may have deleted some keys
+        valueKeys = Object.keys(values);
+        this.subscribeUpdateCycle();
+        let animationEvent = actions_lib_1.SingleEvent.create(resolve => {
+            let ongoingKeys = new Set(valueKeys);
+            let animationDone = (key) => {
+                ongoingKeys.delete(key);
+                if (ongoingKeys.size <= 0) {
+                    resolve();
+                }
+            };
+            for (let i = 0; i < valueKeys.length; i++) {
+                let key = valueKeys[i];
+                let duration = options.duration ?? this.defaultDuration;
+                let animation = options.animation ?? this.defaultAnimation;
+                let loop = options.loop ?? this.defaultLoop;
+                let completeAnimationsHandling = options.completeAnimationsHandling ?? this.defaultCompleteAnimationsHandling;
+                let startingValue = this.target[key];
+                let targetValue = values[key];
+                if (startingValue === targetValue && !loop) {
+                    animationDone(key);
+                }
+                else {
+                    animation.start();
+                    try {
+                        this.propertyStates.set(key, {
+                            propertyName: key,
+                            duration,
+                            animation,
+                            elapsedTime: 0,
+                            startingValue,
+                            targetValue,
+                            loop,
+                            completeAnimationsHandling,
+                            completionCallback: () => animationDone(key)
+                        });
+                    }
+                    catch {
+                        animationDone(key);
+                    }
+                }
+            }
+        });
+        complete();
+        return animationEvent;
+    }
+    completeAnimationOfProperty(propertyName, completionCallback) {
+        let currentState = this.target[propertyName];
+        let propertyState = this.propertyStates.get(propertyName);
+        if (propertyState?.completionCallback === completionCallback) {
+            this.propertyStates.delete(propertyName);
+        }
+        try {
+            completionCallback();
+            this.onCompleteCallback?.(propertyName, currentState);
+        }
+        catch (e) {
+            console.error('Animator:', e);
+        }
+    }
+    getCompleteFunctionOfOngoingAnimations(values, reAnimateHandling) {
+        reAnimateHandling = reAnimateHandling ?? this.defaultReAnimateHandling;
+        let keys = Object.keys(values);
+        let completionInfos = [];
+        for (let i = 0; i < keys.length; i++) {
+            let key = keys[i];
+            let propertyState = this.propertyStates.get(key);
+            if (propertyState) {
+                if (reAnimateHandling === ReAnimateHandlingType.throwError) {
+                    throw new Error(`Animator: property is already being animated. Property: "${key}"`);
+                }
+                else if (reAnimateHandling === ReAnimateHandlingType.ignoreNewAnimation) {
+                    delete values[key];
+                }
+                else if (reAnimateHandling === ReAnimateHandlingType.completePrevious) {
+                    completionInfos.push({
+                        propertyName: propertyState.propertyName,
+                        completionCallback: propertyState.completionCallback
+                    });
+                }
+            }
+        }
+        return () => {
+            for (let i = 0; i < completionInfos.length; i++) {
+                let completionInfo = completionInfos[i];
+                this.completeAnimationOfProperty(completionInfo.propertyName, completionInfo.completionCallback);
+            }
+        };
+    }
+    update(delta) {
+        if (this.running && !this.destroyed) {
+            let triggerOnChange = this.propertyStates.size;
+            let propertyStatesToComplete = [];
+            for (let [key, value] of this.propertyStates) {
+                value.elapsedTime += delta;
+                let animationIsCompete = value.elapsedTime >= value.duration;
+                if (animationIsCompete) {
+                    if (value.loop) {
+                        value.animation.start();
+                        value.elapsedTime -= value.duration;
+                        animationIsCompete = false;
+                    }
+                    else {
+                        if (value.completeAnimationsHandling === CompleteAnimationsHandlingType.returnToOriginal) {
+                            this.target[key] = value.startingValue;
+                        }
+                        else {
+                            this.target[key] = value.targetValue;
+                        }
+                        // Do not complete inside the for loop, completion can start a new animation which will put the loop into infinite loop
+                        propertyStatesToComplete.push(value);
+                    }
+                }
+                if (!animationIsCompete) {
+                    let multiplier = value.animation.multiplierFunction(value.elapsedTime / value.duration);
+                    let relativeTarget = value.targetValue - value.startingValue;
+                    this.target[key] = relativeTarget * multiplier + value.startingValue;
+                }
+            }
+            for (let value of propertyStatesToComplete) {
+                this.completeAnimationOfProperty(value.propertyName, value.completionCallback);
+            }
+            triggerOnChange && this.triggerOnChange();
+            if (this.propertyStates.size <= 0) {
+                this.unsubscribeUpdateCycle();
+            }
+        }
+    }
+    subscribeUpdateCycle() {
+        if (!this.updateCycleSubscription && !this.destroyed) {
+            this.updateCycleSubscription = update_cycle_1.UpdateCycle.beforeSceneUpdateAction
+                .subscribe(update => {
+                try {
+                    this.update(update.delta);
+                }
+                catch (e) {
+                    console.error('Animator:', e);
+                    for (let value of this.propertyStates.values()) {
+                        try {
+                            value.completionCallback();
+                        }
+                        catch (err) {
+                            console.error('Animator:', err);
+                        }
+                    }
+                    this.propertyStates = new Map();
+                    this.unsubscribeUpdateCycle();
+                }
+            })
+                .attachToRoot();
+        }
+    }
+    unsubscribeUpdateCycle() {
+        this.updateCycleSubscription?.destroy();
+        this.updateCycleSubscription = undefined;
+    }
+    checkPropertyValidity(key) {
+        if (!this.effectOn.has(key)) {
+            this.attachToRoot();
+            throw new Error(`Animator: not effected property is tried to update. Key: "${key}", EffectOn: "${this.effectOn}"`);
+        }
+    }
+    triggerOnChange() {
+        try {
+            this.onChangeCallback?.(this.target);
+        }
+        catch (e) {
+            console.error('Animator:', e);
+        }
+    }
+}
+exports.Animator = Animator;
+//# sourceMappingURL=animator.js.map

package/dist/utilities/animator/animator_old/animator.performance.test.d.ts

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

package/dist/utilities/animator/animator_old/animator.performance.test.js

@@ -0,0 +1,121 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const helpers_lib_1 = require("helpers-lib");
+const vitest_1 = require("vitest");
+const game_entities_1 = require("../../../game-entities");
+const animator_1 = require("./animator");
+vitest_1.describe.skipIf(!process.env.MANUAL)('Performance Tests', () => {
+    (0, vitest_1.test)('no anim single', async () => {
+        await helpers_lib_1.UnitTestHelper.testPerformance(async () => {
+            return new Promise(resolve => {
+                let obj = { x: 0, y: 0 };
+                new animator_1.Animator(obj, 'x', {
+                    duration: 1
+                }).attachToRoot();
+                resolve();
+            });
+            // 18.053100109100342
+        }, { sampleCount: 100, repetationCount: 10000 });
+    }, 60000);
+    (0, vitest_1.test)('no anim multiple', async () => {
+        await helpers_lib_1.UnitTestHelper.testPerformance(async () => {
+            return new Promise(resolve => {
+                let obj = { x: 0, y: 0 };
+                new animator_1.Animator(obj, ['x', 'y'], {
+                    duration: 1
+                }).attachToRoot();
+                resolve();
+            });
+            // 18.6875
+        }, { sampleCount: 100, repetationCount: 10000 });
+    }, 60000);
+    (0, vitest_1.test)('single 1 duration', async () => {
+        await helpers_lib_1.UnitTestHelper.testPerformance(async () => {
+            return new Promise(resolve => {
+                let obj = { x: 0, y: 0 };
+                let animator = new animator_1.Animator(obj, 'x', {
+                    duration: 1
+                }).attachToRoot();
+                animator.animate({ x: 1 }).tap(resolve).attachToRoot();
+                game_entities_1.UpdateCycle.triggerUpdateTick(1);
+            });
+            // 3.178299903869629
+            // converting to single event: 6.434300422668457
+            // with wait until all destroyed: 11.552299976348877
+            // 7.839200019836426
+            // last comparible: 5.697200298309326
+            // no forEach: 5.479100227355957
+            // after bundle: 2.5292000770568848
+            // 4.8225998878479
+            // after repetationCount: 10000
+            // 40.16639995574951
+        }, { sampleCount: 100, repetationCount: 10000 });
+    }, 60000);
+    (0, vitest_1.test)('multiple 1 duration', async () => {
+        await helpers_lib_1.UnitTestHelper.testPerformance(async () => {
+            return new Promise(resolve => {
+                let obj = { x: 0, y: 0 };
+                let animator = new animator_1.Animator(obj, ['x', 'y'], {
+                    duration: 1
+                }).attachToRoot();
+                animator.animate({ x: 1, y: 1 }).tap(resolve).attachToRoot();
+                game_entities_1.UpdateCycle.triggerUpdateTick(1);
+            });
+            // 3.6912999153137207
+            // converting to single event: 6.845600128173828
+            // with wait until all destroyed: 13.253100395202637
+            // 9.115399837493896
+            // last comparible: 6.0391998291015625
+            // no forEach: 5.958700180053711
+            // after bundle: 2.9321999549865723
+            // 5.1743998527526855
+            // after repetationCount: 10000
+            // 43.13860011100769
+        }, { sampleCount: 100, repetationCount: 10000 });
+    }, 60000);
+    (0, vitest_1.test)('single 10 duration', async () => {
+        await helpers_lib_1.UnitTestHelper.testPerformance(async () => {
+            return new Promise(resolve => {
+                let obj = { x: 0, y: 0 };
+                let animator = new animator_1.Animator(obj, 'x', {
+                    duration: 10
+                }).attachToRoot();
+                animator.animate({ x: 1 }).tap(resolve).attachToRoot();
+                game_entities_1.UpdateCycle.triggerUpdateTick(1);
+                game_entities_1.UpdateCycle.triggerUpdateTick(1);
+                game_entities_1.UpdateCycle.triggerUpdateTick(1);
+                game_entities_1.UpdateCycle.triggerUpdateTick(1);
+                game_entities_1.UpdateCycle.triggerUpdateTick(1);
+                game_entities_1.UpdateCycle.triggerUpdateTick(1);
+                game_entities_1.UpdateCycle.triggerUpdateTick(1);
+                game_entities_1.UpdateCycle.triggerUpdateTick(1);
+                game_entities_1.UpdateCycle.triggerUpdateTick(1);
+                game_entities_1.UpdateCycle.triggerUpdateTick(1);
+            });
+            // 45.116599798202515
+        }, { sampleCount: 50, repetationCount: 10000 });
+    }, 60000);
+    (0, vitest_1.test)('multiple 10 duration', async () => {
+        await helpers_lib_1.UnitTestHelper.testPerformance(async () => {
+            return new Promise(resolve => {
+                let obj = { x: 0, y: 0 };
+                let animator = new animator_1.Animator(obj, ['x', 'y'], {
+                    duration: 10
+                }).attachToRoot();
+                animator.animate({ x: 1, y: 1 }).tap(resolve).attachToRoot();
+                game_entities_1.UpdateCycle.triggerUpdateTick(1);
+                game_entities_1.UpdateCycle.triggerUpdateTick(1);
+                game_entities_1.UpdateCycle.triggerUpdateTick(1);
+                game_entities_1.UpdateCycle.triggerUpdateTick(1);
+                game_entities_1.UpdateCycle.triggerUpdateTick(1);
+                game_entities_1.UpdateCycle.triggerUpdateTick(1);
+                game_entities_1.UpdateCycle.triggerUpdateTick(1);
+                game_entities_1.UpdateCycle.triggerUpdateTick(1);
+                game_entities_1.UpdateCycle.triggerUpdateTick(1);
+                game_entities_1.UpdateCycle.triggerUpdateTick(1);
+            });
+            // 55.35859990119934
+        }, { sampleCount: 50, repetationCount: 10000 });
+    }, 60000);
+});
+//# sourceMappingURL=animator.performance.test.js.map

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

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