bard-legends-framework 0.10.9 → 0.12.0

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

@@ -10,100 +10,101 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CameraView = void 0;
+const actions_lib_1 = require("actions-lib");
 const helpers_lib_1 = require("helpers-lib");
 const game_entities_1 = require("../../../../game-entities");
 const utilities_1 = require("../../../../utilities");
+const animator_1 = require("../../../../utilities/animator/animator/animator");
 const display_object_1 = require("../../../display-object");
 const container_1 = require("../../../display-object/container");
 const game_1 = require("../../../game");
 const camera_entity_1 = require("../\uD83E\uDDCAentities/camera.entity");
 let CameraView = class CameraView extends game_entities_1.View {
-    constructor(entity) {
+    constructor(_entity) {
         super();
-        this.entity = entity;
-        this.sceneContainer = new container_1.Container().setAlpha(0).displayParent(game_1.Game.instance.stage).attach(this);
-        this.blackScreen = display_object_1.Graphics.createRectangle(new helpers_lib_1.Vector(1, 1), helpers_lib_1.ColorHelper.black)
+        this._entity = _entity;
+        this._sceneContainer = new container_1.Container().setAlpha(0).displayParent(game_1.Game.instance.stage).attach(this);
+        this._blackScreen = display_object_1.Graphics.createRectangle(new helpers_lib_1.Vector(1, 1), helpers_lib_1.ColorHelper.black)
             .toSprite({ cache: true })
             .setAlpha(0)
             .displayParent(game_1.Game.instance.stage)
             .attach(this);
-        this.backgroundScreen = new container_1.Container().displayParent(this.sceneContainer).attach(this);
-        this.cameraOffsetLayer = new container_1.Container().displayParent(this.sceneContainer).attach(this);
-        this.foregroundScreenLayer = new container_1.Container().setSortableChildren(true).displayParent(this.sceneContainer).attach(this);
-        this.cameraLayer = new container_1.Container().setSortableChildren(true).displayParent(this.cameraOffsetLayer).attach(this);
-        this.foreground = new container_1.Container().setSortableChildren(true).setZIndex(20).displayParent(this.cameraLayer).attach(this);
-        this.mainLayer = new container_1.Container().setSortableChildren(true).setZIndex(10).displayParent(this.cameraLayer).attach(this);
-        this.backgroundLayer = new container_1.Container().setZIndex(0).displayParent(this.cameraLayer).attach(this);
-        this.alphaAnimator = new utilities_1.Animator(this.sceneContainer, 'alpha', {
+        this._backgroundScreen = new container_1.Container().displayParent(this._sceneContainer).attach(this);
+        this._cameraOffsetLayer = new container_1.Container().displayParent(this._sceneContainer).attach(this);
+        this._foregroundScreenLayer = new container_1.Container().setSortableChildren(true).displayParent(this._sceneContainer).attach(this);
+        this._cameraLayer = new container_1.Container().setSortableChildren(true).displayParent(this._cameraOffsetLayer).attach(this);
+        this._foreground = new container_1.Container().setSortableChildren(true).setZIndex(20).displayParent(this._cameraLayer).attach(this);
+        this._mainLayer = new container_1.Container().setSortableChildren(true).setZIndex(10).displayParent(this._cameraLayer).attach(this);
+        this._backgroundLayer = new container_1.Container().setZIndex(0).displayParent(this._cameraLayer).attach(this);
+        this._alphaAnimator = new animator_1.Animator(this._sceneContainer, 'alpha', {
             duration: 500,
-            animation: new utilities_1.AnimationEaseInOutCubic(),
-            reAnimateHandling: utilities_1.ReAnimateHandlingType.completePrevious,
-            completeAnimationsHandling: utilities_1.CompleteAnimationsHandlingType.stayInCurrentState
-        }).attach(this);
-        this.blackScreenAnimator = new utilities_1.Animator(this.blackScreen, 'alpha', {
+            animation: utilities_1.Animations.easeInOutCubic,
+            reAnimateHandling: animator_1.ReAnimateHandlingType.CompletePrevious,
+            completionHandling: animator_1.AnimationsCompletionHandlingType.StayInCurrentState
+        });
+        this._blackScreenAnimator = new animator_1.Animator(this._blackScreen, 'alpha', {
             duration: 500,
-            animation: new utilities_1.AnimationEaseInOutCubic(),
-            reAnimateHandling: utilities_1.ReAnimateHandlingType.completePrevious,
-            completeAnimationsHandling: utilities_1.CompleteAnimationsHandlingType.stayInCurrentState
-        }).attach(this);
+            animation: utilities_1.Animations.easeInOutCubic,
+            reAnimateHandling: animator_1.ReAnimateHandlingType.CompletePrevious,
+            completionHandling: animator_1.AnimationsCompletionHandlingType.StayInCurrentState
+        });
         game_1.Game.instance.screenSize
             .subscribe(value => {
-            this.blackScreen.aspectRatio = value.x / value.y;
-            this.blackScreen.scale = Math.max(value.x, value.y);
-            this.blackScreen.setPosition(helpers_lib_1.Vector.zero, { holdFrom: helpers_lib_1.Vector.zero });
+            this._blackScreen.aspectRatio = value.x / value.y;
+            this._blackScreen.scale = Math.max(value.x, value.y);
+            this._blackScreen.setPosition(helpers_lib_1.Vector.zero, { holdFrom: helpers_lib_1.Vector.zero });
         })
             .attach(this);
-        game_1.Game.instance.setScreenPositionToStagePositionFunction(globalMousePosition => new helpers_lib_1.Vector(globalMousePosition.x - this.cameraLayer.position.x - this.cameraOffsetLayer.position.x, globalMousePosition.y - this.cameraLayer.position.y - this.cameraOffsetLayer.position.y));
-        this.entity.position
+        game_1.Game.instance.setScreenPositionToStagePositionFunction(globalMousePosition => new helpers_lib_1.Vector(globalMousePosition.x - this._cameraLayer.position.x - this._cameraOffsetLayer.position.x, globalMousePosition.y - this._cameraLayer.position.y - this._cameraOffsetLayer.position.y));
+        this._entity.position
             .subscribe(position => {
-            this.cameraLayer.position = this.convertToCameraPosition(position);
+            this._cameraLayer.position = this._convertToCameraPosition(position);
         })
             .attach(this);
-        this.entity.offset
+        this._entity.offset
             .subscribe(offset => {
-            this.cameraOffsetLayer.position = offset;
+            this._cameraOffsetLayer.position = offset;
         })
             .attach(this);
         this.appear(true, 'alpha');
     }
     destroy() {
         if (!this.destroyed) {
-            game_1.Game.instance.resetScreenPositionToStagePositionFunction();
             super.destroy();
+            game_1.Game.instance.resetScreenPositionToStagePositionFunction();
         }
     }
     getLayers() {
         return {
-            backgroundScreen: this.backgroundScreen.id,
-            background: this.backgroundLayer.id,
-            main: this.mainLayer.id,
-            foreground: this.foreground.id,
-            foregroundScreen: this.foregroundScreenLayer.id
+            backgroundScreen: this._backgroundScreen.id,
+            background: this._backgroundLayer.id,
+            main: this._mainLayer.id,
+            foreground: this._foreground.id,
+            foregroundScreen: this._foregroundScreenLayer.id
         };
     }
-    async appear(value, type) {
+    appear(value, type) {
         switch (type) {
             case 'alpha':
-                this.blackScreenAnimator.set({ alpha: 0 });
-                this.alphaAnimator.set({ alpha: value ? 0 : 1 });
-                await this.alphaAnimator.animate({ alpha: value ? 1 : 0 });
-                break;
+                this._blackScreenAnimator.set({ alpha: 0 });
+                this._alphaAnimator.set({ alpha: value ? 0 : 1 });
+                return this._alphaAnimator.animate({ alpha: value ? 1 : 0 }).chain(this);
             case 'pureBlack':
-                this.alphaAnimator.set({ alpha: 1 });
-                this.blackScreenAnimator.set({ alpha: value ? 1 : 0 });
-                await this.blackScreenAnimator.animate({ alpha: value ? 0 : 1 });
-                break;
+                this._alphaAnimator.set({ alpha: 1 });
+                this._blackScreenAnimator.set({ alpha: value ? 1 : 0 });
+                return this._blackScreenAnimator.animate({ alpha: value ? 0 : 1 }).chain(this);
             case 'instant':
-                this.alphaAnimator.set({ alpha: value ? 1 : 0 });
-                this.blackScreenAnimator.set({ alpha: value ? 0 : 1 });
-                break;
+                this._alphaAnimator.set({ alpha: value ? 1 : 0 });
+                this._blackScreenAnimator.set({ alpha: value ? 0 : 1 });
+                return actions_lib_1.SingleEvent.instant();
             default: {
                 let _ = type;
+                throw new Error('Switch ended with value "never".');
             }
         }
     }
-    convertToCameraPosition(positionInWorld) {
-        return helpers_lib_1.Vector.fromTo(positionInWorld, game_1.Game.instance.screenSizeCenter.value);
+    _convertToCameraPosition(positionInWorld) {
+        return helpers_lib_1.Vector.fromTo(positionInWorld, game_1.Game.instance.getScreenSizeCenter());
     }
 };
 exports.CameraView = CameraView;

package/dist/pixi/pixi-definitions.d.ts

@@ -0,0 +1,38 @@
+import { RGBColor, Vec2, Vector } from 'helpers-lib';
+export declare const DEFAULT_RESOLUTION = 2;
+export interface AssetDefinition<T extends string = string> {
+    readonly id: string;
+    readonly url: T;
+}
+export declare enum BlendMode {
+    Normal = 0,
+    Add = 1,
+    Screen = 3,
+    Luminosity = 16,
+    ColorDodge = 7
+}
+export interface SpriteDefinition {
+    readonly id: string;
+    readonly scale: number;
+    readonly anchor: Vec2;
+    readonly size: Vec2;
+    readonly boundingShapes?: PolygonDefinition;
+    readonly destroyAssetOnDestroy?: boolean;
+}
+export interface GlowingShapeDefinition {
+    readonly color: RGBColor;
+    readonly shapeAlpha: number;
+    readonly glowAlpha: number;
+    readonly glowOptions: GlowOptions;
+    readonly shapes: PolygonDefinition;
+}
+export type PolygonDefinition = readonly (readonly Vec2[])[];
+export interface GlowOptions {
+    readonly color: RGBColor;
+    readonly blurRadius: number | Vector;
+    readonly expand: number;
+    readonly blendMode: BlendMode;
+}
+export type GlowEffectOptions = Partial<GlowOptions> & {
+    glowAlpha?: number;
+};

package/dist/pixi/pixi-definitions.js

@@ -0,0 +1,37 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BlendMode = exports.DEFAULT_RESOLUTION = void 0;
+const Pixi = __importStar(require("pixi.js"));
+exports.DEFAULT_RESOLUTION = 2;
+var BlendMode;
+(function (BlendMode) {
+    BlendMode[BlendMode["Normal"] = 0] = "Normal";
+    BlendMode[BlendMode["Add"] = 1] = "Add";
+    BlendMode[BlendMode["Screen"] = 3] = "Screen";
+    BlendMode[BlendMode["Luminosity"] = 16] = "Luminosity";
+    BlendMode[BlendMode["ColorDodge"] = 7] = "ColorDodge";
+})(BlendMode || (exports.BlendMode = BlendMode = {}));
+//# sourceMappingURL=pixi-definitions.js.map

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

@@ -1,9 +1,11 @@
 import { Action } from 'actions-lib';
 export declare class KeyboardService {
-    readonly keyPressed: Action<string>;
-    readonly keyReleased: Action<string>;
-    private listOfPressedKeys;
-    private listOfJustPressedKeys;
+    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();
     isKeyDown(key: string): boolean;
     isKeyJustPressed(key: string): boolean;

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

@@ -15,33 +15,35 @@ 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.listOfPressedKeys = new Set();
-        this.listOfJustPressedKeys = new Set();
+        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);
+            this._listOfPressedKeys.add(event.key);
+            this._listOfJustPressedKeys.add(event.key);
+            !event.repeat && this._keyPressed.trigger(event.key);
         });
         window.addEventListener('keyup', event => {
-            this.listOfPressedKeys.delete(event.key);
-            this.keyReleased.trigger(event.key);
+            this._listOfPressedKeys.delete(event.key);
+            this._keyReleased.trigger(event.key);
         });
         window.addEventListener('blur', () => {
-            this.listOfPressedKeys.clear();
+            this._listOfPressedKeys.clear();
         });
         game_entities_1.UpdateCycle.afterSceneUpdateAction
             .subscribe(() => {
-            this.listOfJustPressedKeys.clear();
+            this._listOfJustPressedKeys.clear();
         })
             .attachToRoot();
     }
     isKeyDown(key) {
-        return this.listOfPressedKeys.has(key);
+        return this._listOfPressedKeys.has(key);
     }
     isKeyJustPressed(key) {
-        return this.listOfJustPressedKeys.has(key);
+        return this._listOfJustPressedKeys.has(key);
     }
 };
 exports.KeyboardService = KeyboardService;

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

