bard-legends-framework 0.10.8 → 0.11.0

package/dist/utilities/grid-algorithms/vector-field-path-finder/vector-field-path-finder.test.js

@@ -0,0 +1,254 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const helpers_lib_1 = require("helpers-lib");
+const vitest_1 = require("vitest");
+const vector_field_path_finder_1 = require("./vector-field-path-finder");
+(0, vitest_1.describe)('VectorFieldPathFinder', () => {
+    (0, vitest_1.describe)('weight grid', () => {
+        (0, vitest_1.test)('basic 1', () => {
+            let targetArea = helpers_lib_1.Rectangle.fromRect({ topLeft: { x: 0, y: 0 }, bottomRight: { x: 0, y: 0 } });
+            let availabilityGrid = new helpers_lib_1.Grid({ size: new helpers_lib_1.Vector(1, 1), defaultValue: true });
+            let pathFinder = new vector_field_path_finder_1.VectorFieldPathFinder(targetArea, availabilityGrid);
+            (0, vitest_1.expect)(pathFinder['weightGrid'].get(new helpers_lib_1.Vector(0, 0))).toBe(0);
+        });
+        (0, vitest_1.test)('basic 2', () => {
+            let targetArea = helpers_lib_1.Rectangle.fromRect({ topLeft: { x: 0, y: 0 }, bottomRight: { x: 1, y: 1 } });
+            let availabilityGrid = new helpers_lib_1.Grid([
+                [true, true],
+                [true, true]
+            ]);
+            let pathFinder = new vector_field_path_finder_1.VectorFieldPathFinder(targetArea, availabilityGrid);
+            (0, vitest_1.expect)(pathFinder['weightGrid'].get(new helpers_lib_1.Vector(0, 0))).toBe(0);
+            (0, vitest_1.expect)(pathFinder['weightGrid'].get(new helpers_lib_1.Vector(1, 0))).toBe(0);
+            (0, vitest_1.expect)(pathFinder['weightGrid'].get(new helpers_lib_1.Vector(0, 1))).toBe(0);
+            (0, vitest_1.expect)(pathFinder['weightGrid'].get(new helpers_lib_1.Vector(1, 1))).toBe(0);
+        });
+        (0, vitest_1.test)('sample 1', () => {
+            let targetArea = helpers_lib_1.Rectangle.fromRect({ topLeft: { x: 0, y: 0 }, bottomRight: { x: 0, y: 0 } });
+            let availabilityGrid = new helpers_lib_1.Grid([
+                [true, true],
+                [true, true]
+            ]);
+            let pathFinder = new vector_field_path_finder_1.VectorFieldPathFinder(targetArea, availabilityGrid);
+            (0, vitest_1.expect)(pathFinder['weightGrid'].get(new helpers_lib_1.Vector(0, 0))).toBe(0);
+            (0, vitest_1.expect)(pathFinder['weightGrid'].get(new helpers_lib_1.Vector(1, 0))).toBe(10);
+            (0, vitest_1.expect)(pathFinder['weightGrid'].get(new helpers_lib_1.Vector(0, 1))).toBe(10);
+            (0, vitest_1.expect)(pathFinder['weightGrid'].get(new helpers_lib_1.Vector(1, 1))).toBe(14);
+        });
+        (0, vitest_1.test)('sample 2', () => {
+            let targetArea = helpers_lib_1.Rectangle.fromRect({ topLeft: { x: 0, y: 0 }, bottomRight: { x: 1, y: 1 } });
+            let availabilityGrid = new helpers_lib_1.Grid({ size: new helpers_lib_1.Vector(3, 3), defaultValue: true });
+            let pathFinder = new vector_field_path_finder_1.VectorFieldPathFinder(targetArea, availabilityGrid);
+            (0, vitest_1.expect)(pathFinder['weightGrid']['_grid']).toEqual([
+                [0, 0, 10],
+                [0, 0, 10],
+                [10, 10, 14]
+            ]);
+        });
+        (0, vitest_1.test)('sample 3', () => {
+            let targetArea = helpers_lib_1.Rectangle.fromRect({ topLeft: { x: 1, y: 1 }, bottomRight: { x: 2, y: 2 } });
+            let availabilityGrid = new helpers_lib_1.Grid({ size: new helpers_lib_1.Vector(3, 3), defaultValue: true });
+            let pathFinder = new vector_field_path_finder_1.VectorFieldPathFinder(targetArea, availabilityGrid);
+            (0, vitest_1.expect)(pathFinder['weightGrid']['_grid']).toEqual([
+                [14, 10, 10],
+                [10, 0, 0],
+                [10, 0, 0]
+            ]);
+        });
+        (0, vitest_1.test)('complex 1', () => {
+            let targetArea = helpers_lib_1.Rectangle.fromRect({ topLeft: { x: 0, y: 0 }, bottomRight: { x: 0, y: 0 } });
+            let availabilityGrid = new helpers_lib_1.Grid([
+                [true, false, true],
+                [true, true, true],
+                [false, false, true],
+                [false, false, true]
+            ]);
+            let pathFinder = new vector_field_path_finder_1.VectorFieldPathFinder(targetArea, availabilityGrid);
+            let h = pathFinder['getHighestWeight'](availabilityGrid.size);
+            (0, vitest_1.expect)(pathFinder['weightGrid']['_grid']).toEqual([
+                [0, h, 28],
+                [10, 14, 24],
+                [h, h, 28],
+                [h, h, 38]
+            ]);
+        });
+        (0, vitest_1.test)('complex 2', () => {
+            let targetArea = helpers_lib_1.Rectangle.fromRect({ topLeft: { x: 0, y: 0 }, bottomRight: { x: 1, y: 1 } });
+            let availabilityGrid = new helpers_lib_1.Grid([
+                [true, true, false, true],
+                [true, true, false, true],
+                [false, false, true, true]
+            ]);
+            let pathFinder = new vector_field_path_finder_1.VectorFieldPathFinder(targetArea, availabilityGrid);
+            let h = pathFinder['getHighestWeight'](availabilityGrid.size);
+            (0, vitest_1.expect)(pathFinder['weightGrid']['_grid']).toEqual([
+                [0, 0, h, 38],
+                [0, 0, h, 28],
+                [h, h, 14, 24]
+            ]);
+        });
+        (0, vitest_1.test)('complex 3', () => {
+            let targetArea = helpers_lib_1.Rectangle.fromRect({ topLeft: { x: 2, y: 2 }, bottomRight: { x: 3, y: 3 } });
+            let availabilityGrid = new helpers_lib_1.Grid([
+                [true, true, false, true],
+                [true, true, false, true],
+                [false, false, true, true],
+                [false, false, true, true]
+            ]);
+            let pathFinder = new vector_field_path_finder_1.VectorFieldPathFinder(targetArea, availabilityGrid);
+            let h = pathFinder['getHighestWeight'](availabilityGrid.size);
+            (0, vitest_1.expect)(pathFinder['weightGrid']['_grid']).toEqual([
+                [28, 24, h, 20],
+                [24, 14, h, 10],
+                [h, h, 0, 0],
+                [h, h, 0, 0]
+            ]);
+        });
+        (0, vitest_1.test)('unreachable area 1', () => {
+            let targetArea = helpers_lib_1.Rectangle.fromRect({ topLeft: { x: 0, y: 0 }, bottomRight: { x: 0, y: 0 } });
+            let availabilityGrid = new helpers_lib_1.Grid([
+                [true, false, true, false, true],
+                [true, false, true, false, true],
+                [true, false, false, false, true],
+                [true, false, false, false, true],
+                [true, true, true, true, true]
+            ]);
+            let pathFinder = new vector_field_path_finder_1.VectorFieldPathFinder(targetArea, availabilityGrid);
+            let h = pathFinder['getHighestWeight'](availabilityGrid.size);
+            (0, vitest_1.expect)(pathFinder['weightGrid']['_grid']).toEqual([
+                [0, h, h, h, 108],
+                [10, h, h, h, 98],
+                [20, h, h, h, 88],
+                [30, h, h, h, 78],
+                [40, 44, 54, 64, 74]
+            ]);
+        });
+    });
+    (0, vitest_1.describe)('getDirectionToTarget', () => {
+        (0, vitest_1.test)('sample 1', () => {
+            let targetArea = helpers_lib_1.Rectangle.fromRect({ topLeft: { x: 0, y: 0 }, bottomRight: { x: 0, y: 0 } });
+            let availabilityGrid = new helpers_lib_1.Grid([
+                [true, true],
+                [true, true]
+            ]);
+            let pathFinder = new vector_field_path_finder_1.VectorFieldPathFinder(targetArea, availabilityGrid);
+            (0, vitest_1.expect)(pathFinder.getDirectionToTarget(new helpers_lib_1.Vector(1, 1))?.value).toEqual(helpers_lib_1.Radian.get315.value);
+        });
+        (0, vitest_1.test)('sample 2', () => {
+            let targetArea = helpers_lib_1.Rectangle.fromRect({ topLeft: { x: 0, y: 0 }, bottomRight: { x: 0, y: 0 } });
+            let availabilityGrid = new helpers_lib_1.Grid([
+                [true, true, true],
+                [false, true, true]
+            ]);
+            let pathFinder = new vector_field_path_finder_1.VectorFieldPathFinder(targetArea, availabilityGrid);
+            (0, vitest_1.expect)(pathFinder.getDirectionToTarget(new helpers_lib_1.Vector(2, 1))?.value).toEqual(new helpers_lib_1.Vector(-2, -1).radian.value);
+        });
+        (0, vitest_1.test)('sample 3', () => {
+            let targetArea = helpers_lib_1.Rectangle.fromRect({ topLeft: { x: 0, y: 0 }, bottomRight: { x: 0, y: 0 } });
+            let availabilityGrid = new helpers_lib_1.Grid([
+                [true, false, true],
+                [true, false, true],
+                [true, true, true]
+            ]);
+            let pathFinder = new vector_field_path_finder_1.VectorFieldPathFinder(targetArea, availabilityGrid);
+            (0, vitest_1.expect)(pathFinder.getDirectionToTarget(new helpers_lib_1.Vector(2, 0))?.value).toEqual(helpers_lib_1.Radian.get180.value);
+        });
+        (0, vitest_1.test)('sample 4', () => {
+            let targetArea = helpers_lib_1.Rectangle.fromRect({ topLeft: { x: 0, y: 0 }, bottomRight: { x: 0, y: 0 } });
+            let availabilityGrid = new helpers_lib_1.Grid([
+                [true, false, false],
+                [true, false, false]
+            ]);
+            let pathFinder = new vector_field_path_finder_1.VectorFieldPathFinder(targetArea, availabilityGrid);
+            (0, vitest_1.expect)(pathFinder.getDirectionToTarget(new helpers_lib_1.Vector(2, 0))).toBeUndefined();
+        });
+    });
+    (0, vitest_1.describe)('edge cases', () => {
+        (0, vitest_1.test)('should create an instance', () => {
+            let targetArea = helpers_lib_1.Rectangle.fromRect({ topLeft: { x: 0, y: 0 }, bottomRight: { x: 0, y: 0 } });
+            let availabilityGrid = new helpers_lib_1.Grid({ size: new helpers_lib_1.Vector(1, 1), defaultValue: true });
+            (0, vitest_1.expect)(new vector_field_path_finder_1.VectorFieldPathFinder(targetArea, availabilityGrid)).toBeTruthy();
+        });
+        (0, vitest_1.test)('should activate unavailable target cells of the target area', () => {
+            let targetArea = helpers_lib_1.Rectangle.fromRect({ topLeft: { x: 0, y: 0 }, bottomRight: { x: 0, y: 0 } });
+            let availabilityGrid = new helpers_lib_1.Grid({ size: new helpers_lib_1.Vector(1, 1), defaultValue: false });
+            let pathFinder = new vector_field_path_finder_1.VectorFieldPathFinder(targetArea, availabilityGrid);
+            (0, vitest_1.expect)(pathFinder['weightGrid'].get(new helpers_lib_1.Vector(0, 0))).toBe(0);
+        });
+        (0, vitest_1.test)('should select closest grid cells if the target is outside of the grid', () => {
+            let targetArea = helpers_lib_1.Rectangle.fromRect({ topLeft: { x: 3, y: -1 }, bottomRight: { x: 3, y: 1 } });
+            let availabilityGrid = new helpers_lib_1.Grid({ size: new helpers_lib_1.Vector(3, 3), defaultValue: true });
+            let pathFinder = new vector_field_path_finder_1.VectorFieldPathFinder(targetArea, availabilityGrid);
+            (0, vitest_1.expect)(pathFinder['weightGrid']['_grid']).toEqual([
+                [20, 10, 0],
+                [20, 10, 0],
+                [24, 14, 10]
+            ]);
+        });
+        (0, vitest_1.test)('should return undefined if starting position and its neighbors are unreachable', () => {
+            let targetArea = helpers_lib_1.Rectangle.fromRect({ topLeft: { x: 0, y: 0 }, bottomRight: { x: 0, y: 0 } });
+            let availabilityGrid = new helpers_lib_1.Grid([
+                [true, false, false],
+                [true, false, false]
+            ]);
+            let pathFinder = new vector_field_path_finder_1.VectorFieldPathFinder(targetArea, availabilityGrid);
+            (0, vitest_1.expect)(pathFinder.getDirectionToTarget(new helpers_lib_1.Vector(2, 1))).toBeUndefined();
+        });
+        (0, vitest_1.test)('should find the direction if starting position is unreachable but there is a reachable neighbor', () => {
+            let targetArea = helpers_lib_1.Rectangle.fromRect({ topLeft: { x: 0, y: 0 }, bottomRight: { x: 0, y: 0 } });
+            let availabilityGrid = new helpers_lib_1.Grid([
+                [true, true, false],
+                [true, false, false]
+            ]);
+            let pathFinder = new vector_field_path_finder_1.VectorFieldPathFinder(targetArea, availabilityGrid);
+            (0, vitest_1.expect)(pathFinder.getDirectionToTarget(new helpers_lib_1.Vector(2, 1))?.value).toEqual(helpers_lib_1.Radian.get315.value);
+        });
+        (0, vitest_1.test)('should return undefined if starting point is inside target area', () => {
+            let targetArea = helpers_lib_1.Rectangle.fromRect({ topLeft: { x: 0, y: 0 }, bottomRight: { x: 1, y: 1 } });
+            let availabilityGrid = new helpers_lib_1.Grid({ size: new helpers_lib_1.Vector(2, 2), defaultValue: true });
+            let pathFinder = new vector_field_path_finder_1.VectorFieldPathFinder(targetArea, availabilityGrid);
+            (0, vitest_1.expect)(pathFinder.getDirectionToTarget(new helpers_lib_1.Vector(0, 0))).toBeUndefined();
+        });
+        (0, vitest_1.test)('should return closest cell result if starting point is outside of the grid', () => {
+            let targetArea = helpers_lib_1.Rectangle.fromRect({ topLeft: { x: 0, y: 0 }, bottomRight: { x: 0, y: 0 } });
+            let availabilityGrid = new helpers_lib_1.Grid({ size: new helpers_lib_1.Vector(2, 1), defaultValue: true });
+            let pathFinder = new vector_field_path_finder_1.VectorFieldPathFinder(targetArea, availabilityGrid);
+            (0, vitest_1.expect)(pathFinder.getDirectionToTarget(new helpers_lib_1.Vector(2, 0))?.value).toEqual(helpers_lib_1.Radian.get270.value);
+        });
+        (0, vitest_1.test)('if average direction is pointing blocked path, it should pick random available direction', () => {
+            let targetArea = helpers_lib_1.Rectangle.fromRect({ topLeft: { x: 0, y: 0 }, bottomRight: { x: 0, y: 0 } });
+            let availabilityGrid = new helpers_lib_1.Grid([
+                [true, true, true],
+                [true, false, true],
+                [true, true, true]
+            ]);
+            let pathFinder = new vector_field_path_finder_1.VectorFieldPathFinder(targetArea, availabilityGrid);
+            let result = pathFinder.getDirectionToTarget(new helpers_lib_1.Vector(2, 2));
+            (0, vitest_1.expect)(result?.value === helpers_lib_1.Radian.get270.value || result?.value === 0).toBeTruthy();
+        });
+        (0, vitest_1.test)('finding path from unavailable space should point the direction away from the obstacle', () => {
+            let targetArea = helpers_lib_1.Rectangle.fromRect({ topLeft: { x: 0, y: 0 }, bottomRight: { x: 0, y: 0 } });
+            let availabilityGrid = new helpers_lib_1.Grid([
+                [true, true, true, true],
+                [true, false, false, true],
+                [true, false, false, true],
+                [true, true, true, true]
+            ]);
+            let pathFinder = new vector_field_path_finder_1.VectorFieldPathFinder(targetArea, availabilityGrid);
+            let result = pathFinder.getDirectionToTarget(new helpers_lib_1.Vector(2, 2));
+            (0, vitest_1.expect)(result?.value).toEqual(helpers_lib_1.Radian.get135.value);
+        });
+        (0, vitest_1.test)('finding path from unavailable space should point the direction to the best neighbor if all neighbors are available', () => {
+            let targetArea = helpers_lib_1.Rectangle.fromRect({ topLeft: { x: 0, y: 0 }, bottomRight: { x: 0, y: 0 } });
+            let availabilityGrid = new helpers_lib_1.Grid([
+                [true, false, true, false],
+                [true, false, true, true],
+                [true, true, true, true]
+            ]);
+            let pathFinder = new vector_field_path_finder_1.VectorFieldPathFinder(targetArea, availabilityGrid);
+            let result = pathFinder.getDirectionToTarget(new helpers_lib_1.Vector(3, 0));
+            (0, vitest_1.expect)(result?.value).toEqual(-helpers_lib_1.Radian.get135.value);
+        });
+    });
+});
+//# sourceMappingURL=vector-field-path-finder.test.js.map

