bard-legends-framework 0.9.5 → 0.9.7

package/dist/game-entities/view/view.test.js

@@ -32,8 +32,8 @@ var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const actions_lib_1 = require("actions-lib");
 const ActionsLib = __importStar(require("actions-lib"));
+const actions_lib_1 = require("actions-lib");
 const helpers_lib_1 = require("helpers-lib");
 const vitest_1 = require("vitest");
 const decorate_actions_lib_1 = require("../base/helpers/decorate-actions-lib");

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

@@ -1,25 +1,25 @@
 export interface AnimatorAnimation {
-    start(): void;
-    multiplierFunction(t: number): number;
+  start(): void;
+  multiplierFunction(t: number): number;
 }
 export declare class AnimationLineer implements AnimatorAnimation {
-    start(): void;
-    multiplierFunction(t: number): number;
+  start(): void;
+  multiplierFunction(t: number): number;
 }
 export declare class AnimationEaseInOut implements AnimatorAnimation {
-    start(): void;
-    multiplierFunction(t: number): number;
+  start(): void;
+  multiplierFunction(t: number): number;
 }
 export declare class AnimationEaseIn implements AnimatorAnimation {
-    start(): void;
-    multiplierFunction(t: number): number;
+  start(): void;
+  multiplierFunction(t: number): number;
 }
 export declare class AnimationEaseOut implements AnimatorAnimation {
-    start(): void;
-    multiplierFunction(t: number): number;
+  start(): void;
+  multiplierFunction(t: number): number;
 }
 export declare class AnimationFlicker implements AnimatorAnimation {
-    private timeGrid;
-    start(): void;
-    multiplierFunction(t: number): number;
+  private timeGrid;
+  start(): void;
+  multiplierFunction(t: number): number;
 }

package/dist/lib/animator/animations.js

