bard-legends-framework 0.10.8 → 0.11.0

package/dist/utilities/animator/animator.js

@@ -0,0 +1,315 @@
+"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 = new animations_1.AnimationLineer();
+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 isAnimating() {
+        return this.propertyStates.size > 0;
+    }
+    constructor(target, effectOn, options = {}) {
+        super();
+        this.target = target;
+        this.effectOn = new Set();
+        this.running = true;
+        this.propertyStates = new Map();
+        this.allResolvers = new Set();
+        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);
+        }
+        this.effectOn.forEach(key => {
+            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;
+        this.effectOn.forEach(key => {
+            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) {
+            this.onChangeCallback = undefined;
+            this.onCompleteCallback = undefined;
+            this.defaultAnimation = DEFAULT_ANIMATION;
+            this.propertyStates.clear();
+            let animatedObjectProperties = Animator.animatedObjects.get(this.target);
+            this.effectOn.forEach(key => animatedObjectProperties.delete(key));
+            if (animatedObjectProperties.size <= 0) {
+                Animator.animatedObjects.delete(this.target);
+            }
+            this.target = undefined;
+            this.allResolvers.forEach(resolver => resolver());
+            this.allResolvers.clear();
+            super.destroy();
+        }
+    }
+    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;
+        this.propertyStates.forEach((value, key) => {
+            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);
+        });
+        triggerOnChange && this.triggerOnChange();
+    }
+    set(values) {
+        Object.keys(values).forEach(key => {
+            this.checkPropertyValidity(key);
+        });
+        this.checkOngoingAnimations(values);
+        let triggerOnChange = false;
+        Object.keys(values).forEach(key => {
+            triggerOnChange = triggerOnChange || this.target[key] !== values[key];
+            this.target[key] = values[key];
+        });
+        triggerOnChange && this.triggerOnChange();
+    }
+    async animate(values, options = {}) {
+        if (this.destroyed) {
+            return;
+        }
+        let valueKeys = Object.keys(values);
+        valueKeys.forEach(key => {
+            this.checkPropertyValidity(key);
+        });
+        this.checkOngoingAnimations(values, options.reAnimateHandling);
+        return new Promise(resolveAll => {
+            this.allResolvers.add(resolveAll);
+            Promise.all(Object.keys(values).map(key => new Promise(resolve => {
+                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) {
+                    resolve(undefined);
+                    return;
+                }
+                animation.start();
+                try {
+                    this.propertyStates.set(key, {
+                        propertyName: key,
+                        duration,
+                        animation,
+                        elapsedTime: 0,
+                        startingValue,
+                        targetValue,
+                        loop,
+                        completeAnimationsHandling,
+                        completionCallback: () => {
+                            resolve(undefined);
+                        }
+                    });
+                }
+                catch {
+                    resolveAll();
+                    this.allResolvers.delete(resolveAll);
+                }
+            }))).then(() => {
+                resolveAll();
+                this.allResolvers.delete(resolveAll);
+            });
+            this.subscribeUpdateCycle();
+        });
+    }
+    completeAnimationOfProperty(propertyState) {
+        let currentState = this.target[propertyState.propertyName];
+        this.propertyStates.delete(propertyState.propertyName);
+        try {
+            propertyState.completionCallback();
+            this.onCompleteCallback?.(propertyState.propertyName, currentState);
+        }
+        catch (e) {
+            console.error('Animator:', e);
+        }
+    }
+    checkOngoingAnimations(values, reAnimateHandling) {
+        reAnimateHandling = reAnimateHandling ?? this.defaultReAnimateHandling;
+        Object.keys(values).forEach(key => {
+            let previousState = this.propertyStates.get(key);
+            if (previousState) {
+                if (reAnimateHandling === ReAnimateHandlingType.throwError) {
+                    this.attachToRoot();
+                    throw new Error(`Animator: property is already being animated. Property: "${key}"`);
+                }
+                else if (reAnimateHandling === ReAnimateHandlingType.ignoreNewAnimation) {
+                    delete values[key];
+                }
+                else if (reAnimateHandling === ReAnimateHandlingType.completePrevious) {
+                    this.completeAnimationOfProperty(previousState);
+                }
+            }
+        });
+    }
+    update(delta) {
+        if (this.running && !this.destroyed) {
+            let triggerOnChange = this.propertyStates.size;
+            let propertyStatesToComplete = [];
+            this.propertyStates.forEach((value, key) => {
+                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 forEach loop, completion can start a new animation which will put forEach 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;
+                }
+            });
+            propertyStatesToComplete.forEach(value => {
+                this.completeAnimationOfProperty(value);
+            });
+            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);
+                    this.propertyStates.forEach(value => {
+                        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.test.d.ts

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