package/dist/utilities/index.d.ts

@@ -1,6 +1,6 @@
-export * from './libraries/animator';
-export { VectorSet } from './libraries/data-structures/vector-set/vector-set';
-export { DeltaTime } from './libraries/delta-time/delta-time';
-export { ClosestAvailableSpaceHelper } from './libraries/grid-algorithms/closest-available-space/closest-available-space.helper';
-export { PathFinder, PathFinderResult } from './libraries/grid-algorithms/path-finder/path-finder';
-export { VectorFieldPathFinder } from './libraries/grid-algorithms/vector-field-path-finder/vector-field-path-finder';
+export * from './animator';
+export { VectorSet } from './data-structures/vector-set/vector-set';
+export { DeltaTime } from './delta-time/delta-time';
+export { ClosestAvailableSpaceHelper } from './grid-algorithms/closest-available-space/closest-available-space.helper';
+export { PathFinder, PathFinderResult } from './grid-algorithms/path-finder/path-finder';
+export { VectorFieldPathFinder } from './grid-algorithms/vector-field-path-finder/vector-field-path-finder';

package/dist/utilities/index.js

@@ -15,15 +15,15 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.VectorFieldPathFinder = exports.PathFinder = exports.ClosestAvailableSpaceHelper = exports.DeltaTime = exports.VectorSet = void 0;
-__exportStar(require("./libraries/animator"), exports);
-var vector_set_1 = require("./libraries/data-structures/vector-set/vector-set");
+__exportStar(require("./animator"), exports);
+var vector_set_1 = require("./data-structures/vector-set/vector-set");
 Object.defineProperty(exports, "VectorSet", { enumerable: true, get: function () { return vector_set_1.VectorSet; } });