@@ -1,58 +1,61 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AnimationFlicker = exports.AnimationEaseOut = exports.AnimationEaseIn = exports.AnimationEaseInOut = exports.AnimationLineer = void 0;
-const helpers_lib_1 = require("helpers-lib");
+Object.defineProperty(exports, '__esModule', { value: true });
+exports.AnimationFlicker =
+  exports.AnimationEaseOut =
+  exports.AnimationEaseIn =
+  exports.AnimationEaseInOut =
+  exports.AnimationLineer =
+    void 0;
+const helpers_lib_1 = require('helpers-lib');
 class AnimationLineer {
-    start() { }
-    multiplierFunction(t) {
-        return t;
-    }
+  start() {}
+  multiplierFunction(t) {
+    return t;
+  }
 }
 exports.AnimationLineer = AnimationLineer;
 class AnimationEaseInOut {
-    start() { }
-    multiplierFunction(t) {
-        if ((t *= 2) < 1) {
-            return 0.5 * t * t;
-        }
-        else {
-            return -0.5 * (--t * (t - 2) - 1);
-        }
+  start() {}
+  multiplierFunction(t) {
+    if ((t *= 2) < 1) {
+      return 0.5 * t * t;
+    } else {
+      return -0.5 * (--t * (t - 2) - 1);
     }
+  }
 }
 exports.AnimationEaseInOut = AnimationEaseInOut;
 class AnimationEaseIn {
-    start() { }
-    multiplierFunction(t) {
-        return Math.pow(t, 2);
-    }
+  start() {}
+  multiplierFunction(t) {
+    return t ** 2;
+  }
 }
 exports.AnimationEaseIn = AnimationEaseIn;
 class AnimationEaseOut {
-    start() { }
-    multiplierFunction(t) {
-        return 1 - Math.pow(1 - t, 2);
-    }
+  start() {}
+  multiplierFunction(t) {
+    return 1 - (1 - t) ** 2;
+  }
 }
 exports.AnimationEaseOut = AnimationEaseOut;
 class AnimationFlicker {
-    start() {
-        this.timeGrid = new Array(10).fill(0);
-        helpers_lib_1.Random.randomIntegerBetween(0, 9);
-        this.timeGrid[helpers_lib_1.Random.randomIntegerBetween(0, 9)] = Math.random();
-        if (Math.random() < 0.3) {
-            helpers_lib_1.Random.randomIntegerBetween(0, 9);
-            this.timeGrid[helpers_lib_1.Random.randomIntegerBetween(0, 9)] = Math.random();
-        }
-        if (Math.random() < 0.2) {
-            helpers_lib_1.Random.randomIntegerBetween(0, 9);
-            this.timeGrid[helpers_lib_1.Random.randomIntegerBetween(0, 9)] = Math.random();
-        }
+  start() {
+    this.timeGrid = new Array(10).fill(0);
+    helpers_lib_1.Random.randomIntegerBetween(0, 9);
+    this.timeGrid[helpers_lib_1.Random.randomIntegerBetween(0, 9)] = Math.random();
+    if (Math.random() < 0.3) {
+      helpers_lib_1.Random.randomIntegerBetween(0, 9);
+      this.timeGrid[helpers_lib_1.Random.randomIntegerBetween(0, 9)] = Math.random();
     }
-    multiplierFunction(t) {
-        let index = Math.floor(t * 10);
-        return this.timeGrid[index];
+    if (Math.random() < 0.2) {
+      helpers_lib_1.Random.randomIntegerBetween(0, 9);
+      this.timeGrid[helpers_lib_1.Random.randomIntegerBetween(0, 9)] = Math.random();
     }
+  }
+  multiplierFunction(t) {
+    const index = Math.floor(t * 10);
+    return this.timeGrid[index];
+  }
 }
 exports.AnimationFlicker = AnimationFlicker;
-//# sourceMappingURL=animations.js.map
+//# sourceMappingURL=animations.js.map

package/dist/lib/animator/animator.d.ts

@@ -1,52 +1,52 @@
 import { AnimatorAnimation } from './animations';
 export interface AnimationState {
-    duration: number;
-    elapsedTime: number;
-    startingValue: number;
-    targetValue: number;
-    loop: boolean;
-    completeAnimationsHandling: CompleteAnimationsHandlingType;
+  duration: number;
+  elapsedTime: number;
+  startingValue: number;
+  targetValue: number;
+  loop: boolean;
+  completeAnimationsHandling: CompleteAnimationsHandlingType;
 }
 export declare enum ReAnimateHandlingType {
-    throwError = "throwError",
-    ignore = "ignore"
+  throwError = 'throwError',
+  ignore = 'ignore'
 }
 export declare enum CompleteAnimationsHandlingType {
-    returnToOriginal = "returnToOriginal",
-    stayInCurrentState = "stayInCurrentState",
-    jumpToEnd = "jumpToEnd"
+  returnToOriginal = 'returnToOriginal',
+  stayInCurrentState = 'stayInCurrentState',
+  jumpToEnd = 'jumpToEnd'
 }
 export interface AnimationOptions<T> {
-    duration?: number;
-    animation?: AnimatorAnimation;
-    loop?: boolean;
-    reAnimateHandling?: ReAnimateHandlingType;
-    completeAnimationsHandling?: CompleteAnimationsHandlingType;
+  duration?: number;
+  animation?: AnimatorAnimation;
+  loop?: boolean;
+  reAnimateHandling?: ReAnimateHandlingType;
+  completeAnimationsHandling?: CompleteAnimationsHandlingType;
 }
 export declare class Animator<T> {
-    private static animatedObjects;
-    readonly targetObject: T;
-    private effectOn;
-    private defaultDuration;
-    private defaultAnimation;
-    private defaultLoop;
-    private defaultReAnimateHandling;
-    private defaultCompleteAnimationsHandling;
-    private onChangeCallback?;
-    private running;
-    private propertyStates;
-    private updateCycleSubscription;
-    constructor(target: T, effectOn: string | string[], options?: AnimationOptions<T>);
-    get isAnimating(): boolean;
-    getAnimationStateOfKey(key: string): AnimationState | undefined;
-    onChange(callback: (target: T) => void): Animator<T>;
-    pauseAnimations(): void;
-    resumeAnimations(): void;
-    completeAnimations(completeAnimationsHandling?: CompleteAnimationsHandlingType): void;
-    set(values: Record<string, any>): void;
-    animate(values: Record<string, any>, options?: AnimationOptions<T>): Promise<void>;
-    private startAnimate;
-    private update;
-    private subscribeUpdateCycle;
-    private checkPropertyValidity;
+  private static animatedObjects;
+  readonly targetObject: T;
+  private effectOn;
+  private defaultDuration;
+  private defaultAnimation;
+  private defaultLoop;
+  private defaultReAnimateHandling;
+  private defaultCompleteAnimationsHandling;
+  private onChangeCallback?;
+  private running;
+  private propertyStates;
+  private updateCycleSubscription;
+  constructor(target: T, effectOn: string | string[], options?: AnimationOptions<T>);
+  get isAnimating(): boolean;
+  getAnimationStateOfKey(key: string): AnimationState | undefined;
+  onChange(callback: (target: T) => void): Animator<T>;
+  pauseAnimations(): void;
+  resumeAnimations(): void;
+  completeAnimations(completeAnimationsHandling?: CompleteAnimationsHandlingType): void;
+  set(values: Record<string, any>): void;
+  animate(values: Record<string, any>, options?: AnimationOptions<T>): Promise<void>;
+  private startAnimate;
+  private update;
+  private subscribeUpdateCycle;
+  private checkPropertyValidity;
 }

package/dist/lib/animator/animator.js

@@ -1,20 +1,19 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+Object.defineProperty(exports, '__esModule', { value: true });
 exports.Animator = exports.CompleteAnimationsHandlingType = exports.ReAnimateHandlingType = void 0;
-const helpers_lib_1 = require("helpers-lib");
-const update_loop_1 = require("../update-loop");
-const animations_1 = require("./animations");
+const helpers_lib_1 = require('helpers-lib');
+const update_loop_1 = require('../update-loop');
+const animations_1 = require('./animations');
 var ReAnimateHandlingType;
-(function (ReAnimateHandlingType) {
-    ReAnimateHandlingType["throwError"] = "throwError";
-    ReAnimateHandlingType["ignore"] = "ignore";
-    // TODO: blendIn
+(ReAnimateHandlingType => {
+  ReAnimateHandlingType['throwError'] = 'throwError';
+  ReAnimateHandlingType['ignore'] = 'ignore';
+  // TODO: blendIn
 })(ReAnimateHandlingType || (exports.ReAnimateHandlingType = ReAnimateHandlingType = {}));
 var CompleteAnimationsHandlingType;
-(function (CompleteAnimationsHandlingType) {
-    CompleteAnimationsHandlingType["returnToOriginal"] = "returnToOriginal";
-    CompleteAnimationsHandlingType["stayInCurrentState"] = "stayInCurrentState";
-    CompleteAnimationsHandlingType["jumpToEnd"] = "jumpToEnd";
+(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();
@@ -22,201 +21,199 @@ const DEFAULT_LOOP = false;
 const DEFAULT_RE_ANIMATE_HANDLING = ReAnimateHandlingType.throwError;
 const DEFAULT_COMPLETE_ANIMATIONS_HANDLING = CompleteAnimationsHandlingType.stayInCurrentState;
 class Animator {
-    static { this.animatedObjects = new Set(); }
-    constructor(target, effectOn, options = {}) {
-        this.effectOn = new Set();
-        this.running = true;
-        this.propertyStates = new Map();
-        if (!helpers_lib_1.Comparator.isObject(target)) {
-            throw new Error(`Animator: target is not an object! Target: '${target}'`);
-        }
-        else if (Animator.animatedObjects.has(target)) {
-            throw new Error(`Animator: target is already animated! Target: '${target}'`);
-        }
-        else {
-            Animator.animatedObjects.add(target);
-        }
-        this.targetObject = target;
-        this.effectOn = helpers_lib_1.Comparator.isArray(effectOn) ? new Set(effectOn) : new Set([effectOn]);
-        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)) {
-                throw new Error(`Animator: target does not have target property. Target property: '${key}'`);
-            }
-            else if (!helpers_lib_1.Comparator.isNumber(target[key])) {
-                throw new Error(`Animator: target property is not a number. Target property: '${key}'`);
-            }
-        });
+  static {
+    Animator.animatedObjects = new Set();
+  }
+  constructor(target, effectOn, options = {}) {
+    this.effectOn = new Set();
+    this.running = true;
+    this.propertyStates = new Map();
+    if (!helpers_lib_1.Comparator.isObject(target)) {
+      throw new Error(`Animator: target is not an object! Target: '${target}'`);
+    } else if (Animator.animatedObjects.has(target)) {
+      throw new Error(`Animator: target is already animated! Target: '${target}'`);
+    } else {
+      Animator.animatedObjects.add(target);
     }
-    get isAnimating() {
-        return this.propertyStates.size > 0;
+    this.targetObject = target;
+    this.effectOn = helpers_lib_1.Comparator.isArray(effectOn) ? new Set(effectOn) : new Set([effectOn]);
+    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)) {
+        throw new Error(`Animator: target does not have target property. Target property: '${key}'`);
+      } else if (!helpers_lib_1.Comparator.isNumber(target[key])) {
+        throw new Error(`Animator: target property is not a number. Target property: '${key}'`);
+      }
+    });
+  }
+  get isAnimating() {
+    return this.propertyStates.size > 0;
+  }
+  getAnimationStateOfKey(key) {
+    const 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
+      };
     }
-    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
-            };
-        }
+  }
+  onChange(callback) {
+    if (this.onChangeCallback) {
+      throw new Error('Animator: onChangeCallback is already set!');
     }
-    onChange(callback) {
-        if (this.onChangeCallback) {
-            throw new Error('Animator: onChangeCallback is already set!');
+    this.onChangeCallback = callback;
+    return this;
+  }
+  pauseAnimations() {
+    this.running = false;
+  }
+  resumeAnimations() {
+    this.running = true;
+  }
+  completeAnimations(completeAnimationsHandling) {
+    const triggerOnChange = this.isAnimating;
+    this.propertyStates.forEach((value, key) => {
+      const completeAnimationsHandlingFinal = completeAnimationsHandling || value.completeAnimationsHandling;
+      if (completeAnimationsHandlingFinal === CompleteAnimationsHandlingType.returnToOriginal) {
+        this.targetObject[key] = value.startingValue;
+      } else if (completeAnimationsHandlingFinal === CompleteAnimationsHandlingType.jumpToEnd) {
+        this.targetObject[key] = value.targetValue;
+      }
+      value.completionCallback();
+      this.propertyStates.delete(key);
+    });
+    triggerOnChange && this.onChangeCallback?.(this.targetObject);
+  }
+  set(values) {
+    Object.keys(values).forEach(key => {
+      this.checkPropertyValidity(key);
+      if (this.propertyStates.get(key)) {
+        throw new Error(`Animator: property is already being animated. Property: '${key}'`);
+      }
+    });
+    let triggerOnChange = false;
+    Object.keys(values).forEach(key => {
+      triggerOnChange = triggerOnChange || this.targetObject[key] !== values[key];
+      this.targetObject[key] = values[key];
+    });
+    triggerOnChange && this.onChangeCallback?.(this.targetObject);
+  }
+  async animate(values, options = {}) {
+    const valueKeys = Object.keys(values);
+    valueKeys.forEach(key => {
+      this.checkPropertyValidity(key);
+    });
+    return this.startAnimate(values, options);
+  }
+  startAnimate(values, options = {}) {
+    const reAnimateHandling = options.reAnimateHandling || this.defaultReAnimateHandling;
+    Object.keys(values).forEach(key => {
+      const previousState = this.propertyStates.get(key);
+      if (previousState) {
+        if (reAnimateHandling === ReAnimateHandlingType.throwError) {
+          throw new Error(`Animator: property is already being animated. Property: '${key}'`);
+        } else if (reAnimateHandling === ReAnimateHandlingType.ignore) {
+          delete values[key];
         }
-        this.onChangeCallback = callback;
-        return this;
-    }
-    pauseAnimations() {
-        this.running = false;
-    }
-    resumeAnimations() {
-        this.running = true;
-    }
-    completeAnimations(completeAnimationsHandling) {
-        let triggerOnChange = this.isAnimating;
-        this.propertyStates.forEach((value, key) => {
-            let completeAnimationsHandlingFinal = completeAnimationsHandling || value.completeAnimationsHandling;
-            if (completeAnimationsHandlingFinal === CompleteAnimationsHandlingType.returnToOriginal) {
-                this.targetObject[key] = value.startingValue;
-            }
-            else if (completeAnimationsHandlingFinal === CompleteAnimationsHandlingType.jumpToEnd) {
-                this.targetObject[key] = value.targetValue;
+      }
+    });
+    return new Promise(resolveAll => {
+      Promise.all(
+        Object.keys(values).map(
+          key =>
+            new Promise(resolve => {
+              const duration = options.duration || this.defaultDuration;
+              const animation = options.animation || this.defaultAnimation;
+              const loop = options.loop || this.defaultLoop;
+              const completeAnimationsHandling = options.completeAnimationsHandling || this.defaultCompleteAnimationsHandling;
+              animation.start();
+              try {
+                this.propertyStates.set(key, {
+                  duration,
+                  animation,
+                  elapsedTime: 0,
+                  startingValue: this.targetObject[key],
+                  targetValue: values[key],
+                  loop,
+                  completeAnimationsHandling,
+                  completionCallback: () => {
+                    resolve(undefined);
+                  }
+                });
+              } catch (e) {
+                resolveAll();
+              }
+            })
+        )
+      ).then(() => {
+        resolveAll();
+      });
+      this.subscribeUpdateCycle();
+    });
+  }
+  update(delta) {
+    if (this.running) {
+      const triggerOnChange = this.propertyStates.size;
+      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.targetObject[key] = value.startingValue;
+            } else {
+              this.targetObject[key] = value.targetValue;
             }
             value.completionCallback();
             this.propertyStates.delete(key);
-        });
-        triggerOnChange && this.onChangeCallback?.(this.targetObject);
-    }
-    set(values) {
-        Object.keys(values).forEach(key => {
-            this.checkPropertyValidity(key);
-            if (this.propertyStates.get(key)) {
-                throw new Error(`Animator: property is already being animated. Property: '${key}'`);
-            }
-        });
-        let triggerOnChange = false;
-        Object.keys(values).forEach(key => {
-            triggerOnChange = triggerOnChange || this.targetObject[key] !== values[key];
-            this.targetObject[key] = values[key];
-        });
-        triggerOnChange && this.onChangeCallback?.(this.targetObject);
-    }
-    async animate(values, options = {}) {
-        let valueKeys = Object.keys(values);
-        valueKeys.forEach(key => {
-            this.checkPropertyValidity(key);
-        });
-        return this.startAnimate(values, options);
-    }
-    startAnimate(values, options = {}) {
-        let reAnimateHandling = options.reAnimateHandling || this.defaultReAnimateHandling;
-        Object.keys(values).forEach(key => {
-            let previousState = this.propertyStates.get(key);
-            if (previousState) {
-                if (reAnimateHandling === ReAnimateHandlingType.throwError) {
-                    throw new Error(`Animator: property is already being animated. Property: '${key}'`);
-                }
-                else if (reAnimateHandling === ReAnimateHandlingType.ignore) {
-                    delete values[key];
-                }
-            }
-        });
-        return new Promise(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;
-                animation.start();
-                try {
-                    this.propertyStates.set(key, {
-                        duration,
-                        animation,
-                        elapsedTime: 0,
-                        startingValue: this.targetObject[key],
-                        targetValue: values[key],
-                        loop,
-                        completeAnimationsHandling,
-                        completionCallback: () => {
-                            resolve(undefined);
-                        }
-                    });
-                }
-                catch (e) {
-                    resolveAll();
-                }
-            }))).then(() => {
-                resolveAll();
-            });
-            this.subscribeUpdateCycle();
-        });
-    }
-    update(delta) {
-        if (this.running) {
-            let triggerOnChange = this.propertyStates.size;
-            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.targetObject[key] = value.startingValue;
-                        }
-                        else {
-                            this.targetObject[key] = value.targetValue;
-                        }
-                        value.completionCallback();
-                        this.propertyStates.delete(key);
-                    }
-                }
-                if (!animationIsCompete) {
-                    let multiplier = value.animation.multiplierFunction(value.elapsedTime / value.duration);
-                    let relativeTarget = value.targetValue - value.startingValue;
-                    this.targetObject[key] = relativeTarget * multiplier + value.startingValue;
-                }
-            });
-            triggerOnChange && this.onChangeCallback?.(this.targetObject);
-            if (this.propertyStates.size <= 0) {
-                this.updateCycleSubscription?.unsubscribe();
-            }
+          }
         }