@@ -2,19 +2,20 @@ import { Action } from 'actions-lib';
 import { Vector } from 'helpers-lib';
 import { MouseService } from './mouse.service';
 export declare class MouseTargetFocusService {
-    private mouseService;
-    onTargetFocus: Action<Vector>;
+    private _mouseService;
+    readonly _onTargetFocus: Action<Vector>;
+    readonly onTargetFocus: import("actions-lib").Notifier<Vector>;
     get focusedInLastFrame(): boolean;
     get lastFocusedPosition(): Vector | undefined;
-    private mouseStagePositionPrevious;
-    private peakValueChange;
-    private timePassFromLastTrigger;
-    private triggerAfterCooldown;
+    private _mouseStagePositionPrevious;
+    private _peakValueChange;
+    private _timePassFromLastTrigger;
+    private _triggerAfterCooldown;
     private _focusedInLastFrame;
     private _lastFocusedPosition;
-    constructor(mouseService: MouseService);
-    private update;
-    private check;
-    private iterateValues;
-    private getPositionChange;
+    constructor(_mouseService: MouseService);
+    private _update;
+    private _check;
+    private _iterateValues;
+    private _getPositionChange;
 }

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

@@ -22,57 +22,58 @@ let MouseTargetFocusService = class MouseTargetFocusService {
     get lastFocusedPosition() {
         return this._lastFocusedPosition;
     }
-    constructor(mouseService) {
-        this.mouseService = mouseService;
-        this.onTargetFocus = new actions_lib_1.Action();
-        this.timePassFromLastTrigger = 0;
-        this.triggerAfterCooldown = false;
+    constructor(_mouseService) {
+        this._mouseService = _mouseService;
+        this._onTargetFocus = new actions_lib_1.Action();
+        this.onTargetFocus = this._onTargetFocus.notifier;
+        this._timePassFromLastTrigger = 0;
+        this._triggerAfterCooldown = false;
         this._focusedInLastFrame = false;
         this._lastFocusedPosition = undefined;
         update_cycle_1.UpdateCycle.beforeSceneUpdateAction
-            .subscribe((event) => this.update(event.delta))
+            .subscribe((event) => this._update(event.delta))
             .attachToRoot();
     }
-    update(delta) {
-        if (this.mouseStagePositionPrevious) {
-            let mousePositionChange = this.getPositionChange(this.mouseService.stagePosition.value, this.mouseStagePositionPrevious);
-            if (this.peakValueChange === undefined) {
-                this.peakValueChange = mousePositionChange;
+    _update(delta) {
+        if (this._mouseStagePositionPrevious) {
+            let mousePositionChange = this._getPositionChange(this._mouseService.getStagePosition(), this._mouseStagePositionPrevious);
+            if (this._peakValueChange === undefined) {
+                this._peakValueChange = mousePositionChange;
             }
             else {
-                this.check(mousePositionChange, delta);
+                this._check(mousePositionChange, delta);
             }
         }
-        this.mouseStagePositionPrevious = this.mouseService.stagePosition.value;
+        this._mouseStagePositionPrevious = this._mouseService.getStagePosition();
     }
-    check(mousePositionChange, delta) {
-        if (this.peakValueChange - mousePositionChange > 10) {
-            this.timePassFromLastTrigger = Math.max(250, this.timePassFromLastTrigger);
-            this.triggerAfterCooldown = true;
+    _check(mousePositionChange, delta) {
+        if (this._peakValueChange - mousePositionChange > 10) {
+            this._timePassFromLastTrigger = Math.max(250, this._timePassFromLastTrigger);
+            this._triggerAfterCooldown = true;
         }
-        else if (this.timePassFromLastTrigger > 1000) {
-            this.triggerAfterCooldown = true;
+        else if (this._timePassFromLastTrigger > 1000) {
+            this._triggerAfterCooldown = true;
         }
-        let focusHappened = this.timePassFromLastTrigger >= 300 && this.triggerAfterCooldown;
-        this.iterateValues(focusHappened, mousePositionChange, delta);
+        let focusHappened = this._timePassFromLastTrigger >= 300 && this._triggerAfterCooldown;
+        this._iterateValues(focusHappened, mousePositionChange, delta);
     }
-    iterateValues(focusHappened, mousePositionChange, delta) {
-        if (focusHappened || mousePositionChange > this.peakValueChange) {
-            this.peakValueChange = mousePositionChange;
+    _iterateValues(focusHappened, mousePositionChange, delta) {
+        if (focusHappened || mousePositionChange > this._peakValueChange) {
+            this._peakValueChange = mousePositionChange;
         }
         if (focusHappened) {
-            this.triggerAfterCooldown = false;
-            this.timePassFromLastTrigger = 0;
+            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;
+            this._timePassFromLastTrigger += delta;
             this._focusedInLastFrame = false;
         }
     }
-    getPositionChange(positionA, positionB) {
+    _getPositionChange(positionA, positionB) {
         let changeVector = helpers_lib_1.Vector.fromTo(positionA, positionB);
         return Math.abs(changeVector.x) + Math.abs(changeVector.y);
     }

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;
+    private _startListeningMouseMove;
 }

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

@@ -14,60 +14,80 @@ const actions_lib_1 = require("actions-lib");
 const helpers_lib_1 = require("helpers-lib");
 const service_1 = require("../../../game-entities/service/service");
 const update_cycle_1 = require("../../../game-entities/update-cycle");
-const __1 = require("../..");
+const game_1 = require("../../game");
 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.startListeningMouseMove();
+        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() {
+    _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 = game_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,
+                game_1.Game.instance.renderer.events['onPointerMove'](new PointerEvent('pointermove', {
+                    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

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

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

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

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const fade_in_content_1 = require("./fade-in-content");
+(0, vitest_1.describe)('Fade In Content', () => {
+    (0, vitest_1.test)('should exist', () => {
+        (0, vitest_1.expect)(fade_in_content_1.FadeInContent).toBeDefined();
+    });
+});
+//# sourceMappingURL=fade-in-content.test.js.map