bard-legends-framework 0.9.3 → 0.9.5

package/dist/physics/helpers/closest-available-space.helper.spec.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const closest_available_space_helper_1 = require("./closest-available-space.helper");
+describe('findClosestAvailableSpace', () => {
+    let helper;
+    let newObject;
+    beforeEach(() => {
+        helper = new closest_available_space_helper_1.ClosestAvailableSpaceHelper(100, 100, 10);
+    });
+    it('should return no change vector if the location is available', () => {
+        newObject = { topLeft: { x: 50, y: 50 }, bottomRight: { x: 60, y: 60 } };
+        expect(helper.findClosestAvailableSpace(newObject)).toEqual({ x: 0, y: 0 });
+    });
+    it('should support object positions outside of the world size', () => {
+        newObject = { topLeft: { x: -5, y: -5 }, bottomRight: { x: 5, y: 5 } };
+        expect(helper.findClosestAvailableSpace(newObject)).toEqual({ x: 5, y: 5 });
+        newObject = { topLeft: { x: 95, y: 95 }, bottomRight: { x: 105, y: 105 } };
+        expect(helper.findClosestAvailableSpace(newObject)).toEqual({ x: -5, y: -5 });
+    });
+    it('should find the no change vector space next to an existing object', () => {
+        helper.markObjectOnGrid({ topLeft: { x: 0, y: 0 }, bottomRight: { x: 10, y: 10 } });
+        newObject = { topLeft: { x: 10, y: 10 }, bottomRight: { x: 20, y: 20 } };
+        expect(helper.findClosestAvailableSpace(newObject)).toEqual({ x: 0, y: 0 });
+    });
+    it('should find the closest available space if trying to spawn in occupied space', () => {
+        helper.markObjectOnGrid({ topLeft: { x: 0, y: 0 }, bottomRight: { x: 20, y: 20 } });
+        newObject = { topLeft: { x: 5, y: 5 }, bottomRight: { x: 15, y: 15 } };
+        expect(helper.findClosestAvailableSpace(newObject)).toEqual({ x: 15, y: -5 });
+    });
+    it('should find the closest available space if trying to spawn in crowded space', () => {
+        // Crowded space
+        //   0 1 2 3 4 5 6 7 8 9
+        // 0 □ 1 1 1 2 2 □ □ □ □
+        // 1 □ 1 1 1 2 2 □ □ □ □
+        // 2 □ 1 1 1 2 2 □ □ □ □
+        // 3 3 3 3 ■ ■ ■ □ □ □ □
+        // 4 □ □ □ ■ ■ ■ □ □ □ □
+        // 5 □ □ 4 ■ ■ ■ 6 6 6 □
+        // 6 □ □ 4 5 5 5 □ □ □ □
+        helper.markObjectOnGrid({ topLeft: { x: 12, y: 5 }, bottomRight: { x: 35, y: 25 } });
+        helper.markObjectOnGrid({ topLeft: { x: 45, y: 5 }, bottomRight: { x: 52, y: 25 } });
+        helper.markObjectOnGrid({ topLeft: { x: -2, y: 32 }, bottomRight: { x: 12, y: 35 } });
+        helper.markObjectOnGrid({ topLeft: { x: 22, y: 55 }, bottomRight: { x: 28, y: 62 } });
+        helper.markObjectOnGrid({ topLeft: { x: 35, y: 65 }, bottomRight: { x: 52, y: 75 } });
+        helper.markObjectOnGrid({ topLeft: { x: 74, y: 42 }, bottomRight: { x: 95, y: 48 } });
+        newObject = { topLeft: { x: 10, y: 20 }, bottomRight: { x: 40, y: 50 } };
+        expect(helper.findClosestAvailableSpace(newObject)).toEqual({ x: 20, y: 10 });
+    });
+    it('should not fooled by initial position occupying more space in grid and find narrower gap', () => {
+        helper.markObjectOnGrid({ topLeft: { x: 10, y: 0 }, bottomRight: { x: 40, y: 30 } });
+        newObject = { topLeft: { x: 4, y: 2 }, bottomRight: { x: 12, y: 20 } };
+        expect(helper.findClosestAvailableSpace(newObject)).toEqual({ x: -3, y: -1 });
+    });
+    it('should not fooled by initial position occupying more space in grid and find narrower gap negative starting point', () => {
+        helper.markObjectOnGrid({ topLeft: { x: 10, y: 0 }, bottomRight: { x: 40, y: 30 } });
+        newObject = { topLeft: { x: -6, y: -8 }, bottomRight: { x: 2, y: 10 } };
+        expect(helper.findClosestAvailableSpace(newObject)).toEqual({ x: 7, y: 9 });
+    });
+    it('should not suggest a location at the edge of the map', () => {
+        helper = new closest_available_space_helper_1.ClosestAvailableSpaceHelper(10, 10, 9);
+        helper.markObjectOnGrid({ topLeft: { x: 0, y: 0 }, bottomRight: { x: 9, y: 9 } });
+        newObject = { topLeft: { x: 0, y: 0 }, bottomRight: { x: 1, y: 1 } };
+        expect(helper.findClosestAvailableSpace(newObject)).toBeUndefined();
+    });
+    it('should return undefined if there is no available space', () => {
+        helper.markObjectOnGrid({ topLeft: { x: 0, y: 0 }, bottomRight: { x: 100, y: 100 } });
+        newObject = { topLeft: { x: 0, y: 0 }, bottomRight: { x: 10, y: 10 } };
+        expect(helper.findClosestAvailableSpace(newObject)).toBeUndefined();
+    });
+});
+//# sourceMappingURL=closest-available-space.helper.spec.js.map

