bard-legends-framework 0.11.0 → 0.12.0

package/dist/physics/module//360/237/223/220services/ray-casting/ray-casting.service.js

@@ -5,9 +5,6 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-var __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -16,11 +13,7 @@ exports.RayCastingService = void 0;
 const p2_1 = __importDefault(require("p2"));
 const game_entities_1 = require("../../../../game-entities");
 const p2js_helper_1 = require("../../../libs/p2js.helper");
-const physics_body_group_service_1 = require("../collision/physics-body-group.service");
 let RayCastingService = class RayCastingService {
-    constructor(physicsBodyGroupService) {
-        this.physicsBodyGroupService = physicsBodyGroupService;
-    }
     castClosest(physicsWorld, line, physicsBodyGroup) {
         let p2RaycastResult = new p2_1.default.RaycastResult();
         let p2Ray = new p2_1.default.Ray({
@@ -30,9 +23,9 @@ let RayCastingService = class RayCastingService {
             collisionGroup: physicsWorld.physicsBodyGroupToP2Group.get(physicsBodyGroup),
             collisionMask: physicsWorld.physicsBodyGroupToP2Mask.get(physicsBodyGroup)
         });
-        physicsWorld['p2World'].raycast(p2RaycastResult, p2Ray);
+        physicsWorld.p2World.raycast(p2RaycastResult, p2Ray);
         if (p2RaycastResult.hasHit()) {
-            let rayCastResult = this.convertP2RaycastResultToRaycastResult(p2RaycastResult, line);
+            let rayCastResult = this._convertP2RaycastResultToRaycastResult(p2RaycastResult, line);
             return rayCastResult;
         }
     }
@@ -47,19 +40,19 @@ let RayCastingService = class RayCastingService {
             callback: callbackResult => {
                 let previousItem = p2BodyToClosestRaycastResult.get(callbackResult.body);
                 if (!p2BodyToClosestRaycastResult.has(callbackResult.body) || callbackResult.fraction < previousItem.fraction) {
-                    p2BodyToClosestRaycastResult.set(callbackResult.body, this.convertP2RaycastResultToRaycastResult(callbackResult, line));
+                    p2BodyToClosestRaycastResult.set(callbackResult.body, this._convertP2RaycastResultToRaycastResult(callbackResult, line));
                 }
                 else if (callbackResult.fraction === previousItem.fraction && previousItem.isExternal()) {
                     // If the raycast starts from inside an object with multiple shapes, there is a chance that first hit is wrongfuly seen as external hit.
                     // Therefore, we need to check if the previous hit was external and if the current hit is internal.
-                    p2BodyToClosestRaycastResult.set(callbackResult.body, this.convertP2RaycastResultToRaycastResult(callbackResult, line));
+                    p2BodyToClosestRaycastResult.set(callbackResult.body, this._convertP2RaycastResultToRaycastResult(callbackResult, line));
                 }
             }
         });
-        physicsWorld['p2World'].raycast(new p2_1.default.RaycastResult(), p2Ray);
+        physicsWorld.p2World.raycast(new p2_1.default.RaycastResult(), p2Ray);
         return Array.from(p2BodyToClosestRaycastResult.values());
     }