-var delta_time_1 = require("./libraries/delta-time/delta-time");
+var delta_time_1 = require("./delta-time/delta-time");
 Object.defineProperty(exports, "DeltaTime", { enumerable: true, get: function () { return delta_time_1.DeltaTime; } });
-var closest_available_space_helper_1 = require("./libraries/grid-algorithms/closest-available-space/closest-available-space.helper");
+var closest_available_space_helper_1 = require("./grid-algorithms/closest-available-space/closest-available-space.helper");
 Object.defineProperty(exports, "ClosestAvailableSpaceHelper", { enumerable: true, get: function () { return closest_available_space_helper_1.ClosestAvailableSpaceHelper; } });
-var path_finder_1 = require("./libraries/grid-algorithms/path-finder/path-finder");
+var path_finder_1 = require("./grid-algorithms/path-finder/path-finder");
 Object.defineProperty(exports, "PathFinder", { enumerable: true, get: function () { return path_finder_1.PathFinder; } });
-var vector_field_path_finder_1 = require("./libraries/grid-algorithms/vector-field-path-finder/vector-field-path-finder");
+var vector_field_path_finder_1 = require("./grid-algorithms/vector-field-path-finder/vector-field-path-finder");
 Object.defineProperty(exports, "VectorFieldPathFinder", { enumerable: true, get: function () { return vector_field_path_finder_1.VectorFieldPathFinder; } });
 //# sourceMappingURL=index.js.map

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