-    }
-    subscribeUpdateCycle() {
+        if (!animationIsCompete) {
+          const multiplier = value.animation.multiplierFunction(value.elapsedTime / value.duration);
+          const relativeTarget = value.targetValue - value.startingValue;
+          this.targetObject[key] = relativeTarget * multiplier + value.startingValue;
+        }
+      });
+      triggerOnChange && this.onChangeCallback?.(this.targetObject);
+      if (this.propertyStates.size <= 0) {
         this.updateCycleSubscription?.unsubscribe();
-        this.updateCycleSubscription = update_loop_1.UpdateCycle.updateAction
-            .subscribe(update => {
-            try {
-                this.update(update.delta);
-            }
-            catch (e) {
-                this.propertyStates.forEach(value => {
-                    value.completionCallback();
-                });
-                this.propertyStates = new Map();
-                this.updateCycleSubscription?.unsubscribe();
-            }
-        })
-            .skipAttachCheck();
+      }
     }
-    checkPropertyValidity(key) {
-        if (!this.effectOn.has(key)) {
-            throw new Error(`Animator: not effected property is tried to update. Key: '${key}', EffectOn: '${this.effectOn}'`);
+  }
+  subscribeUpdateCycle() {
+    this.updateCycleSubscription?.unsubscribe();
+    this.updateCycleSubscription = update_loop_1.UpdateCycle.updateAction
+      .subscribe(update => {
+        try {
+          this.update(update.delta);
+        } catch (e) {
+          this.propertyStates.forEach(value => {
+            value.completionCallback();
+          });
+          this.propertyStates = new Map();
+          this.updateCycleSubscription?.unsubscribe();
         }
+      })
+      .skipAttachCheck();
+  }
+  checkPropertyValidity(key) {
+    if (!this.effectOn.has(key)) {
+      throw new Error(`Animator: not effected property is tried to update. Key: '${key}', EffectOn: '${this.effectOn}'`);
     }
+  }
 }
 exports.Animator = Animator;
-//# sourceMappingURL=animator.js.map
+//# sourceMappingURL=animator.js.map