bard-legends-framework 0.11.0 → 0.12.1

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

@@ -0,0 +1,234 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Animator = exports.AnimationsCompletionHandlingType = exports.ReAnimateHandlingType = void 0;
+const actions_lib_1 = require("actions-lib");
+const helpers_lib_1 = require("helpers-lib");
+const game_entities_1 = require("../../../game-entities");
+const animations_1 = require("../animations");
+var ReAnimateHandlingType;
+(function (ReAnimateHandlingType) {
+    ReAnimateHandlingType[ReAnimateHandlingType["ThrowError"] = 1] = "ThrowError";
+    ReAnimateHandlingType[ReAnimateHandlingType["IgnoreNewAnimation"] = 2] = "IgnoreNewAnimation";
+    ReAnimateHandlingType[ReAnimateHandlingType["CompletePrevious"] = 3] = "CompletePrevious";
+})(ReAnimateHandlingType || (exports.ReAnimateHandlingType = ReAnimateHandlingType = {}));
+var AnimationsCompletionHandlingType;
+(function (AnimationsCompletionHandlingType) {
+    AnimationsCompletionHandlingType[AnimationsCompletionHandlingType["ReturnToOriginal"] = 1] = "ReturnToOriginal";
+    AnimationsCompletionHandlingType[AnimationsCompletionHandlingType["StayInCurrentState"] = 2] = "StayInCurrentState";
+    AnimationsCompletionHandlingType[AnimationsCompletionHandlingType["JumpToEnd"] = 3] = "JumpToEnd";
+    AnimationsCompletionHandlingType[AnimationsCompletionHandlingType["Loop"] = 4] = "Loop";
+})(AnimationsCompletionHandlingType || (exports.AnimationsCompletionHandlingType = AnimationsCompletionHandlingType = {}));
+class Animator {
+    static { this._animatedObjects = new WeakMap(); }
+    static _getAnimatedObjectProperties(target) {
+        let animatedObjectProperties = Animator._animatedObjects.get(target);
+        if (!animatedObjectProperties) {
+            animatedObjectProperties = new helpers_lib_1.MapToWeakRefs();
+            Animator._animatedObjects.set(target, animatedObjectProperties);
+        }
+        return animatedObjectProperties;
+    }
+    get animating() {
+        return this._ongoingAnimation !== undefined;
+    }
+    get target() {
+        return this._target;
+    }
+    get value() {
+        if (!this._value) {
+            this._value = new actions_lib_1.Variable(this._target);
+        }
+        return this._value.notifier;
+    }
+    constructor(target, animatedProperties, partialOptions) {
+        this._target = target;
+        this._options = {
+            duration: 200,
+            animation: animations_1.Animations.lineer,
+            reAnimateHandling: ReAnimateHandlingType.ThrowError,
+            completionHandling: AnimationsCompletionHandlingType.StayInCurrentState,
+            ...partialOptions
+        };
+        this._animatedProperties = helpers_lib_1.Comparator.isArray(animatedProperties) ? animatedProperties : [animatedProperties];
+        this._lockAnimatedProperties(target, this._animatedProperties); // NOTE: this can be removed in release mode
+    }
+    animate(values, partialOptions) {
+        let options = {
+            ...this._options,
+            ...partialOptions
+        };
+        if (this._ongoingAnimation) {
+            switch (options.reAnimateHandling) {
+                case ReAnimateHandlingType.ThrowError:
+                    throw new Error(`Animator: new animation triggered while another is not complete yet.`);
+                case ReAnimateHandlingType.IgnoreNewAnimation:
+                    return actions_lib_1.SingleEvent.instant();
+                case ReAnimateHandlingType.CompletePrevious:
+                    this._setCompletionValues(options.completionHandling, this._ongoingAnimation._properties, true);
+                    break;
+                default: {
+                    let _ = options.reAnimateHandling;
+                    throw new Error(`Animator: unknown re-animate handling type: "${options.reAnimateHandling}"`);
+                }
+            }
+        }
+        let event = actions_lib_1.SingleEvent.create(resolve => {
+            let properties = this._animatedProperties.reduce((acc, key) => {
+                acc[key] = {
+                    _startingValue: this._target[key],
+                    _targetValue: values[key]
+                };
+                return acc;
+            }, {});
+            let updateCycleSubscription;
+            let animationState = {
+                _duration: options.duration,
+                _elapsedTime: 0,
+                _properties: properties,
+                _completionHandling: options.completionHandling,
+                _animation: options.animation,
+                _completionCallback: resolve
+            };
+            if (animationState._completionHandling !== AnimationsCompletionHandlingType.Loop &&
+                this._isAnimatingToSameValues(animationState)) {
+                this._ongoingAnimation = undefined;
+                resolve();
+                return;
+            }
+            else {
+                animationState._animation.start();
+            }
+            let previousAnimationState = this._ongoingAnimation;
+            this._ongoingAnimation = animationState;
+            updateCycleSubscription = game_entities_1.UpdateCycle.beforeSceneUpdateAction
+                .subscribe(update => {
+                animationState._elapsedTime += update.delta;
+                let animationIsCompete = animationState._elapsedTime >= animationState._duration;
+                if (animationIsCompete) {
+                    if (animationState._completionHandling === AnimationsCompletionHandlingType.Loop) {
+                        animationState._elapsedTime %= animationState._duration;
+                        animationState._animation.start();
+                        animationIsCompete = false;
+                    }
+                    else {
+                        this._setCompletionValues(animationState._completionHandling, animationState._properties, false);
+                        this._ongoingAnimation = undefined;
+                        animationState._completionCallback();
+                    }
+                }
+                if (!animationIsCompete) {
+                    let multiplier = animationState._animation.multiplierFunction(animationState._elapsedTime / animationState._duration);
+                    let changeHappened = false;
+                    for (let i = 0; i < this._animatedProperties.length; i++) {
+                        let key = this._animatedProperties[i];
+                        let propertyState = animationState._properties[key];
+                        let relativeTarget = propertyState._targetValue - propertyState._startingValue;
+                        let newValue = relativeTarget * multiplier + propertyState._startingValue;
+                        if (newValue !== this._target[key]) {
+                            changeHappened = true;
+                            this._target[key] = newValue;
+                        }
+                    }
+                    changeHappened && this._value?.set(this._target);
+                }
+            })
+                .attachToRoot();
+            previousAnimationState?._completionCallback();
+            return () => {
+                updateCycleSubscription.destroy();
+                if (this._ongoingAnimation === animationState) {
+                    if (!(this._target instanceof actions_lib_1.Attachable && this._target.destroyed)) {
+                        this._setCompletionValues(this._ongoingAnimation._completionHandling, this._ongoingAnimation._properties, true);
+                    }
+                    this._ongoingAnimation = undefined;
+                }
+            };
+        });
+        return event;
+    }
+    set(values) {
+        let changeHappened = false;
+        for (let i = 0; i < this._animatedProperties.length; i++) {
+            let key = this._animatedProperties[i];
+            if (this._target[key] !== values[key]) {
+                changeHappened = true;
+                this._target[key] = values[key];
+            }
+        }
+        changeHappened && this._value?.set(this._target);
+        this._ongoingAnimation?._completionCallback();
+    }
+    completeAnimation(completionHandling) {
+        if (this._ongoingAnimation) {
+            completionHandling = completionHandling ?? this._ongoingAnimation._completionHandling;
+            this._setCompletionValues(completionHandling, this._ongoingAnimation._properties, true);
+            let callback = this._ongoingAnimation._completionCallback;
+            this._ongoingAnimation = undefined;
+            callback();
+        }
+    }
+    _isAnimatingToSameValues(ongoingAnimation) {
+        for (let i = 0; i < this._animatedProperties.length; i++) {
+            let key = this._animatedProperties[i];
+            if (this._target[key] !== ongoingAnimation._properties[key]._targetValue) {
+                return false;
+            }
+        }
+        return true;
+    }
+    _setCompletionValues(completionHandling, values, interruptedCompletion) {
+        switch (completionHandling) {
+            case AnimationsCompletionHandlingType.ReturnToOriginal:
+                this._returnToStartingValues(values);
+                break;
+            case AnimationsCompletionHandlingType.StayInCurrentState:
+                if (!interruptedCompletion) {
+                    this._jumpToTargetValues(values);
+                }
+                break;
+            case AnimationsCompletionHandlingType.JumpToEnd:
+                this._jumpToTargetValues(values);
+                break;
+            case AnimationsCompletionHandlingType.Loop:
+                this._returnToStartingValues(values);
+                break;
+            default: {
+                let _ = completionHandling;
+                throw new Error(`Animator: unknown completion handling type: "${completionHandling}"`);
+            }
+        }
+    }
+    _returnToStartingValues(values) {
+        let changeHappened = false;
+        for (let i = 0; i < this._animatedProperties.length; i++) {
+            let key = this._animatedProperties[i];
+            if (this._target[key] !== values[key]._startingValue) {
+                changeHappened = true;
+                this._target[key] = values[key]._startingValue;
+            }
+        }
+        changeHappened && this._value?.set(this._target);
+    }
+    _jumpToTargetValues(values) {
+        let changeHappened = false;
+        for (let i = 0; i < this._animatedProperties.length; i++) {
+            let key = this._animatedProperties[i];
+            if (this._target[key] !== values[key]._targetValue) {
+                changeHappened = true;
+                this._target[key] = values[key]._targetValue;
+            }
+        }
+        changeHappened && this._value?.set(this._target);
+    }
+    _lockAnimatedProperties(target, animatedProperties) {
+        let animatedObjectProperties = Animator._getAnimatedObjectProperties(target);
+        for (let key of animatedProperties) {
+            if (animatedObjectProperties.has(key)) {
+                throw new Error(`Animator: target property is already animated! Target: "${JSON.stringify(target, undefined, 2)}", Property: "${key}"`);
+            }
+            animatedObjectProperties.set(key, this);
+        }
+    }
+}
+exports.Animator = Animator;
+//# sourceMappingURL=animator.js.map

