bard-legends-framework 0.10.9 → 0.11.0

package/dist/physics/module//342/232/234/357/270/217gateways/physics.gateway.d.ts

@@ -1,6 +1,6 @@
 import { GridNeighborType, Radian, Rectangle, Vector } from 'helpers-lib';
 import { ControllerLink } from '../../../game-entities';
-import { PathFinderResult } from '../../../utilities/libraries/grid-algorithms/path-finder/path-finder';
+import { PathFinderResult } from '../../../utilities/grid-algorithms/path-finder/path-finder';
 import { PhysicsBodyGroup } from '../../libs/physics-body-groups';
 import { CreatePhysicsWorldRequestDTO, HitTestOptions, PhysicsExplosionOptions } from './dtos/requests.dto';
 import { ExplosionHit, MapSizeDTO } from './dtos/responses.dto';

package/dist/physics/module//360/237/223/220services/creation/physics-world.service.js

@@ -34,8 +34,8 @@ let PhysicsWorldService = class PhysicsWorldService {
         let { materials, materialDefinitions } = this.materialsService.createMaterials(p2World, request.borderProperties, request.materialDefinitions, request.materialContactDefinitions);
         let { physicsBodyGroupToP2Group, physicsBodyGroupToP2Mask } = this.physicsBodyGroupService.createBodyGroupsAndMasks(request.physicsBodyGroups, request.interactingBodyGroups);
         let physicsWorld = new physics_world_entity_1.PhysicsWorldEntity(request.mapSize, request.modifyUpdateCycle, p2World, materials, materialDefinitions, physicsBodyGroupToP2Group, physicsBodyGroupToP2Mask).attach(request.attachTo);
-        physicsWorld.onDestroy
-            .subscribe(() => {
+        physicsWorld
+            .onDestroy(() => {
             p2World.clear();
             if (request.modifyUpdateCycle) {
                 game_entities_1.UpdateCycle.cleanUpdateModifier();

package/dist/physics/module//360/237/223/220services/path-finding/availability-grid.service.js

@@ -13,7 +13,7 @@ exports.AvailabilityGridService = void 0;
 const helpers_lib_1 = require("helpers-lib");
 const game_entities_1 = require("../../../../game-entities");
 const utilities_1 = require("../../../../utilities");
-const position_to_grid_position_converter_1 = require("../../../../utilities/libraries/grid-algorithms/position-to-grid-position-converter");
+const position_to_grid_position_converter_1 = require("../../../../utilities/grid-algorithms/position-to-grid-position-converter");
 const physics_entity_1 = require("../../../entity-types/physics-entity");
 const p2js_helper_1 = require("../../../libs/p2js.helper");
 const physics_body_group_service_1 = require("../collision/physics-body-group.service");

package/dist/physics/module//360/237/223/220services/path-finding/path-finder.service.js

@@ -13,7 +13,7 @@ exports.PathFinderService = exports.DEFAULT_GRID_CELL_SIZE = void 0;
 const helpers_lib_1 = require("helpers-lib");
 const game_entities_1 = require("../../../../game-entities");
 const utilities_1 = require("../../../../utilities");
-const position_to_grid_position_converter_1 = require("../../../../utilities/libraries/grid-algorithms/position-to-grid-position-converter");
+const position_to_grid_position_converter_1 = require("../../../../utilities/grid-algorithms/position-to-grid-position-converter");
 const physics_entity_1 = require("../../../entity-types/physics-entity");
 const p2js_helper_1 = require("../../../libs/p2js.helper");
 const physics_world_entity_1 = require("../../\uD83E\uDDCAentities/physics-world.entity");

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

@@ -1,9 +1,9 @@
-import { ActionListenerCallbackFunction, ActionSubscription } from 'actions-lib';
+import { IAttachable, NotifierCallbackFunction } from 'actions-lib';
 import { MapSizeDTO } from '../../⚜️gateways';
 export declare class PhysicsQueryService {
     getMapSize(physicsWorldId: string): MapSizeDTO;
-    subscribeToPhysicsStep(physicsWorldId: string, callback: ActionListenerCallbackFunction<{
+    subscribeToPhysicsStep(physicsWorldId: string, callback: NotifierCallbackFunction<{
         time: number;
         delta: number;
-    }>): ActionSubscription;
+    }>): IAttachable;
 }

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

@@ -8,13 +8,17 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 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 };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TestVisualsService = void 0;
 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 position_to_grid_position_converter_1 = require("../../../../utilities/libraries/grid-algorithms/position-to-grid-position-converter");
+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");
@@ -117,16 +121,22 @@ let TestVisualsService = class TestVisualsService {
         });
     }
     drawShape(shape, color) {
-        switch (shape.constructor.name) {
-            case 'Circle':
+        switch (shape.type) {
+            case p2_1.default.Shape.PARTICLE:
+                throw new Error('Not implemented');
+            case p2_1.default.Shape.LINE:
+                throw new Error('Not implemented');
+            case p2_1.default.Shape.PLANE:
+                throw new Error('Not implemented');
+            case p2_1.default.Shape.CIRCLE:
                 throw new Error('Not implemented');
-            case 'Plane':
+            case p2_1.default.Shape.CAPSULE:
                 throw new Error('Not implemented');
-            case 'Capsule':
+            case p2_1.default.Shape.BOX:
                 throw new Error('Not implemented');
-            case 'Rectangle':
+            case p2_1.default.Shape.HEIGHTFIELD:
                 throw new Error('Not implemented');
-            case 'Convex':
+            case p2_1.default.Shape.CONVEX:
                 return this.drawConvexShape(shape, color);
             default:
                 throw new Error('Not implemented');

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

@@ -27,8 +27,8 @@ let PhysicsWorldEntity = class PhysicsWorldEntity extends game_entities_1.Entity
         this.vectorFieldCache = new Map();
         this.bodiesInContactWith = new Map();
         this.collisionReports = new Map();
-        this.paused = new actions_lib_1.Variable().set(false);
-        this.lastP2Time = new actions_lib_1.Variable().set(0);
+        this.paused = new actions_lib_1.Variable(false);
+        this.lastP2Time = new actions_lib_1.Variable(0);
         this.onPhysicsStep = new actions_lib_1.Action();
         this.mapSize = mapSize;
         this.mapSizeCenter = this.mapSize.multiplyNumber(0.5);

package/dist/pixi/components/mouse-wheel-listener.ui.d.ts

@@ -2,7 +2,8 @@ import { Action } from 'actions-lib';
 import { Vector } from 'helpers-lib';
 import { Container } from '../display-object/container';
 export declare class MouseWheelListenerUI extends Container {
-    readonly onWheel: Action<number>;
+    readonly _onWheel: Action<number>;
+    readonly onWheel: import("actions-lib").Notifier<number>;
     private wheelListener;
     private handler;
     constructor(size: Vector);

package/dist/pixi/components/mouse-wheel-listener.ui.js

@@ -32,15 +32,16 @@ const mouse_service_1 = require("../services/mouse/mouse.service");
 class MouseWheelListenerUI extends container_1.Container {
     constructor(size) {
         super();
-        this.onWheel = new actions_lib_1.Action();
+        this._onWheel = new actions_lib_1.Action();
+        this.onWheel = this._onWheel.notifier;
         this.handler = ((event) => {
-            let mouseScreenPosition = game_entities_1.Service.get(mouse_service_1.MouseService).screenPosition.value;
+            let mouseScreenPosition = game_entities_1.Service.get(mouse_service_1.MouseService).getScreenPosition();
             let bounds = this.wheelListener.getBounds();
             if (mouseScreenPosition.x >= bounds.x &&
                 mouseScreenPosition.x <= bounds.x + bounds.width &&
                 mouseScreenPosition.y >= bounds.y &&
                 mouseScreenPosition.y <= bounds.y + bounds.height) {
-                this.onWheel.trigger(event.deltaY);
+                this._onWheel.trigger(event.deltaY);
             }
         }).bind(this);
         this.wheelListener = new PIXI.Graphics();

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

@@ -1,7 +1,6 @@
-import { ActionSubscription } from 'actions-lib';
+import { Attachable, IAttachable } from 'actions-lib';
 import { Radian, Vector } from 'helpers-lib';
 import * as PIXI from 'pixi.js';
-import { Attachable } from '../../game-entities';
 export declare enum ContainerEventType {
     click = "click",
     mouseover = "mouseover",
@@ -47,7 +46,7 @@ export declare abstract class ContainerAttributes extends Attachable {
     set x(value: number);
     get y(): number;
     set y(value: number);
-    on(eventType: ContainerEventType, callback: () => void): ActionSubscription;
+    on(eventType: ContainerEventType, callback: () => void): IAttachable;
     setRotation(value: Radian): this;
     get rotation(): Radian;
     set rotation(value: Radian);

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

@@ -27,7 +27,6 @@ exports.ContainerAttributes = exports.Cursor = exports.ContainerEventType = void
 const actions_lib_1 = require("actions-lib");
 const helpers_lib_1 = require("helpers-lib");
 const PIXI = __importStar(require("pixi.js"));
-const game_entities_1 = require("../../game-entities");
 var ContainerEventType;
 (function (ContainerEventType) {
     ContainerEventType["click"] = "click";
@@ -52,7 +51,7 @@ var Cursor;
     Cursor["default"] = "default";
     Cursor["pointer"] = "pointer";
 })(Cursor || (exports.Cursor = Cursor = {}));
-class ContainerAttributes extends game_entities_1.Attachable {
+class ContainerAttributes extends actions_lib_1.Attachable {
     constructor() {
         super();
         // --------------------- Scale ---------------------
@@ -121,7 +120,7 @@ class ContainerAttributes extends game_entities_1.Attachable {
         this.pixiContainer.on(eventType, handle);
         return new actions_lib_1.ActionSubscription(() => {
             this.pixiContainer.off(eventType, handle);
-        }).decorateActionSubscription();
+        });
     }
     setRotation(value) {
         this.rotation = value;

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

@@ -1,5 +1,4 @@
 import { Rectangle } from 'helpers-lib';
-import { Attachable } from '../../game-entities';
 import { ContainerAttributes } from './container-attributes';
 import { Filters } from './filters';
 import { Sprite } from './objects/sprite/sprite';
@@ -16,8 +15,6 @@ export declare class Container extends ContainerAttributes {
         cropOverflowingParts: boolean;
     };
     constructor();
-    attach(parent: Attachable | string): this;
-    attachToRoot(): this;
     destroy(): void;
     getBoundingMask(): Sprite;
     displayParent(parent: Container | string, partialOptions?: Partial<SetParentOptions>): this;

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

@@ -16,16 +16,6 @@ class Container extends container_attributes_1.ContainerAttributes {
         Container.allContainers.set(this.id, this);
         this.filters = new filters_1.Filters(this.pixiContainer);
     }
-    // make the attach function non-internal
-    attach(parent) {
-        super.attach(parent);
-        return this;
-    }
-    // make the attachToRoot function non-internal
-    attachToRoot() {
-        super.attachToRoot();
-        return this;
-    }
     destroy() {
         if (!this.destroyed) {
             Container.allContainers.delete(this.id);

package/dist/pixi/display-object/objects/sprite/glow-sprite-generator.js

@@ -26,7 +26,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.GlowSpriteGenerator = void 0;
 const helpers_lib_1 = require("helpers-lib");
 const PIXI = __importStar(require("pixi.js"));
-const update_cycle_1 = require("../../../../game-entities/update-cycle");
+const unit_test_helper_1 = require("../../../../game-entities/unit-test.helper");
 const __1 = require("../../..");
 const game_assets_1 = require("../../../helpers/game-assets");
 const glow_filter_1 = require("../../filters/composite-filters/glow-filter");
@@ -104,7 +104,9 @@ class GlowSpriteGenerator {
     }
 }
 exports.GlowSpriteGenerator = GlowSpriteGenerator;
-update_cycle_1.UpdateCycle.hardResetAction.subscribe(() => {
+unit_test_helper_1.UnitTestHelper.onHardReset
+    .subscribe(() => {
     GlowSpriteGenerator['glowTextureCache'].clear();
-});
+})
+    .attachToRoot();
 //# sourceMappingURL=glow-sprite-generator.js.map

package/dist/pixi/game.d.ts

@@ -21,8 +21,12 @@ export declare class Game {
     static get time(): number;
     readonly stage: Container;
     readonly renderer: PIXI.Renderer;
-    readonly screenSize: Variable<Vector>;
-    readonly screenSizeCenter: Variable<Vector>;
+    readonly _screenSize: Variable<Vector>;
+    readonly screenSize: import("actions-lib").Notifier<Vector>;
+    getScreenSize(): Vector;
+    readonly _screenSizeCenter: Variable<Vector>;
+    readonly screenSizeCenter: import("actions-lib").Notifier<Vector>;
+    getScreenSizeCenter(): Vector;
     readonly devMode: boolean;
     private readonly pixiApp;
     private readonly configuration;

package/dist/pixi/game.js

@@ -44,9 +44,17 @@ class Game {
     static get time() {
         return update_cycle_1.UpdateCycle['time'];
     }
+    getScreenSize() {
+        return this._screenSize.value;
+    }
+    getScreenSizeCenter() {
+        return this._screenSizeCenter.value;
+    }
     constructor(partialConfiguration) {
-        this.screenSize = new actions_lib_1.Variable();
-        this.screenSizeCenter = new actions_lib_1.Variable();
+        this._screenSize = new actions_lib_1.Variable(helpers_lib_1.Vector.zero);
+        this.screenSize = this._screenSize.notifier;
+        this._screenSizeCenter = new actions_lib_1.Variable(helpers_lib_1.Vector.zero);
+        this.screenSizeCenter = this._screenSizeCenter.notifier;
         this.devMode = false;
         this.resetScreenPositionToStagePositionFunction();
         if (Game._instance) {
@@ -102,7 +110,7 @@ class Game {
         this.pixiApp.renderer.resize(this.pixiApp.screen.width, this.pixiApp.screen.height);
     }
     screenPositonToStagePosition(screenPosition) {
-        let adjustedScreenPositionWithScale = position_conversion_helper_1.PositionConversionHelper.includeScaleInScreenPosition(screenPosition, Game.instance.stage.scale, Game.instance.screenSizeCenter.value);
+        let adjustedScreenPositionWithScale = position_conversion_helper_1.PositionConversionHelper.includeScaleInScreenPosition(screenPosition, Game.instance.stage.scale, Game.instance.getScreenSizeCenter());
         return this.screenPositionToStagePositionConverter(adjustedScreenPositionWithScale);
     }
     setScreenPositionToStagePositionFunction(converterFunction) {
@@ -115,8 +123,9 @@ class Game {
         game_assets_1.GameAssets.destroyAsset(assetId);
     }
     setScreenSize() {
-        this.screenSize.value = new helpers_lib_1.Vector(this.pixiApp.screen.width, this.pixiApp.screen.height);
-        this.screenSizeCenter.value = this.screenSize.value.multiplyNumber(0.5).round();
+        let screenSize = new helpers_lib_1.Vector(this.pixiApp.screen.width, this.pixiApp.screen.height);
+        this._screenSize.value = screenSize;
+        this._screenSizeCenter.value = screenSize.multiplyNumber(0.5).round();
     }
 }
 exports.Game = Game;

package/dist/pixi/modules/CAMERA//360/237/247/212entities/camera.entity.js

@@ -13,10 +13,10 @@ const game_entities_1 = require("../../../../game-entities");
 let CameraEntity = class CameraEntity extends game_entities_1.SingletonEntity {
     constructor() {
         super(...arguments);
-        this.position = new actions_lib_1.Variable().set(helpers_lib_1.Vector.zero);
-        this.offset = new actions_lib_1.Variable().set(helpers_lib_1.Vector.zero);
-        this.targetPosition = new actions_lib_1.Variable();
-        this.focusingNewTargetInfo = new actions_lib_1.Variable().set(undefined);
+        this.position = new actions_lib_1.Variable(helpers_lib_1.Vector.zero);
+        this.offset = new actions_lib_1.Variable(helpers_lib_1.Vector.zero);
+        this.targetPosition = new actions_lib_1.Variable(undefined);
+        this.focusingNewTargetInfo = new actions_lib_1.Variable(undefined);
     }
 };
 exports.CameraEntity = CameraEntity;

package/dist/pixi/modules/CAMERA//360/237/247/251views/camera.view.js

@@ -103,7 +103,7 @@ let CameraView = class CameraView extends game_entities_1.View {
         }
     }
     convertToCameraPosition(positionInWorld) {
-        return helpers_lib_1.Vector.fromTo(positionInWorld, game_1.Game.instance.screenSizeCenter.value);
+        return helpers_lib_1.Vector.fromTo(positionInWorld, game_1.Game.instance.getScreenSizeCenter());
     }
 };
 exports.CameraView = CameraView;

package/dist/pixi/services/keyboard/keyboard.d.ts

@@ -1,7 +1,9 @@
 import { Action } from 'actions-lib';
 export declare class KeyboardService {
-    readonly keyPressed: Action<string>;
-    readonly keyReleased: Action<string>;
+    readonly _keyPressed: Action<string>;
+    readonly keyPressed: import("actions-lib").Notifier<string>;
+    readonly _keyReleased: Action<string>;
+    readonly keyReleased: import("actions-lib").Notifier<string>;
     private listOfPressedKeys;
     private listOfJustPressedKeys;
     constructor();

package/dist/pixi/services/keyboard/keyboard.js

@@ -15,18 +15,20 @@ const game_entities_1 = require("../../../game-entities");
 const service_1 = require("../../../game-entities/service/service");
 let KeyboardService = class KeyboardService {
     constructor() {
-        this.keyPressed = new actions_lib_1.Action();
-        this.keyReleased = new actions_lib_1.Action();
+        this._keyPressed = new actions_lib_1.Action();
+        this.keyPressed = this._keyPressed.notifier;
+        this._keyReleased = new actions_lib_1.Action();
+        this.keyReleased = this._keyReleased.notifier;
         this.listOfPressedKeys = new Set();
         this.listOfJustPressedKeys = new Set();
         window.addEventListener('keydown', event => {
             this.listOfPressedKeys.add(event.key);
             this.listOfJustPressedKeys.add(event.key);
-            !event.repeat && this.keyPressed.trigger(event.key);
+            !event.repeat && this._keyPressed.trigger(event.key);
         });
         window.addEventListener('keyup', event => {
             this.listOfPressedKeys.delete(event.key);
-            this.keyReleased.trigger(event.key);
+            this._keyReleased.trigger(event.key);
         });
         window.addEventListener('blur', () => {
             this.listOfPressedKeys.clear();

package/dist/pixi/services/mouse/mouse-target-focus.service.d.ts

@@ -3,7 +3,8 @@ import { Vector } from 'helpers-lib';
 import { MouseService } from './mouse.service';
 export declare class MouseTargetFocusService {
     private mouseService;
-    onTargetFocus: Action<Vector>;
+    readonly _onTargetFocus: Action<Vector>;
+    readonly onTargetFocus: import("actions-lib").Notifier<Vector>;
     get focusedInLastFrame(): boolean;
     get lastFocusedPosition(): Vector | undefined;
     private mouseStagePositionPrevious;

package/dist/pixi/services/mouse/mouse-target-focus.service.js

@@ -24,7 +24,8 @@ let MouseTargetFocusService = class MouseTargetFocusService {
     }
     constructor(mouseService) {
         this.mouseService = mouseService;
-        this.onTargetFocus = new actions_lib_1.Action();
+        this._onTargetFocus = new actions_lib_1.Action();
+        this.onTargetFocus = this._onTargetFocus.notifier;
         this.timePassFromLastTrigger = 0;
         this.triggerAfterCooldown = false;
         this._focusedInLastFrame = false;
@@ -35,7 +36,7 @@ let MouseTargetFocusService = class MouseTargetFocusService {
     }
     update(delta) {
         if (this.mouseStagePositionPrevious) {
-            let mousePositionChange = this.getPositionChange(this.mouseService.stagePosition.value, this.mouseStagePositionPrevious);
+            let mousePositionChange = this.getPositionChange(this.mouseService.getStagePosition(), this.mouseStagePositionPrevious);
             if (this.peakValueChange === undefined) {
                 this.peakValueChange = mousePositionChange;
             }
@@ -43,7 +44,7 @@ let MouseTargetFocusService = class MouseTargetFocusService {
                 this.check(mousePositionChange, delta);
             }
         }
-        this.mouseStagePositionPrevious = this.mouseService.stagePosition.value;
+        this.mouseStagePositionPrevious = this.mouseService.getStagePosition();
     }
     check(mousePositionChange, delta) {
         if (this.peakValueChange - mousePositionChange > 10) {
@@ -64,8 +65,8 @@ let MouseTargetFocusService = class MouseTargetFocusService {
             this.triggerAfterCooldown = false;
             this.timePassFromLastTrigger = 0;
             this._focusedInLastFrame = true;
-            this._lastFocusedPosition = this.mouseService.stagePosition.value;
-            this.onTargetFocus.trigger(this._lastFocusedPosition);
+            this._lastFocusedPosition = this.mouseService.getStagePosition();
+            this._onTargetFocus.trigger(this._lastFocusedPosition);
         }
         else {
             this.timePassFromLastTrigger += delta;

package/dist/pixi/services/mouse/mouse.service.d.ts

@@ -1,11 +1,21 @@
 import { Variable } from 'actions-lib';
 import { Vector } from 'helpers-lib';
 export declare class MouseService {
-    readonly mouseMoved: Variable<boolean>;
-    readonly stagePosition: Variable<Vector>;
-    readonly screenPosition: Variable<Vector>;
-    readonly mainButtonState: Variable<boolean>;
-    readonly secondaryButtonState: Variable<boolean>;
+    readonly _initialMouseMovementHappened: Variable<boolean>;
+    readonly onInitialMouseMove: import("actions-lib").Notifier<boolean>;
+    get initialMouseMoveHappened(): boolean;
+    readonly _stagePosition: Variable<Vector>;
+    readonly stagePosition: import("actions-lib").Notifier<Vector>;
+    getStagePosition(): Vector;
+    readonly _screenPosition: Variable<Vector>;
+    readonly screenPosition: import("actions-lib").Notifier<Vector>;
+    getScreenPosition(): Vector;
+    readonly _mainButtonState: Variable<boolean>;
+    readonly mainButtonState: import("actions-lib").Notifier<boolean>;
+    getMainButtonState(): boolean;
+    readonly _secondaryButtonState: Variable<boolean>;
+    readonly secondaryButtonState: import("actions-lib").Notifier<boolean>;
+    getSecondaryButtonState(): boolean;
     constructor();
     private startListeningMouseMove;
 }

package/dist/pixi/services/mouse/mouse.service.js

@@ -16,58 +16,78 @@ const service_1 = require("../../../game-entities/service/service");
 const update_cycle_1 = require("../../../game-entities/update-cycle");
 const __1 = require("../..");
 let MouseService = class MouseService {
+    get initialMouseMoveHappened() {
+        return this._initialMouseMovementHappened.value;
+    }
+    getStagePosition() {
+        return this._stagePosition.value;
+    }
+    getScreenPosition() {
+        return this._screenPosition.value;
+    }
+    getMainButtonState() {
+        return this._mainButtonState.value;
+    }
+    getSecondaryButtonState() {
+        return this._secondaryButtonState.value;
+    }
     constructor() {
-        this.mouseMoved = new actions_lib_1.Variable().set(false);
-        this.stagePosition = new actions_lib_1.Variable({ notifyOnChange: true }).set(helpers_lib_1.Vector.zero);
-        this.screenPosition = new actions_lib_1.Variable({ notifyOnChange: true }).set(helpers_lib_1.Vector.zero);
-        this.mainButtonState = new actions_lib_1.Variable().set(false);
-        this.secondaryButtonState = new actions_lib_1.Variable().set(false);
+        this._initialMouseMovementHappened = new actions_lib_1.Variable(false);
+        this.onInitialMouseMove = this._initialMouseMovementHappened.notifier;
+        this._stagePosition = new actions_lib_1.Variable(helpers_lib_1.Vector.zero, { notifyOnChange: true });
+        this.stagePosition = this._stagePosition.notifier;
+        this._screenPosition = new actions_lib_1.Variable(helpers_lib_1.Vector.zero, { notifyOnChange: true });
+        this.screenPosition = this._screenPosition.notifier;
+        this._mainButtonState = new actions_lib_1.Variable(false);
+        this.mainButtonState = this._mainButtonState.notifier;
+        this._secondaryButtonState = new actions_lib_1.Variable(false);
+        this.secondaryButtonState = this._secondaryButtonState.notifier;
         this.startListeningMouseMove();
         window.addEventListener('mousedown', event => {
             if (event.button === 0) {
-                this.mainButtonState.value = true;
+                this._mainButtonState.value = true;
             }
             else if (event.button === 2) {
-                this.secondaryButtonState.value = true;
+                this._secondaryButtonState.value = true;
             }
         });
         window.addEventListener('mouseup', event => {
             if (event.button === 0) {
-                this.mainButtonState.value = false;
+                this._mainButtonState.value = false;
             }
             else if (event.button === 2) {
-                this.secondaryButtonState.value = false;
+                this._secondaryButtonState.value = false;
             }
         });
         window.addEventListener('blur', () => {
-            this.mainButtonState.value = false;
-            this.secondaryButtonState.value = false;
+            this._mainButtonState.value = false;
+            this._secondaryButtonState.value = false;
         });
     }
     startListeningMouseMove() {
         let mouseScreenPosition = helpers_lib_1.Vector.zero;
         window.addEventListener('mousemove', event => {
             mouseScreenPosition = new helpers_lib_1.Vector(event.clientX, event.clientY);
-            this.mouseMoved.value = true;
+            this._initialMouseMovementHappened.value = true;
         });
         update_cycle_1.UpdateCycle.beforeSceneUpdateAction
             .subscribe(() => {
-            this.screenPosition.value = mouseScreenPosition;
+            this._screenPosition.value = mouseScreenPosition;
         })
             .attachToRoot();
         update_cycle_1.UpdateCycle.afterSceneUpdateAction
             .subscribe(() => {
-            let newStagePosition = __1.Game.instance.screenPositonToStagePosition(this.screenPosition.value);
-            if (newStagePosition.isEqual(this.stagePosition.value)) {
+            let newStagePosition = __1.Game.instance.screenPositonToStagePosition(this._screenPosition.value);
+            if (newStagePosition.isEqual(this._stagePosition.value)) {
                 // Trigger pointer move event, because content might slide under the mouse cursor
                 __1.Game.instance.renderer.events['onPointerMove'](new PointerEvent('pointermove', {
-                    clientX: this.screenPosition.value.x,
-                    clientY: this.screenPosition.value.y,
+                    clientX: this._screenPosition.value.x,
+                    clientY: this._screenPosition.value.y,
                     pointerType: 'mouse'
                 }));
             }
             else {
-                this.stagePosition.value = newStagePosition;
+                this._stagePosition.value = newStagePosition;
             }
         })
             .attachToRoot();

package/dist/utilities/animator/animating-content/fade-in-content.d.ts

@@ -0,0 +1,18 @@
+import { Container } from '../../../pixi';
+import { AnimatorAnimation } from '../animations';
+export interface FadeInContentOptions {
+    duration: number;
+    animation: AnimatorAnimation;
+}
+export declare class FadeInContent<T> extends Container {
+    private createFunction;
+    private stateAnimation;
+    private content;
+    constructor(createFunction: (value: {
+        state: T;
+        container: Container;
+    }) => void, partialOptions?: Partial<FadeInContentOptions>);
+    setState(state: T | undefined, options?: {
+        instant?: boolean;
+    }): this;
+}

package/dist/utilities/animator/animating-content/fade-in-content.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FadeInContent = void 0;
+const pixi_1 = require("../../../pixi");
+const animations_1 = require("../animations");
+const visit_disappear_state_animation_1 = require("../state-animation/visit-disappear-state-animation");
+class FadeInContent extends pixi_1.Container {
+    constructor(createFunction, partialOptions) {
+        super();
+        this.createFunction = createFunction;
+        let options = {
+            duration: 200,
+            animation: new animations_1.AnimationEaseInOut(),
+            ...partialOptions
+        };
+        this.alpha = 0;
+        this.stateAnimation = new visit_disappear_state_animation_1.VisitDisappearStateAnimation(options)
+            .onStateChange(state => {
+            this.content?.destroy();
+            this.content = undefined;
+            if (state !== undefined) {
+                this.content = new pixi_1.Container().displayParent(this).attach(this);
+                this.createFunction({ state, container: this.content });
+            }
+        })
+            .onValueChange(value => {
+            this.alpha = value;
+        })
+            .attach(this);
+    }
+    setState(state, options) {
+        this.stateAnimation.setState(state, options);
+        return this;
+    }
+}
+exports.FadeInContent = FadeInContent;
+//# sourceMappingURL=fade-in-content.js.map