package/dist/pixi/components/display-object-array.d.ts

@@ -13,6 +13,16 @@ export declare class DisplayObjectArray<T> extends Container {
     private createFunction;
     private displayObjects;
     private options;
+    /**
+     * @param createFunction function to create the display object
+     * @param partialOptions.trackBy default is index
+     * @param partialOptions.positioning.direction default is vertical
+     * @param partialOptions.positioning.spacing default is 0
+     */
     constructor(createFunction: (item: T) => UpdatableContainer<T>, partialOptions?: Partial<DisplayObjectArrayOptions<T>>);
+    /**
+     * Updates the display objects. Removes the deleted ones, updates the existing ones with their "trackBy" key, creates the new ones.
+     * @param items new items list
+     */
     set(items: T[]): void;
 }

package/dist/pixi/components/display-object-array.js

@@ -6,6 +6,12 @@ class UpdatableContainer extends display_object_1.Container {
 }
 exports.UpdatableContainer = UpdatableContainer;
 class DisplayObjectArray extends display_object_1.Container {
+    /**
+     * @param createFunction function to create the display object
+     * @param partialOptions.trackBy default is index
+     * @param partialOptions.positioning.direction default is vertical
+     * @param partialOptions.positioning.spacing default is 0
+     */
     constructor(createFunction, partialOptions) {
         super();
         this.createFunction = createFunction;
@@ -19,6 +25,10 @@ class DisplayObjectArray extends display_object_1.Container {
             ...partialOptions
         };
     }
+    /**
+     * Updates the display objects. Removes the deleted ones, updates the existing ones with their "trackBy" key, creates the new ones.
+     * @param items new items list
+     */
     set(items) {
         let unUsedItems = new Set(this.displayObjects.values());
         let position = 0;

package/dist/pixi/components/helpers/smooth-scroller.js

@@ -10,7 +10,7 @@ class SmoothScroller extends game_entities_1.Destroyable {
         return this._scrollHeight;
     }
     get contentSize() {
-        return this.content.size;
+        return this.content.size.ceil();
     }
     constructor(content, areaHeight, padding, smallContentAlign) {
         super();
@@ -33,22 +33,23 @@ class SmoothScroller extends game_entities_1.Destroyable {
         this.setTarget(-Infinity);
     }
     setTarget(target) {
-        this.target = helpers_lib_1.NumberHelper.clamp(target, this.areaHeight - this.padding - this.content.size.y, this.padding);
+        this.target = helpers_lib_1.NumberHelper.clamp(target, this.areaHeight - this.padding - this.contentSize.y, this.padding);
     }
     jumpToTarget() {
         this.content.y = this.target;
     }
     update(delta) {
-        if (this.content.size.y <= this._scrollHeight) {
+        let contentSize = this.contentSize;
+        if (contentSize.y <= this._scrollHeight) {
             switch (this.smallContentAlign) {
                 case 'start':
                     this.target = this.padding;
                     break;
                 case 'center':
-                    this.target = (this.areaHeight - this.content.size.y) * 0.5;
+                    this.target = (this.areaHeight - contentSize.y) * 0.5;
                     break;
                 case 'end':
-                    this.target = this.areaHeight - this.content.size.y - this.padding;
+                    this.target = this.areaHeight - contentSize.y - this.padding;
                     break;
             }
             if (!this.initialUpdateHappened) {

package/dist/pixi/display-object/container-attributes.d.ts

@@ -27,9 +27,10 @@ export declare enum Cursor {
 export declare abstract class ContainerAttributes extends Attachable {
     protected pixiContainer: PIXI.Container;
     protected constructor();
-    setSize(value: Vector): this;
     get size(): Vector;
     set size(value: Vector);
+    getSize(): Vector;
+    setSize(value: Vector): this;
     /**
      * @param value The position to set
      * @param options.holdFrom An anchor point to hold the position from

package/dist/pixi/display-object/container-attributes.js

@@ -62,16 +62,19 @@ class ContainerAttributes extends game_entities_1.Attachable {
         this._aspectRatio = 1;
         this.pixiContainer = new PIXI.Container();
     }
-    setSize(value) {
-        this.size = value;
-        return this;
-    }
     get size() {
-        return new helpers_lib_1.Vector(this.pixiContainer.width, this.pixiContainer.height);
+        return this.getSize();
     }
     set size(value) {
+        this.setSize(value);
+    }
+    getSize() {
+        return new helpers_lib_1.Vector(this.pixiContainer.width, this.pixiContainer.height);
+    }
+    setSize(value) {
         this.pixiContainer.width = value.x;
         this.pixiContainer.height = value.y;
+        return this;
     }
     /**
      * @param value The position to set

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

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