package/dist/utilities/animator/animator/animator.memory-leak.test.d.ts

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

package/dist/utilities/animator/animator/animator.memory-leak.test.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@memlab/core");
+const actions_lib_1 = require("actions-lib");
+const helpers_lib_1 = require("helpers-lib");
+const vitest_1 = require("vitest");
+const game_entities_1 = require("../../../game-entities");
+const animator_1 = require("./animator");
+const ClassNamesToCheck = ['Animator', 'SingleEvent'];
+vitest_1.describe.skipIf(process.env.QUICK)('Memory Leak', () => {
+    (0, vitest_1.beforeEach)(() => {
+        actions_lib_1.ActionLib.hardReset();
+    });
+    async function checkMemoryLeaks(...additionalNames) {
+        await helpers_lib_1.UnitTestHelper.waitForAllOperations();
+        await (0, helpers_lib_1.Wait)();
+        let snapshot = await (0, core_1.takeNodeMinimalHeap)();
+        ClassNamesToCheck.concat(additionalNames).forEach(name => {
+            if (snapshot.hasObjectWithClassName(name)) {
+                throw new Error(`"${name}" has at least one instance in the memory.`);
+            }
+        });
+    }
+    (0, vitest_1.test)('simple animator', async () => {
+        let target = { x: 1 };
+        let animator = new animator_1.Animator(target, 'x');
+        (0, vitest_1.expect)(animator).toBeDefined();
+        animator = undefined;
+        await (0, vitest_1.expect)(checkMemoryLeaks()).resolves.not.toThrow();
+    }, 60000);
+    (0, vitest_1.test)('sample animation', async () => {
+        let target = { x: 1 };
+        let animator = new animator_1.Animator(target, 'x');
+        let animation = animator.animate({ x: 2 }).attachToRoot();
+        game_entities_1.UpdateCycle.triggerUpdateTick(1);
+        (0, vitest_1.expect)(animation).toBeDefined();
+        animation.destroy();
+        animator = undefined;
+        animation = undefined;
+        await (0, vitest_1.expect)(checkMemoryLeaks()).resolves.not.toThrow();
+    }, 60000);
+    (0, vitest_1.test)('target contains the animator', async () => {
+        class Foo {
+            constructor() {
+                this.x = 0;
+                this.animator = new animator_1.Animator(this, 'x');
+            }
+        }
+        let foo = new Foo();
+        (0, vitest_1.expect)(foo).toBeDefined();
+        foo = undefined;
+        await (0, vitest_1.expect)(checkMemoryLeaks(Foo.name)).resolves.not.toThrow();
+    }, 60000);
+    (0, vitest_1.test)('default animation contains the animator', async () => {
+        class FaultyAnimation {
+            start() { }
+            multiplierFunction(t) {
+                return 0;
+            }
+            setAnimator(anim) {
+                this._animator = anim;
+            }
+        }
+        let animation = new FaultyAnimation();
+        let animator = new animator_1.Animator({ x: 1 }, 'x', { animation });
+        animation.setAnimator(animator);
+        (0, vitest_1.expect)(animator).toBeDefined();
+        animation = undefined;
+        animator = undefined;
+        await (0, vitest_1.expect)(checkMemoryLeaks(FaultyAnimation.name)).resolves.not.toThrow();
+    }, 60000);
+});
+//# sourceMappingURL=animator.memory-leak.test.js.map

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

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

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