@@ -1,5 +1,4 @@
-import { AttachmentTarget } from '../../../game-entities';
-import { Attachable } from '../../../game-entities/base/attachable';
+import { Attachable } from '../../../game-entities';
 import { AnimatorAnimation } from './animations';
 export interface AnimationState {
     duration: number;
@@ -43,12 +42,11 @@ export declare class Animator<T> extends Attachable {
     private allResolvers;
     get isAnimating(): boolean;
     constructor(target: T, effectOn: string | string[], options?: AnimationOptions);
-    destroy(): void;
-    attach(parent: AttachmentTarget | string): this;
+    attach(parent: Attachable | string): this;
     attachToRoot(): this;
     onChange(callback: (target: T) => void): Animator<T>;
     onComplete(callback: (key: string, value: number) => void): Animator<T>;
-    protected destroySelf(): void;
+    destroy(): void;
     getAnimationStateOfKey(key: string): AnimationState | undefined;
     pauseAnimations(): void;
     resumeAnimations(): void;

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

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Animator = exports.CompleteAnimationsHandlingType = exports.ReAnimateHandlingType = void 0;
 const helpers_lib_1 = require("helpers-lib");
-const attachable_1 = require("../../../game-entities/base/attachable");
+const game_entities_1 = require("../../../game-entities");
 const update_cycle_1 = require("../../../game-entities/update-cycle");
 const animations_1 = require("./animations");
 var ReAnimateHandlingType;
@@ -22,7 +22,7 @@ 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 attachable_1.Attachable {
+class Animator extends game_entities_1.Attachable {
     static { this.animatedObjects = new Map(); }
     get isAnimating() {
         return this.propertyStates.size > 0;
@@ -67,10 +67,6 @@ class Animator extends attachable_1.Attachable {
             }
         });
     }
-    // make the destroy function non-internal
-    destroy() {
-        super.destroy();
-    }
     // make the attach function non-internal
     attach(parent) {
         super.attach(parent);
@@ -97,20 +93,22 @@ class Animator extends attachable_1.Attachable {
         this.onCompleteCallback = callback;
         return this;
     }
-    destroySelf() {
-        super.destroySelf();
-        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);
+    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();
         }
-        this.target = undefined;
-        this.allResolvers.forEach(resolver => resolver());
-        this.allResolvers.clear();
     }
     getAnimationStateOfKey(key) {
         let propertyState = this.propertyStates.get(key);

package/dist/utilities/libraries/animator/state-animation/slide-state-animation.d.ts

@@ -1,10 +1,10 @@
-import { AttachmentTarget } from '../../../../game-entities';
+import { Attachable } from '../../../../game-entities';
 import { StateAnimationOptions } from './state-animation';
 export declare enum SlideStateAnimationState {
     appear = "appear",
     disappear = "disappear"
 }
-export declare class SlideStateAnimation extends AttachmentTarget {
+export declare class SlideStateAnimation extends Attachable {
     private stateAnimation;
     private options;
     private index;

package/dist/utilities/libraries/animator/state-animation/slide-state-animation.js

@@ -11,7 +11,7 @@ var SlideStateAnimationState;
     SlideStateAnimationState["appear"] = "appear";
     SlideStateAnimationState["disappear"] = "disappear";
 })(SlideStateAnimationState || (exports.SlideStateAnimationState = SlideStateAnimationState = {}));
-class SlideStateAnimation extends game_entities_1.AttachmentTarget {
+class SlideStateAnimation extends game_entities_1.Attachable {
     constructor(partialOptions) {
         super();
         this.animationState = 'idle';

package/dist/utilities/libraries/animator/state-animation/state-animation.d.ts

@@ -1,11 +1,11 @@
-import { AttachmentTarget } from '../../../../game-entities';
+import { Attachable } from '../../../../game-entities';
 import { AnimatorAnimation } from '../animations';
 export interface StateAnimationOptions {
     readonly duration: number;
     readonly animation: AnimatorAnimation;
 }
 type AnimationState = 'idle' | 'transitioning' | 'reverting';
-export declare class StateAnimation<T> extends AttachmentTarget {
+export declare class StateAnimation<T> extends Attachable {
     private animator;
     private options;
     private value;

package/dist/utilities/libraries/animator/state-animation/state-animation.js

@@ -5,7 +5,7 @@ const actions_lib_1 = require("actions-lib");
 const game_entities_1 = require("../../../../game-entities");
 const animations_1 = require("../animations");
 const animator_1 = require("../animator");
-class StateAnimation extends game_entities_1.AttachmentTarget {
+class StateAnimation extends game_entities_1.Attachable {
     get currentState() {
         return {
             value: this.value,

package/dist/utilities/libraries/animator/state-animation/visit-disappear-state-animation.d.ts

@@ -1,7 +1,7 @@
-import { AttachmentTarget } from '../../../../game-entities';
+import { Attachable } from '../../../../game-entities';
 import { StateAnimationOptions } from './state-animation';
 type AnimationState = 'hidden' | 'visible' | 'appearing' | 'disappearing' | 'disappearToChange';
-export declare class VisitDisappearStateAnimation<T> extends AttachmentTarget {
+export declare class VisitDisappearStateAnimation<T> extends Attachable {
     private animator;
     private options;
     private value;

package/dist/utilities/libraries/animator/state-animation/visit-disappear-state-animation.js

@@ -5,7 +5,7 @@ const actions_lib_1 = require("actions-lib");
 const game_entities_1 = require("../../../../game-entities");
 const animations_1 = require("../animations");
 const animator_1 = require("../animator");
-class VisitDisappearStateAnimation extends game_entities_1.AttachmentTarget {
+class VisitDisappearStateAnimation extends game_entities_1.Attachable {
     get currentState() {
         return {
             value: this.value,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bard-legends-framework",
-  "version": "0.10.8",
+  "version": "0.11.0",
   "description": "Bard Legends Framework",
   "main": "dist/index.js",
   "files": [
@@ -28,19 +28,19 @@
     "test": "vitest run",
     "build": "tsc",
     "lint": "biome check . --write --max-diagnostics=1",
-    "deploy": "vitest run && npm run build && npm publish",
+    "deploy": "npm i && vitest run && npm run build && npm publish",
     "prepack": "cp package.json package.json.bak && ts-node scripts/prepare-package-json.ts",
     "postpack": "mv package.json.bak package.json"
   },
   "dependencies": {
     "p2": "0.7.1",
     "pixi.js": "7.4.2",
-    "reflect-metadata": "0.2.1"
+    "reflect-metadata": "0.2.2"
   },
   "peerDependencies": {
-    "actions-lib": "1.8.6",
-    "helpers-lib": "1.13.10",
-    "script-engine-lib": "0.4.3"
+    "actions-lib": "^2.0.0",
+    "helpers-lib": "^1.13.10",
+    "script-engine-lib": "^0.4.3"
   },
   "devDependencies": {
     "@biomejs/biome": "2.2.4",