-    convertP2RaycastResultToRaycastResult(p2RaycastResult, line) {
+    _convertP2RaycastResultToRaycastResult(p2RaycastResult, line) {
         let fraction = p2RaycastResult.fraction;
         let normal = p2js_helper_1.P2JSHelper.arrayToVector(p2RaycastResult.normal);
         let hitPosition;
@@ -93,7 +86,6 @@ let RayCastingService = class RayCastingService {
 };
 exports.RayCastingService = RayCastingService;
 exports.RayCastingService = RayCastingService = __decorate([
-    (0, game_entities_1.ServiceDecorator)(),
-    __metadata("design:paramtypes", [physics_body_group_service_1.PhysicsBodyGroupService])
+    (0, game_entities_1.ServiceDecorator)()
 ], RayCastingService);
 //# sourceMappingURL=ray-casting.service.js.map

package/dist/physics/module//360/237/223/220services/test-visuals/test-visuals.service.d.ts

@@ -6,17 +6,17 @@ import { PhysicsWorldEntity } from '../../🧊entities/physics-world.entity';
 import { AvailabilityGridService } from '../path-finding/availability-grid.service';
 import { PathFinderService } from '../path-finding/path-finder.service';
 export declare class TestVisualsService {
-    private availabilityGridService;
-    private pathFinderService;
-    constructor(availabilityGridService: AvailabilityGridService, pathFinderService: PathFinderService);
-    printPathfindingTestGrid(physicsWorldId: string, testLayerId: string, target: Vector | string, physicsBodyGroup: PhysicsBodyGroup, area: Rectangle, gridCellSize: number): void;
-    createExplosionDebugVisual(physicsWorld: PhysicsWorldEntity, testLayerId: string, rayCasts: RayCast[], explosionCenter: Vector, radius: number, duration?: number): void;
-    createElipticExplosionDebugVisual(physicsWorld: PhysicsWorldEntity, testLayerId: string, rayCasts: RayCast[], explosionCenter: Vector, rotation: Radian, size: Vector, duration?: number): void;
-    createPhysicsEntityShapeVisual(p2Body: p2.Body, testLayerId: string, options?: {
+    private _availabilityGridService;
+    private _pathFinderService;
+    constructor(_availabilityGridService: AvailabilityGridService, _pathFinderService: PathFinderService);
+    printPathfindingTestGrid(physicsWorldID: number, testLayerID: number, target: Vector | number, physicsBodyGroup: PhysicsBodyGroup, area: Rectangle, gridCellSize: number): void;
+    createExplosionDebugVisual(physicsWorld: PhysicsWorldEntity, testLayerID: number, rayCasts: RayCast[], explosionCenter: Vector, radius: number, duration?: number): void;
+    createElipticExplosionDebugVisual(physicsWorld: PhysicsWorldEntity, testLayerID: number, rayCasts: RayCast[], explosionCenter: Vector, rotation: Radian, size: Vector, duration?: number): void;
+    createPhysicsEntityShapeVisual(p2Body: p2.Body, testLayerID: number, options?: {
         overridePosition?: Vector;
         overrideRotation?: Radian;
         color?: RGBColor;
     }): void;
-    private drawShape;
-    private drawConvexShape;
+    private _drawShape;
+    private _drawConvexShape;
 }

package/dist/physics/module//360/237/223/220services/test-visuals/test-visuals.service.js

@@ -17,20 +17,21 @@ const helpers_lib_1 = require("helpers-lib");
 const p2_1 = __importDefault(require("p2"));
 const game_entities_1 = require("../../../../game-entities");
 const pixi_1 = require("../../../../pixi");
-const utilities_1 = require("../../../../utilities");
+const animations_1 = require("../../../../utilities/animator/animations");
+const animator_1 = require("../../../../utilities/animator/animator/animator");
 const position_to_grid_position_converter_1 = require("../../../../utilities/grid-algorithms/position-to-grid-position-converter");
 const p2js_helper_1 = require("../../../libs/p2js.helper");
 const physics_world_entity_1 = require("../../\uD83E\uDDCAentities/physics-world.entity");
 const availability_grid_service_1 = require("../path-finding/availability-grid.service");
 const path_finder_service_1 = require("../path-finding/path-finder.service");
 let TestVisualsService = class TestVisualsService {
-    constructor(availabilityGridService, pathFinderService) {
-        this.availabilityGridService = availabilityGridService;
-        this.pathFinderService = pathFinderService;
+    constructor(_availabilityGridService, _pathFinderService) {
+        this._availabilityGridService = _availabilityGridService;
+        this._pathFinderService = _pathFinderService;
     }
-    printPathfindingTestGrid(physicsWorldId, testLayerId, target, physicsBodyGroup, area, gridCellSize) {
-        let physicsWorld = physics_world_entity_1.PhysicsWorldEntity.getInstanceByIdOrFail(physicsWorldId);
-        let availabilityGrid = this.availabilityGridService.getAvilabilityGrid(physicsWorld, gridCellSize, physicsBodyGroup);
+    printPathfindingTestGrid(physicsWorldID, testLayerID, target, physicsBodyGroup, area, gridCellSize) {
+        let physicsWorld = physics_world_entity_1.PhysicsWorldEntity.getInstanceByIDOrFail(physicsWorldID);
+        let availabilityGrid = this._availabilityGridService.getAvilabilityGrid(physicsWorld, gridCellSize, physicsBodyGroup);
         availabilityGrid
             .map((value, position) => ({
             position: position_to_grid_position_converter_1.PositionToGridPositionConverter.gridPositionToPosition(position, gridCellSize),
@@ -38,33 +39,33 @@ let TestVisualsService = class TestVisualsService {
         }))
             .forEach(value => {
             if (value.position.isInsideRectangle(area)) {
-                let direction = this.pathFinderService.findPathDirection(physicsWorldId, value.position, target, physicsBodyGroup);
+                let direction = this._pathFinderService.findPathDirection(physicsWorldID, value.position, target, physicsBodyGroup);
                 let sprite;
                 if (direction === undefined) {
                     sprite = pixi_1.Graphics.createRectangleBorders(new helpers_lib_1.Vector(8, 8), 2, helpers_lib_1.ColorHelper.red)
                         .toSprite()
-                        .displayParent(testLayerId)
+                        .displayParent(testLayerID)
                         .setPosition(value.position, { round: false })
-                        .attach(physicsWorldId);
+                        .attach(physicsWorld);
                 }
                 else {
                     sprite = pixi_1.Graphics.createArrow(25, value.availability ? helpers_lib_1.ColorHelper.green : helpers_lib_1.ColorHelper.red)
                         .toSprite()
-                        .displayParent(testLayerId)
+                        .displayParent(testLayerID)
                         .setPosition(value.position, { round: false })
                         .setRotation(direction)
-                        .attach(physicsWorldId);
+                        .attach(physicsWorld);
                 }
-                let animator = new utilities_1.Animator(sprite, 'alpha', { duration: 1000, animation: new utilities_1.AnimationEaseIn() }).attachToRoot();
-                animator.animate({ alpha: 0 }).then(() => {
-                    sprite.destroy();
-                    animator.destroy();
-                });
+                let animator = new animator_1.Animator(sprite, 'alpha', { duration: 1000, animation: animations_1.Animations.easeIn });
+                animator
+                    .animate({ alpha: 0 })
+                    .tap(() => sprite.destroy())
+                    .attach(sprite);
             }
         });
     }
-    createExplosionDebugVisual(physicsWorld, testLayerId, rayCasts, explosionCenter, radius, duration = 300) {
-        let lineContainer = new pixi_1.Container().displayParent(testLayerId).setAlpha(0.5).attach(physicsWorld);
+    createExplosionDebugVisual(physicsWorld, testLayerID, rayCasts, explosionCenter, radius, duration = 300) {
+        let lineContainer = new pixi_1.Container().displayParent(testLayerID).setAlpha(0.5).attach(physicsWorld);
         pixi_1.Graphics.createCircle(radius, helpers_lib_1.ColorHelper.blue)
             .toSprite()
             .displayParent(lineContainer)
@@ -75,14 +76,14 @@ let TestVisualsService = class TestVisualsService {
             let color = ray.hits.length > 0 ? helpers_lib_1.ColorHelper.red : helpers_lib_1.ColorHelper.white;
             pixi_1.Graphics.createVector(explosionCenter, ray.line.to, color).toSprite().displayParent(lineContainer).attach(physicsWorld);
         });
-        let animator = new utilities_1.Animator(lineContainer, 'alpha', { duration, animation: new utilities_1.AnimationEaseIn() }).attachToRoot();
-        animator.animate({ alpha: 0 }).then(() => {
-            lineContainer.destroy();
-            animator.destroy();
-        });
+        let animator = new animator_1.Animator(lineContainer, 'alpha', { duration, animation: animations_1.Animations.easeIn });
+        animator
+            .animate({ alpha: 0 })
+            .tap(() => lineContainer.destroy())
+            .attach(lineContainer);
     }
-    createElipticExplosionDebugVisual(physicsWorld, testLayerId, rayCasts, explosionCenter, rotation, size, duration = 300) {
-        let lineContainer = new pixi_1.Container().displayParent(testLayerId).setAlpha(0.5).attach(physicsWorld);
+    createElipticExplosionDebugVisual(physicsWorld, testLayerID, rayCasts, explosionCenter, rotation, size, duration = 300) {
+        let lineContainer = new pixi_1.Container().displayParent(testLayerID).setAlpha(0.5).attach(physicsWorld);
         pixi_1.Graphics.createElipse(size, helpers_lib_1.ColorHelper.blue)
             .toSprite()
             .displayParent(lineContainer)
@@ -94,33 +95,33 @@ let TestVisualsService = class TestVisualsService {
             let color = ray.hits.length > 0 ? helpers_lib_1.ColorHelper.red : helpers_lib_1.ColorHelper.white;
             pixi_1.Graphics.createVector(ray.line.from, ray.line.to, color).toSprite().displayParent(lineContainer).attach(physicsWorld);
         });
-        let animator = new utilities_1.Animator(lineContainer, 'alpha', { duration, animation: new utilities_1.AnimationEaseIn() }).attachToRoot();
-        animator.animate({ alpha: 0 }).then(() => {
-            lineContainer.destroy();
-            animator.destroy();
-        });
+        let animator = new animator_1.Animator(lineContainer, 'alpha', { duration, animation: animations_1.Animations.easeIn });
+        animator
+            .animate({ alpha: 0 })
+            .tap(() => lineContainer.destroy())
+            .attach(lineContainer);
     }
-    createPhysicsEntityShapeVisual(p2Body, testLayerId, options) {
+    createPhysicsEntityShapeVisual(p2Body, testLayerID, options) {
         let position = options?.overridePosition ?? p2js_helper_1.P2JSHelper.arrayToVector(p2Body.position);
         let rotation = options?.overrideRotation ?? new helpers_lib_1.Radian(p2Body.angle);
         let color = options?.color ?? helpers_lib_1.ColorHelper.blue;
         let container = new pixi_1.Container()
-            .displayParent(testLayerId)
+            .displayParent(testLayerID)
             .setPosition(position, { round: false })
             .setRotation(rotation)
             .setAlpha(0.5)
             .attachToRoot();
         p2Body.shapes.forEach(shape => {
-            let displayObject = this.drawShape(shape, color);
+            let displayObject = this._drawShape(shape, color);
             displayObject.displayParent(container).attachToRoot();
         });
-        let animator = new utilities_1.Animator(container, 'alpha', { duration: 1000, animation: new utilities_1.AnimationEaseIn() }).attachToRoot();
-        animator.animate({ alpha: 0 }).then(() => {
-            container.destroy();
-            animator.destroy();
-        });
+        let animator = new animator_1.Animator(container, 'alpha', { duration: 1000, animation: animations_1.Animations.easeIn });
+        animator
+            .animate({ alpha: 0 })
+            .tap(() => container.destroy())
+            .attach(container);
     }
-    drawShape(shape, color) {
+    _drawShape(shape, color) {
         switch (shape.type) {
             case p2_1.default.Shape.PARTICLE:
                 throw new Error('Not implemented');
@@ -137,12 +138,12 @@ let TestVisualsService = class TestVisualsService {
             case p2_1.default.Shape.HEIGHTFIELD:
                 throw new Error('Not implemented');
             case p2_1.default.Shape.CONVEX:
-                return this.drawConvexShape(shape, color);
+                return this._drawConvexShape(shape, color);
             default:
                 throw new Error('Not implemented');
         }
     }
-    drawConvexShape(shape, color) {
+    _drawConvexShape(shape, color) {
         let polygon = [shape.vertices.map(vertex => ({ x: vertex[0], y: vertex[1] }))];
         return pixi_1.Graphics.createPolygon(polygon, color).toSprite();
     }

package/dist/physics/module//360/237/247/212entities/border.entity.d.ts

@@ -1,5 +1,5 @@
 import { ImmovablePhysicsEntity } from '../../entity-types/immovable-physics-entity';
 import { PhysicsEntityDefinition } from '../../interfaces';
 export declare class BorderEntity extends ImmovablePhysicsEntity {
-    constructor(physicsWorldId: string, physicsEntityDefinition: PhysicsEntityDefinition);
+    constructor(physicsWorldID: number, physicsEntityDefinition: PhysicsEntityDefinition);
 }

package/dist/physics/module//360/237/247/212entities/border.entity.js

@@ -13,13 +13,13 @@ exports.BorderEntity = void 0;
 const game_entities_1 = require("../../../game-entities");
 const immovable_physics_entity_1 = require("../../entity-types/immovable-physics-entity");
 let BorderEntity = class BorderEntity extends immovable_physics_entity_1.ImmovablePhysicsEntity {
-    constructor(physicsWorldId, physicsEntityDefinition) {
-        super(physicsWorldId, physicsEntityDefinition);
+    constructor(physicsWorldID, physicsEntityDefinition) {
+        super(physicsWorldID, physicsEntityDefinition);
     }
 };
 exports.BorderEntity = BorderEntity;
 exports.BorderEntity = BorderEntity = __decorate([
     (0, game_entities_1.EntityDecorator)(),
-    __metadata("design:paramtypes", [String, Object])
+    __metadata("design:paramtypes", [Number, Object])
 ], BorderEntity);
 //# sourceMappingURL=border.entity.js.map

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

@@ -10,16 +10,16 @@ export interface DisplayObjectArrayOptions<T> {
     };
 }
 export declare class DisplayObjectArray<T> extends Container {
-    private createFunction;
-    private displayObjects;
-    private options;
+    private _createFunction;
+    private _displayObjects;
+    private _options;
     /**
-     * @param createFunction function to create the display object
+     * @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>>);
+    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

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

@@ -7,16 +7,16 @@ 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 _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) {
+    constructor(_createFunction, partialOptions) {
         super();
-        this.createFunction = createFunction;
-        this.displayObjects = new Map();
-        this.options = {
+        this._createFunction = _createFunction;
+        this._displayObjects = new Map();
+        this._options = {
             trackBy: (item, index) => index,
             positioning: {
                 direction: 'vertical',
@@ -30,27 +30,27 @@ class DisplayObjectArray extends display_object_1.Container {
      * @param items new items list
      */
     set(items) {
-        let unUsedItems = new Set(this.displayObjects.values());
+        let unUsedItems = new Set(this._displayObjects.values());
         let position = 0;
         items.forEach((item, index) => {
-            let key = this.options.trackBy(item, index);
+            let key = this._options.trackBy(item, index);
             let displayObject;
-            if (this.displayObjects.has(key)) {
-                displayObject = this.displayObjects.get(key);
+            if (this._displayObjects.has(key)) {
+                displayObject = this._displayObjects.get(key);
                 unUsedItems.delete(displayObject);
                 displayObject.update(item);
             }
             else {
-                displayObject = this.createFunction(item).displayParent(this).attach(this);
-                this.displayObjects.set(key, displayObject);
+                displayObject = this._createFunction(item).displayParent(this).attach(this);
+                this._displayObjects.set(key, displayObject);
             }
-            if (this.options.positioning.direction === 'horizontal') {
+            if (this._options.positioning.direction === 'horizontal') {
                 displayObject.x = position;
-                position += displayObject.size.x + this.options.positioning.spacing;
+                position += displayObject.size.x + this._options.positioning.spacing;
             }
             else {
                 displayObject.y = position;
-                position += displayObject.size.y + this.options.positioning.spacing;
+                position += displayObject.size.y + this._options.positioning.spacing;
             }
         });
         unUsedItems.forEach(item => {

package/dist/pixi/components/helpers/smooth-scroller.d.ts

@@ -5,16 +5,16 @@ interface ContainerFrame {
     size: Vector;
 }
 export declare class SmoothScroller {
-    private content;
-    private areaHeight;
-    private padding;
-    private smallContentAlign;
-    private target;
+    private _content;
+    private _areaHeight;
+    private _padding;
+    private _smallContentAlign;
+    private _target;
     private _scrollHeight;
-    private initialUpdateHappened;
+    private _initialUpdateHappened;
     get scrollHeight(): number;
     get contentSize(): Vector;
-    constructor(content: ContainerFrame, areaHeight: number, padding: number, smallContentAlign: 'start' | 'center' | 'end');
+    constructor(_content: ContainerFrame, _areaHeight: number, _padding: number, _smallContentAlign: 'start' | 'center' | 'end');
     onWheel(scrollDelta: number): void;
     scrollToTop(): void;
     scrollToBottom(): void;

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

@@ -9,20 +9,20 @@ class SmoothScroller {
         return this._scrollHeight;
     }
     get contentSize() {
-        return this.content.size.ceil();
-    }
-    constructor(content, areaHeight, padding, smallContentAlign) {
-        this.content = content;
-        this.areaHeight = areaHeight;
-        this.padding = padding;
-        this.smallContentAlign = smallContentAlign;
-        this.initialUpdateHappened = false;
-        this._scrollHeight = areaHeight - padding * 2;
-        this.content.y = padding;
-        this.target = padding;
+        return this._content.size.ceil();
+    }
+    constructor(_content, _areaHeight, _padding, _smallContentAlign) {
+        this._content = _content;
+        this._areaHeight = _areaHeight;
+        this._padding = _padding;
+        this._smallContentAlign = _smallContentAlign;
+        this._initialUpdateHappened = false;
+        this._scrollHeight = _areaHeight - _padding * 2;
+        this._content.y = _padding;
+        this._target = _padding;
     }
     onWheel(scrollDelta) {
-        this.setTarget(this.target - scrollDelta * SCROLL_SPEED);
+        this.setTarget(this._target - scrollDelta * SCROLL_SPEED);
     }
     scrollToTop() {
         this.setTarget(Infinity);
@@ -31,32 +31,32 @@ class SmoothScroller {
         this.setTarget(-Infinity);
     }
     setTarget(target) {
-        this.target = helpers_lib_1.NumberHelper.clamp(target, this.areaHeight - this.padding - this.contentSize.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;
+        this._content.y = this._target;
     }
     update(delta) {
         let contentSize = this.contentSize;
         if (contentSize.y <= this._scrollHeight) {
-            switch (this.smallContentAlign) {
+            switch (this._smallContentAlign) {
                 case 'start':
-                    this.target = this.padding;
+                    this._target = this._padding;
                     break;
                 case 'center':
-                    this.target = (this.areaHeight - contentSize.y) * 0.5;
+                    this._target = (this._areaHeight - contentSize.y) * 0.5;
                     break;
                 case 'end':
-                    this.target = this.areaHeight - contentSize.y - this.padding;
+                    this._target = this._areaHeight - contentSize.y - this._padding;
                     break;
             }
-            if (!this.initialUpdateHappened) {
-                this.content.y = this.target;
+            if (!this._initialUpdateHappened) {
+                this._content.y = this._target;
             }
         }
-        this.initialUpdateHappened = true;
-        let distance = this.target - this.content.y;
-        this.content.y = this.content.y + distance * SCROLL_SPEED_DECAY_RATE * delta;
+        this._initialUpdateHappened = true;
+        let distance = this._target - this._content.y;
+        this._content.y = this._content.y + distance * SCROLL_SPEED_DECAY_RATE * delta;
     }
 }
 exports.SmoothScroller = SmoothScroller;

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

@@ -28,68 +28,68 @@ class Container {
             (0, vitest_1.test)('sample 1 - scroll up', () => {
                 let wheelMove = 100;
                 scroller.onWheel(wheelMove);
-                (0, vitest_1.expect)(scroller['target']).toEqual(-SCROLL_SPEED * wheelMove + padding);
+                (0, vitest_1.expect)(scroller['_target']).toEqual(-SCROLL_SPEED * wheelMove + padding);
             });
             (0, vitest_1.test)('sample 2 - scroll down', () => {
                 let wheelMove = -100;
                 scroller.onWheel(wheelMove);
-                (0, vitest_1.expect)(scroller['target']).toEqual(top);
+                (0, vitest_1.expect)(scroller['_target']).toEqual(top);
             });
             (0, vitest_1.test)('sample 3 - scroll to top', () => {
                 scroller.scrollToTop();
-                (0, vitest_1.expect)(scroller['target']).toEqual(top);
+                (0, vitest_1.expect)(scroller['_target']).toEqual(top);
             });
             (0, vitest_1.test)('sample 4 - scroll to bottom', () => {
                 scroller.scrollToBottom();
-                (0, vitest_1.expect)(scroller['target']).toEqual(bottom);
+                (0, vitest_1.expect)(scroller['_target']).toEqual(bottom);
             });
         });
         (0, vitest_1.describe)('Starting Mid', () => {
             (0, vitest_1.beforeEach)(() => {
                 container.y = mid;
-                scroller['target'] = container.y;
+                scroller['_target'] = container.y;
             });
             (0, vitest_1.test)('sample 1 - scroll up', () => {
                 let wheelMove = 100;
                 scroller.onWheel(wheelMove);
-                (0, vitest_1.expect)(scroller['target']).toEqual(-SCROLL_SPEED * wheelMove + mid);
+                (0, vitest_1.expect)(scroller['_target']).toEqual(-SCROLL_SPEED * wheelMove + mid);
             });
             (0, vitest_1.test)('sample 2 - scroll down', () => {
                 let wheelMove = -100;
                 scroller.onWheel(wheelMove);
-                (0, vitest_1.expect)(scroller['target']).toEqual(-SCROLL_SPEED * wheelMove + mid);
+                (0, vitest_1.expect)(scroller['_target']).toEqual(-SCROLL_SPEED * wheelMove + mid);
             });
             (0, vitest_1.test)('sample 3 - scroll to top', () => {
                 scroller.scrollToTop();
-                (0, vitest_1.expect)(scroller['target']).toEqual(padding);
+                (0, vitest_1.expect)(scroller['_target']).toEqual(padding);
             });
             (0, vitest_1.test)('sample 4 - scroll to bottom', () => {
                 scroller.scrollToBottom();
-                (0, vitest_1.expect)(scroller['target']).toEqual(bottom);
+                (0, vitest_1.expect)(scroller['_target']).toEqual(bottom);
             });
         });
         (0, vitest_1.describe)('Starting Bottom', () => {
             (0, vitest_1.beforeEach)(() => {
                 container.y = bottom;
-                scroller['target'] = container.y;
+                scroller['_target'] = container.y;
             });
             (0, vitest_1.test)('sample 1 - scroll up', () => {
                 let wheelMove = 100;
                 scroller.onWheel(wheelMove);
-                (0, vitest_1.expect)(scroller['target']).toEqual(bottom);
+                (0, vitest_1.expect)(scroller['_target']).toEqual(bottom);
             });
             (0, vitest_1.test)('sample 2 - scroll down', () => {
                 let wheelMove = -100;
                 scroller.onWheel(wheelMove);
-                (0, vitest_1.expect)(scroller['target']).toEqual(-SCROLL_SPEED * wheelMove + bottom);
+                (0, vitest_1.expect)(scroller['_target']).toEqual(-SCROLL_SPEED * wheelMove + bottom);
             });
             (0, vitest_1.test)('sample 3 - scroll to top', () => {
                 scroller.scrollToTop();
-                (0, vitest_1.expect)(scroller['target']).toEqual(padding);
+                (0, vitest_1.expect)(scroller['_target']).toEqual(padding);
             });
             (0, vitest_1.test)('sample 4 - scroll to bottom', () => {
                 scroller.scrollToBottom();
-                (0, vitest_1.expect)(scroller['target']).toEqual(bottom);
+                (0, vitest_1.expect)(scroller['_target']).toEqual(bottom);
             });
         });
         (0, vitest_1.describe)('Smooth Scrolling', () => {

package/dist/pixi/components/menu/menu-entity.d.ts

@@ -0,0 +1,14 @@
+import { SingleEvent } from 'actions-lib';
+import { SingletonEntity } from '../../../game-entities';
+import { Menu, MenuOptions } from './menu.ui';
+export declare class MenuEntity extends SingletonEntity {
+    private _onCreate;
+    readonly onCreate: import("actions-lib").Notifier<Menu>;
+    private _onOpen;
+    readonly onOpen: import("actions-lib").Notifier<void>;
+    private _onClose;
+    readonly onClose: import("actions-lib").Notifier<void>;
+    private _menu;
+    constructor(background: string, partialOptions: Partial<MenuOptions>);
+    close(): SingleEvent;
+}

package/dist/pixi/components/menu/menu-entity.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MenuEntity = void 0;
+const actions_lib_1 = require("actions-lib");
+const game_entities_1 = require("../../../game-entities");
+const game_1 = require("../../game");
+const menu_ui_1 = require("./menu.ui");
+class MenuEntity extends game_entities_1.SingletonEntity {
+    constructor(background, partialOptions) {
+        super();
+        this._onCreate = new actions_lib_1.SingleAction();
+        this.onCreate = this._onCreate.notifier;
+        this._onOpen = new actions_lib_1.SingleAction();
+        this.onOpen = this._onOpen.notifier;
+        this._onClose = new actions_lib_1.SingleAction();
+        this.onClose = this._onClose.notifier;
+        menu_ui_1.Menu.closeAll()
+            .tap(() => {
+            let activeScene = game_entities_1.Scene.getActiveScene();
+            if (!activeScene) {
+                throw new Error('WindowEntity: constructor is called when there is no active scene!');
+            }
+            game_1.Game.pause.effect(true).attach(this);
+            this._menu = new menu_ui_1.Menu(background, partialOptions).displayParent(game_1.Game.camera.layers.foregroundScreen).attach(this);
+            this._onCreate.resolve(this._menu);
+            this._menu.onOpen.subscribe(() => this._onOpen.resolve()).attach(this);
+            this._menu.onClose
+                .subscribe(() => {
+                this._onClose.resolve();
+                this.destroy();
+            })
+                .attach(this);
+        })
+            .attach(this);
+    }
+    close() {
+        if (this._menu) {
+            let onClose = this.onClose.toSingleEvent().destroyIfNotAttached();
+            this._menu.close();
+            return onClose;
+        }
+        else {
+            return this.onCreate.asyncMapQueue(() => this.close()).singleChain(this);
+        }
+    }
+}
+exports.MenuEntity = MenuEntity;
+//# sourceMappingURL=menu-entity.js.map

package/dist/pixi/components/menu/menu.ui.d.ts

@@ -0,0 +1,23 @@
+import { SingleEvent } from 'actions-lib';
+import { Container, Sprite } from '../../display-object';
+export interface MenuOptions {
+    readonly closeOnBackgroundClick: boolean;
+    readonly appearAnimationDuration: number;
+    readonly darkeningAlpha: number;
+}
+export declare class Menu extends Container {
+    private static _openWindow;
+    private static _transitioning;
+    static closeAll(): SingleEvent;
+    private _background;
+    private _menu;
+    private _animator;
+    private _onOpen;
+    readonly onOpen: import("actions-lib").Notifier<void>;
+    private _onClose;
+    readonly onClose: import("actions-lib").Notifier<void>;
+    constructor(background: string, partialOptions: Partial<MenuOptions>);
+    getBoundingMask(): Sprite;
+    close(): SingleEvent;
+    private _appear;
+}