@@ -0,0 +1,116 @@
+"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
+                });
+                resolve();
+            });
+            // old animator: 18.053100109100342
+            // 11.454499959945679
+            // not using context.attachable: 11.263000011444092
+        }, { 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
+                });
+                resolve();
+            });
+            // old animator: 18.6875
+            // 12.170400142669678
+            // not using context.attachable: 11.783799886703491
+        }, { sampleCount: 100, repetationCount: 10000 });
+    }, 60000);
+    (0, vitest_1.test)('single anim with trigger', 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
+                });
+                animator.animate({ x: 1 }).tap(resolve).attachToRoot();
+                game_entities_1.UpdateCycle.triggerUpdateTick(1);
+            });
+            // old animator: 40.16639995574951
+            // 31.48099994659424
+            // not using context.attachable: 28.500200033187866
+        }, { sampleCount: 100, repetationCount: 10000 });
+    }, 60000);
+    (0, vitest_1.test)('multiple anim with trigger', 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
+                });
+                animator.animate({ x: 1, y: 1 }).tap(resolve).attachToRoot();
+                game_entities_1.UpdateCycle.triggerUpdateTick(1);
+            });
+            // old animator: 43.13860011100769
+            // 34.62980008125305
+            // not using context.attachable: 33.04159998893738
+        }, { sampleCount: 100, repetationCount: 10000 });
+    }, 60000);
+    (0, vitest_1.test)('single anim with 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
+                });
+                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);
+            });
+            // old animator: 45.116599798202515
+            // 42.34260010719299
+            // after single event optimizations: 39.85520005226135
+            // not using context.attachable: 34.36899995803833
+        }, { sampleCount: 200, repetationCount: 10000 });
+    }, 60000);
+    (0, vitest_1.test)('multiple anim with 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
+                });
+                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);
+            });
+            // old animator: 55.35859990119934
+            // 54.57029986381531
+            // not using context.attachable: 50.5145001411438
+        }, { sampleCount: 50, repetationCount: 10000 });
+    }, 60000);
+});
+//# sourceMappingURL=animator.performance.test.js.map

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

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