bard-legends-framework 0.11.0 → 0.12.0

package/dist/pixi/display-object/objects/graphics/graphics.js

@@ -25,16 +25,16 @@ var __importStar = (this && this.__importStar) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Graphics = void 0;
 const helpers_lib_1 = require("helpers-lib");
-const PIXI = __importStar(require("pixi.js"));
+const Pixi = __importStar(require("pixi.js"));
 const game_1 = require("../../../game");
 const game_assets_1 = require("../../../helpers/game-assets");
 const container_1 = require("../../container");
 const sprite_1 = require("../sprite/sprite");
 const dashed_line_helper_1 = require("./helpers/dashed-line.helper");
 class Graphics extends container_1.Container {
-    static { this.drawnTextureCache = new Map(); }
+    static { this._drawnTextureCache = new Map(); }
     static createArrow(size, color) {
-        let pixiGraphics = new PIXI.Graphics();
+        let pixiGraphics = new Pixi.Graphics();
         let polygon = [
             [
                 { x: 0, y: -size / 2 },
@@ -54,7 +54,7 @@ class Graphics extends container_1.Container {
         ];
         pixiGraphics.beginFill(color);
         polygon.forEach(vertices => {
-            pixiGraphics.drawPolygon(vertices.map(vertex => new PIXI.Point(vertex.x, vertex.y)));
+            pixiGraphics.drawPolygon(vertices.map(vertex => new Pixi.Point(vertex.x, vertex.y)));
         });
         pixiGraphics.endFill();
         return new Graphics(pixiGraphics, JSON.stringify({ type: 'arrow', size, color }));
@@ -69,7 +69,7 @@ class Graphics extends container_1.Container {
             color: helpers_lib_1.ColorHelper.white,
             ...partialOptions
         };
-        let pixiGraphics = new PIXI.Graphics();
+        let pixiGraphics = new Pixi.Graphics();
         pixiGraphics.lineStyle(options.width, options.color);
         let lines = dashed_line_helper_1.DashedLineHelper.getLines(from, to, options);
         lines.forEach(line => {
@@ -78,7 +78,7 @@ class Graphics extends container_1.Container {
         return new Graphics(pixiGraphics, JSON.stringify({ type: 'dashedLine', from, to, options }));
     }
     static createVector(from, to, color) {
-        let pixiGraphics = new PIXI.Graphics();
+        let pixiGraphics = new Pixi.Graphics();
         pixiGraphics.lineStyle(2, color);
         pixiGraphics.moveTo(from.x, from.y);
         pixiGraphics.lineTo(to.x, to.y);
@@ -89,7 +89,7 @@ class Graphics extends container_1.Container {
         return new Graphics(pixiGraphics, JSON.stringify({ type: 'line', start: from, end: to, color }));
     }
     static createRectangleBorders(size, borderSize, color) {
-        let pixiGraphics = new PIXI.Graphics();
+        let pixiGraphics = new Pixi.Graphics();
         pixiGraphics.beginFill(color);
         pixiGraphics.drawRect(0, 0, size.x, borderSize);
         pixiGraphics.drawRect(0, borderSize, borderSize, size.y - borderSize * 2);
@@ -99,38 +99,38 @@ class Graphics extends container_1.Container {
         return new Graphics(pixiGraphics, JSON.stringify({ type: 'rectangle-borders', size, borderSize, color }));
     }
     static createRectangle(size, color = helpers_lib_1.ColorHelper.white) {
-        let pixiGraphics = new PIXI.Graphics();
+        let pixiGraphics = new Pixi.Graphics();
         pixiGraphics.beginFill(color);
         pixiGraphics.drawRect(0, 0, size.x, size.y);
         pixiGraphics.endFill();
         return new Graphics(pixiGraphics, JSON.stringify({ type: 'rectangle', size, color }));
     }
     static createCircle(radius, color) {
-        let pixiGraphics = new PIXI.Graphics();
+        let pixiGraphics = new Pixi.Graphics();
         pixiGraphics.beginFill(color);
         pixiGraphics.drawCircle(0, 0, radius);
         pixiGraphics.endFill();
         return new Graphics(pixiGraphics, JSON.stringify({ type: 'circle', radius, color }));
     }
     static createElipse(size, color) {
-        let pixiGraphics = new PIXI.Graphics();
+        let pixiGraphics = new Pixi.Graphics();
         pixiGraphics.beginFill(color);
         pixiGraphics.drawEllipse(0, 0, size.x, size.y);
         pixiGraphics.endFill();
         return new Graphics(pixiGraphics, JSON.stringify({ type: 'elipse', size, color }));
     }
     static createPolygon(polygon, color) {
-        let pixiGraphics = new PIXI.Graphics();
+        let pixiGraphics = new Pixi.Graphics();
         let cacheName = JSON.stringify({ type: 'polygon', polygon, color });
         pixiGraphics.beginFill(color);
         polygon.forEach(vertices => {
-            pixiGraphics.drawPolygon(vertices.map(vertex => new PIXI.Point(vertex.x, vertex.y)));
+            pixiGraphics.drawPolygon(vertices.map(vertex => new Pixi.Point(vertex.x, vertex.y)));
         });
         pixiGraphics.endFill();
         return new Graphics(pixiGraphics, cacheName);
     }
     static createRegularPolygon(sides, radius, color) {
-        let polygon = new PIXI.Graphics();
+        let polygon = new Pixi.Graphics();
         let anglePerStep = new helpers_lib_1.Radian(helpers_lib_1.PI_360 / sides);
         polygon.beginFill(color);
         polygon.moveTo(radius, 0);
@@ -148,24 +148,24 @@ class Graphics extends container_1.Container {
         super();
         this.pixiContainer.addChild(pixiGraphics);
         this.pixiGraphics = pixiGraphics;
-        this.cacheName = cacheName;
+        this._cacheName = cacheName;
     }
     destroy() {
         if (!this.destroyed) {
-            !this.pixiGraphics.destroyed && this.pixiGraphics.destroy();
             super.destroy();
+            !this.pixiGraphics.destroyed && this.pixiGraphics.destroy();
         }
     }
     toSprite(partialOptions) {
         let options = {
-            cacheName: this.cacheName,
+            cacheName: this._cacheName,
             keepBounds: true,
             cache: false,
             ...partialOptions
         };
-        let textureConversion = this.getTexture(options.cacheName, options.cache);
+        let textureConversion = this._getTexture(options.cacheName, options.cache);
         let spriteDefinition = {
-            id: textureConversion.assetId,
+            id: textureConversion.assetID,
             scale: 1,
             size: textureConversion.bounds,
             anchor: { x: 0, y: 0 },
@@ -177,24 +177,24 @@ class Graphics extends container_1.Container {
         this.destroy();
         return sprite;
     }
-    getTexture(cacheName, cache) {
+    _getTexture(cacheName, cache) {
         if (cache) {
-            let textureOfGraphics = Graphics.drawnTextureCache.get(cacheName);
+            let textureOfGraphics = Graphics._drawnTextureCache.get(cacheName);
             if (!textureOfGraphics) {
-                textureOfGraphics = this.createTextureFromGraphics();
-                Graphics.drawnTextureCache.set(cacheName, textureOfGraphics);
+                textureOfGraphics = this._createTextureFromGraphics();
+                Graphics._drawnTextureCache.set(cacheName, textureOfGraphics);
             }
             return textureOfGraphics;
         }
         else {
-            return this.createTextureFromGraphics();
+            return this._createTextureFromGraphics();
         }
     }
-    createTextureFromGraphics() {
+    _createTextureFromGraphics() {
         let texture = game_1.Game.instance.renderer.generateTexture(this.pixiGraphics);
         texture.id = game_assets_1.GameAssets.insertAsset(texture);
         let graphicsBounds = this.pixiGraphics.getBounds();
-        return { assetId: texture.id, bounds: new helpers_lib_1.Vector(graphicsBounds.x, graphicsBounds.y) };
+        return { assetID: texture.id, bounds: new helpers_lib_1.Vector(graphicsBounds.x, graphicsBounds.y) };
     }
 }
 exports.Graphics = Graphics;

package/dist/pixi/display-object/objects/placeholder.d.ts

@@ -1,7 +1,7 @@
 import { Vector } from 'helpers-lib';
 import { Container } from '../container';
 export declare class Placeholder extends Container {
-    private pixiGraphics;
+    private _pixiGraphics;
     constructor(size: Vector);
     destroy(): void;
 }

package/dist/pixi/display-object/objects/placeholder.js

@@ -24,21 +24,21 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Placeholder = void 0;
-const PIXI = __importStar(require("pixi.js"));
+const Pixi = __importStar(require("pixi.js"));
 const container_1 = require("../container");
 class Placeholder extends container_1.Container {
     constructor(size) {
         super();
-        this.pixiGraphics = new PIXI.Graphics();
-        this.pixiGraphics.beginFill(0x000000, 0.000000001);
-        this.pixiGraphics.drawRect(0, 0, size.x, size.y);
-        this.pixiGraphics.endFill();
-        this.pixiContainer.addChild(this.pixiGraphics);
+        this._pixiGraphics = new Pixi.Graphics();
+        this._pixiGraphics.beginFill(0x000000, 0.000000001);
+        this._pixiGraphics.drawRect(0, 0, size.x, size.y);
+        this._pixiGraphics.endFill();
+        this.pixiContainer.addChild(this._pixiGraphics);
     }
     destroy() {
         if (!this.destroyed) {
-            this.pixiGraphics.destroy();
             super.destroy();
+            this._pixiGraphics.destroy();
         }
     }
 }

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

@@ -1,11 +1,11 @@
-import * as PIXI from 'pixi.js';
-import { GlowEffectOptions } from '../../..';
+import * as Pixi from 'pixi.js';
+import { GlowEffectOptions } from '../../../pixi-definitions';
 export declare class GlowSpriteGenerator {
-    private static glowTextureCache;
-    static createGlowSpriteFromSprite(pixiSprite: PIXI.Sprite, partialOptions: GlowEffectOptions, cache: boolean): PIXI.Sprite;
-    private static getGlowTexture;
-    private static getGlowTextureFromSprite;
-    private static setEquavelentAnchorByExtendedBounds;
-    private static extendBounds;
-    private static completeOptions;
+    private static _glowTextureCache;
+    static createGlowSpriteFromSprite(pixiSprite: Pixi.Sprite, partialOptions: GlowEffectOptions, cache: boolean): Pixi.Sprite;
+    private static _getGlowTexture;
+    private static _getGlowTextureFromSprite;
+    private static _setEquavelentAnchorByExtendedBounds;
+    private static _extendBounds;
+    private static _completeOptions;
 }

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

@@ -25,61 +25,62 @@ var __importStar = (this && this.__importStar) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GlowSpriteGenerator = void 0;
 const helpers_lib_1 = require("helpers-lib");
-const PIXI = __importStar(require("pixi.js"));
-const unit_test_helper_1 = require("../../../../game-entities/unit-test.helper");
-const __1 = require("../../..");
+const Pixi = __importStar(require("pixi.js"));
+const hard_reset_1 = require("../../../../game-entities/hard-reset");
+const game_1 = require("../../../game");
 const game_assets_1 = require("../../../helpers/game-assets");
+const pixi_definitions_1 = require("../../../pixi-definitions");
 const glow_filter_1 = require("../../filters/composite-filters/glow-filter");
 class GlowSpriteGenerator {
-    static { this.glowTextureCache = new Map(); }
+    static { this._glowTextureCache = new Map(); }
     static createGlowSpriteFromSprite(pixiSprite, partialOptions, cache) {
-        let options = this.completeOptions(partialOptions);
+        let options = this._completeOptions(partialOptions);
         let blurRadiusVector = helpers_lib_1.Comparator.isNumber(options.blurRadius)
             ? new helpers_lib_1.Vector(options.blurRadius, options.blurRadius)
             : options.blurRadius;
-        let glowBaseTexture = this.getGlowTexture(pixiSprite.texture, blurRadiusVector, options.expand, options.color, cache);
-        let glowSprite = new PIXI.Sprite(glowBaseTexture);
-        this.setEquavelentAnchorByExtendedBounds(glowSprite, helpers_lib_1.Vector.fromVec2(pixiSprite.anchor), Math.max(blurRadiusVector.x, blurRadiusVector.y) + options.expand);
+        let glowBaseTexture = this._getGlowTexture(pixiSprite.texture, blurRadiusVector, options.expand, options.color, cache);
+        let glowSprite = new Pixi.Sprite(glowBaseTexture);
+        this._setEquavelentAnchorByExtendedBounds(glowSprite, helpers_lib_1.Vector.fromVec2(pixiSprite.anchor), Math.max(blurRadiusVector.x, blurRadiusVector.y) + options.expand);
         glowSprite.alpha = options.glowAlpha;
         glowSprite.blendMode = options.blendMode;
         return glowSprite;
     }
-    static getGlowTexture(baseTexture, blurRadius, expand, color, cache) {
+    static _getGlowTexture(baseTexture, blurRadius, expand, color, cache) {
         if (!baseTexture.id) {
             throw new Error('GlowSpriteGenerator: baseTexture should have an id');
         }
         if (cache) {
             let cacheName = `${baseTexture.id}-${expand}-${blurRadius.x}-${blurRadius.y}-${color.r}-${color.g}-${color.b}`;
-            if (GlowSpriteGenerator.glowTextureCache.has(cacheName)) {
-                return GlowSpriteGenerator.glowTextureCache.get(cacheName);
+            if (GlowSpriteGenerator._glowTextureCache.has(cacheName)) {
+                return GlowSpriteGenerator._glowTextureCache.get(cacheName);
             }
             else {
-                let texture = this.getGlowTextureFromSprite(baseTexture, blurRadius, expand, color);
-                GlowSpriteGenerator.glowTextureCache.set(cacheName, texture);
+                let texture = this._getGlowTextureFromSprite(baseTexture, blurRadius, expand, color);
+                GlowSpriteGenerator._glowTextureCache.set(cacheName, texture);
                 return texture;
             }
         }
         else {
-            return this.getGlowTextureFromSprite(baseTexture, blurRadius, expand, color);
+            return this._getGlowTextureFromSprite(baseTexture, blurRadius, expand, color);
         }
     }
-    static getGlowTextureFromSprite(baseTexture, blurRadius, expand, color) {
-        let glowBaseSprite = new PIXI.Sprite(baseTexture);
-        this.extendBounds(glowBaseSprite, Math.max(blurRadius.x, blurRadius.y) + expand);
+    static _getGlowTextureFromSprite(baseTexture, blurRadius, expand, color) {
+        let glowBaseSprite = new Pixi.Sprite(baseTexture);
+        this._extendBounds(glowBaseSprite, Math.max(blurRadius.x, blurRadius.y) + expand);
         glowBaseSprite.filters = [new glow_filter_1.GlowFilter({ blurRadius, expand, color })];
-        let texture = __1.Game.instance.renderer.generateTexture(glowBaseSprite);
+        let texture = game_1.Game.instance.renderer.generateTexture(glowBaseSprite);
         texture.id = game_assets_1.GameAssets.insertAsset(texture);
         glowBaseSprite.destroy();
         return texture;
     }
-    static setEquavelentAnchorByExtendedBounds(sprite, anchor, amount) {
+    static _setEquavelentAnchorByExtendedBounds(sprite, anchor, amount) {
         let x = (amount + (sprite.width - amount * 2) * anchor.x) / sprite.width;
         let y = (amount + (sprite.height - amount * 2) * anchor.y) / sprite.height;
         sprite.anchor.set(x, y);
     }
-    static extendBounds(container, amount) {
+    static _extendBounds(container, amount) {
         if (container.isSprite) {
-            let graphics = new PIXI.Graphics();
+            let graphics = new Pixi.Graphics();
             container.addChild(graphics);
         }
         let width = container.width;
@@ -89,13 +90,13 @@ class GlowSpriteGenerator {
             this._bounds.addFrame(this.transform, -amount, -amount, width + amount, height + amount);
         };
     }
-    static completeOptions(partialOptions) {
+    static _completeOptions(partialOptions) {
         let options = {
             glowAlpha: 1,
             blurRadius: 5,
             expand: 0,
             color: helpers_lib_1.ColorHelper.white,
-            blendMode: __1.BlendMode.add
+            blendMode: pixi_definitions_1.BlendMode.Add
         };
         if (partialOptions) {
             options = { ...options, ...partialOptions };
@@ -104,9 +105,9 @@ class GlowSpriteGenerator {
     }
 }
 exports.GlowSpriteGenerator = GlowSpriteGenerator;
-unit_test_helper_1.UnitTestHelper.onHardReset
+hard_reset_1.BardLegendsHardReset.onHardReset
     .subscribe(() => {
-    GlowSpriteGenerator['glowTextureCache'].clear();
+    GlowSpriteGenerator['_glowTextureCache'].clear();
 })
     .attachToRoot();
 //# sourceMappingURL=glow-sprite-generator.js.map

package/dist/pixi/display-object/objects/sprite/sprite.d.ts

@@ -1,6 +1,6 @@
 import { RGBColor, Vector } from 'helpers-lib';
-import * as PIXI from 'pixi.js';
-import { BlendMode, GlowEffectOptions, SpriteDefinition } from '../../..';
+import * as Pixi from 'pixi.js';
+import { BlendMode, GlowEffectOptions, SpriteDefinition } from '../../../pixi-definitions';
 import { Container } from '../../container';
 export interface SpriteOptions {
     readonly textureSize?: Vector;
@@ -8,12 +8,13 @@ export interface SpriteOptions {
     readonly ignoreAnchor?: boolean;
 }
 export declare class Sprite extends Container {
+    static createByName(spriteName: string): Sprite;
     static createSnapshotSprite(container: Container): Sprite;
-    readonly pixiSprite: PIXI.Sprite;
-    private spriteDefinition;
-    private mask;
-    private boundingShape;
-    private pixiGlowSprite;
+    readonly pixiSprite: Pixi.Sprite;
+    private _spriteDefinition;
+    private _maskSprite;
+    private _boundingShape;
+    private _pixiGlowSprite;
     constructor(spriteDefinition: SpriteDefinition, options?: SpriteOptions);
     destroy(): void;
     private _textureScale;
@@ -21,7 +22,7 @@ export declare class Sprite extends Container {
     get textureScale(): number;
     set textureScale(value: number);
     get size(): Vector;
-    protected getMask(): PIXI.Container;
+    protected getMask(): Pixi.Container;
     set interactive(value: boolean);
     setMipmap(value: boolean): this;
     get mipmap(): boolean;
@@ -46,6 +47,6 @@ export declare class Sprite extends Container {
     setGlowEffect(partialOptions: GlowEffectOptions | undefined): this;
     showBoundingShape(value: boolean): this;
     getBoundingMask(): Sprite;
-    private createBoundingShapeImage;
+    private _createBoundingShapeImage;
     download(): this;
 }

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

@@ -25,33 +25,40 @@ var __importStar = (this && this.__importStar) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Sprite = void 0;
 const helpers_lib_1 = require("helpers-lib");
-const PIXI = __importStar(require("pixi.js"));
-const __1 = require("../../..");
+const Pixi = __importStar(require("pixi.js"));
+const game_1 = require("../../../game");
 const game_assets_1 = require("../../../helpers/game-assets");
 const position_conversion_helper_1 = require("../../../helpers/position-conversion.helper");
 const container_1 = require("../../container");
 const graphics_1 = require("../graphics/graphics");
 const glow_sprite_generator_1 = require("./glow-sprite-generator");
 class Sprite extends container_1.Container {
+    static createByName(spriteName) {
+        let spriteDefinition = game_1.Game.setupOptions.spriteDefinitions[spriteName];
+        if (!spriteDefinition) {
+            throw new Error(`Sprite: Could not find sprite definition with name ${spriteName}.`);
+        }
+        return new Sprite(spriteDefinition);
+    }
     static createSnapshotSprite(container) {
-        let pixiContainer = container['pixiContainer'];
+        let pixiContainer = container.pixiContainer;
         let parent = pixiContainer.parent;
         // The "renderer.generateTexture" is not working if the sprite has a parent with the PIXI version 7.4.2
         // TODO: Check if this is still the case with a newer version of PIXI
         if (parent) {
             parent.removeChild(pixiContainer);
         }
-        let texture = __1.Game.instance.renderer.generateTexture(pixiContainer, {
+        let texture = game_1.Game.instance.renderer.generateTexture(pixiContainer, {
             resolution: 2,
-            scaleMode: PIXI.SCALE_MODES.LINEAR,
-            multisample: PIXI.MSAA_QUALITY.HIGH
+            scaleMode: Pixi.SCALE_MODES.LINEAR,
+            multisample: Pixi.MSAA_QUALITY.HIGH
         });
         if (parent) {
             parent.addChild(pixiContainer); // TODO: removing and re-adding the child changes the order, it would break the z-index order
         }
-        let assetId = game_assets_1.GameAssets.insertAsset(texture);
+        let assetID = game_assets_1.GameAssets.insertAsset(texture);
         let spriteDefinition = {
-            id: assetId,
+            id: assetID,
             scale: container.scale,
             size: container.size,
             anchor: helpers_lib_1.Vector.zero,
@@ -66,8 +73,8 @@ class Sprite extends container_1.Container {
         if (!spriteDefinition) {
             throw new Error(`Sprite: spriteDefinition cannot be nullish!`);
         }
-        this.spriteDefinition = spriteDefinition;
-        this.pixiSprite = new PIXI.Sprite(game_assets_1.GameAssets.getAsset(spriteDefinition.id));
+        this._spriteDefinition = spriteDefinition;
+        this.pixiSprite = new Pixi.Sprite(game_assets_1.GameAssets.getAsset(spriteDefinition.id));
         this.pixiContainer.addChild(this.pixiSprite);
         this.setTextureScale(spriteDefinition.scale);
         if (options.textureSize) {
@@ -83,16 +90,18 @@ class Sprite extends container_1.Container {
     }
     destroy() {
         if (!this.destroyed) {
-            !this.pixiGlowSprite?.destroyed && this.pixiGlowSprite?.destroy();
-            this.pixiGlowSprite = undefined;
-            this.mask?.destroy();
-            this.mask = undefined;
-            this.boundingShape?.destroy();
-            this.boundingShape = undefined;
-            if (this.spriteDefinition.destroyAssetOnDestroy) {
-                game_assets_1.GameAssets.destroyAsset(this.spriteDefinition.id);
-            }
             super.destroy();
+            this._maskSprite?.destroy();
+            this._boundingShape?.destroy();
+            if (this._spriteDefinition.destroyAssetOnDestroy) {
+                game_assets_1.GameAssets.destroyAsset(this._spriteDefinition.id);
+                if (this._pixiGlowSprite) {
+                    game_assets_1.GameAssets.destroyAsset(this._pixiGlowSprite.texture.id);
+                }
+            }
+            if (this._pixiGlowSprite && !this._pixiGlowSprite.destroyed) {
+                this._pixiGlowSprite.destroy();
+            }
         }
     }
     setTextureScale(value) {
@@ -115,8 +124,8 @@ class Sprite extends container_1.Container {
     }
     set interactive(value) {
         super.interactive = value;
-        if (value && this.spriteDefinition.boundingShapes && !this.pixiContainer.hitArea) {
-            this.pixiContainer.hitArea = new position_conversion_helper_1.CompositeHitArea(this.spriteDefinition.boundingShapes, this.size, helpers_lib_1.Vector.fromVec2(this.spriteDefinition.anchor));
+        if (value && this._spriteDefinition.boundingShapes && !this.pixiContainer.hitArea) {
+            this.pixiContainer.hitArea = new position_conversion_helper_1.CompositeHitArea(this._spriteDefinition.boundingShapes, this.size, helpers_lib_1.Vector.fromVec2(this._spriteDefinition.anchor));
         }
     }
     setMipmap(value) {
@@ -124,14 +133,14 @@ class Sprite extends container_1.Container {
         return this;
     }
     get mipmap() {
-        return this.pixiSprite.texture.baseTexture.mipmap === PIXI.MIPMAP_MODES.ON;
+        return this.pixiSprite.texture.baseTexture.mipmap === Pixi.MIPMAP_MODES.ON;
     }
     set mipmap(value) {
         if (value) {
-            this.pixiSprite.texture.baseTexture.mipmap = PIXI.MIPMAP_MODES.ON;
+            this.pixiSprite.texture.baseTexture.mipmap = Pixi.MIPMAP_MODES.ON;
         }
         else {
-            this.pixiSprite.texture.baseTexture.mipmap = PIXI.MIPMAP_MODES.OFF;
+            this.pixiSprite.texture.baseTexture.mipmap = Pixi.MIPMAP_MODES.OFF;
         }
     }
     setBlendMode(value) {
@@ -149,7 +158,7 @@ class Sprite extends container_1.Container {
         return this;
     }
     get tint() {
-        return new PIXI.Color(this.pixiSprite.tint).toRgb();
+        return new Pixi.Color(this.pixiSprite.tint).toRgb();
     }
     set tint(value) {
         this.pixiSprite.tint = value;
@@ -169,16 +178,16 @@ class Sprite extends container_1.Container {
         return this;
     }
     get glowAlpha() {
-        if (this.pixiGlowSprite) {
-            return this.pixiGlowSprite.alpha;
+        if (this._pixiGlowSprite) {
+            return this._pixiGlowSprite.alpha;
         }
         else {
             throw new Error(`Sprite: getGlowFilterAlpha cannot be called before glow filter is added.`);
         }
     }
     set glowAlpha(value) {
-        if (this.pixiGlowSprite) {
-            this.pixiGlowSprite.alpha = value;
+        if (this._pixiGlowSprite) {
+            this._pixiGlowSprite.alpha = value;
         }
         else {
             throw new Error(`Sprite: setGlowFilterAlpha cannot be called before glow filter is added.`);
@@ -189,56 +198,56 @@ class Sprite extends container_1.Container {
      * @returns the vector of the alignment to set the position for the children
      */
     getAlignmentVector(alignment) {
-        let direction = helpers_lib_1.Vector.fromVec2(this.spriteDefinition.anchor).to(alignment);
+        let direction = helpers_lib_1.Vector.fromVec2(this._spriteDefinition.anchor).to(alignment);
         return new helpers_lib_1.Vector(this.size.x * direction.x, this.size.y * direction.y);
     }
     setGlowEffect(partialOptions) {
-        if (this.pixiGlowSprite) {
-            this.pixiGlowSprite.destroy();
-            this.pixiGlowSprite = undefined;
+        if (this._pixiGlowSprite) {
+            this._pixiGlowSprite.destroy();
+            this._pixiGlowSprite = undefined;
         }
         if (partialOptions) {
-            this.pixiGlowSprite = glow_sprite_generator_1.GlowSpriteGenerator.createGlowSpriteFromSprite(this.pixiSprite, partialOptions, !this.spriteDefinition.destroyAssetOnDestroy);
-            this.pixiGlowSprite.position.set(this.pixiSprite.x, this.pixiSprite.y);
-            this.pixiGlowSprite.scale.set(this.pixiSprite.scale.x, this.pixiSprite.scale.y);
-            this.pixiContainer.addChild(this.pixiGlowSprite);
+            this._pixiGlowSprite = glow_sprite_generator_1.GlowSpriteGenerator.createGlowSpriteFromSprite(this.pixiSprite, partialOptions, !this._spriteDefinition.destroyAssetOnDestroy);
+            this._pixiGlowSprite.position.set(this.pixiSprite.x, this.pixiSprite.y);
+            this._pixiGlowSprite.scale.set(this.pixiSprite.scale.x, this.pixiSprite.scale.y);
+            this.pixiContainer.addChild(this._pixiGlowSprite);
         }
         return this;
     }
     showBoundingShape(value) {
         if (value) {
-            if (!this.boundingShape) {
-                this.boundingShape = this.createBoundingShapeImage().setAlpha(0.3).setTint({ r: 0, g: 0, b: 200 }).displayParent(this);
+            if (!this._boundingShape) {
+                this._boundingShape = this._createBoundingShapeImage().setAlpha(0.3).setTint({ r: 0, g: 0, b: 200 }).displayParent(this);
             }
         }
-        else if (this.boundingShape) {
-            this.boundingShape.destroy();
-            this.boundingShape = undefined;
+        else if (this._boundingShape) {
+            this._boundingShape.destroy();
+            this._boundingShape = undefined;
         }
         return this;
     }
     getBoundingMask() {
-        if (!this.mask) {
-            if (!this.spriteDefinition.boundingShapes) {
+        if (!this._maskSprite) {
+            if (!this._spriteDefinition.boundingShapes) {
                 throw new Error(`Sprite: cropOverflowingParts cannot be used without polygonDefinition!`);
             }
-            this.mask = this.createBoundingShapeImage();
+            this._maskSprite = this._createBoundingShapeImage();
             // PixiJS prevents mask sprites from being rendered, but when there is display object left that uses the mask, it will be rendered.
             // to prevent this, we set the mask's renderable property to false and set the mask's maskRefCount to Number.POSITIVE_INFINITY
-            this.mask.pixiSprite['_maskRefCount'] = Number.POSITIVE_INFINITY;
-            this.mask.pixiSprite.renderable = false;
-            this.mask.displayParent(this);
+            this._maskSprite.pixiSprite['_maskRefCount'] = Number.POSITIVE_INFINITY;
+            this._maskSprite.pixiSprite.renderable = false;
+            this._maskSprite.displayParent(this);
         }
-        return this.mask;
+        return this._maskSprite;
     }
-    createBoundingShapeImage() {
-        if (!this.spriteDefinition.boundingShapes) {
+    _createBoundingShapeImage() {
+        if (!this._spriteDefinition.boundingShapes) {
             throw new Error(`Sprite: bounding shape cannot be created without polygonDefinition!`);
         }
-        return graphics_1.Graphics.createPolygon(this.spriteDefinition.boundingShapes, helpers_lib_1.ColorHelper.white).toSprite().attach(this);
+        return graphics_1.Graphics.createPolygon(this._spriteDefinition.boundingShapes, helpers_lib_1.ColorHelper.white).toSprite().attach(this);
     }
     download() {
-        let canvas = __1.Game.instance.renderer.extract.canvas(this.pixiContainer);
+        let canvas = game_1.Game.instance.renderer.extract.canvas(this.pixiContainer);
         if (!canvas.toBlob) {
             throw new Error(`Sprite: canvas.toBlob is undefined!`);
         }

package/dist/pixi/display-object/objects/text/helpers/process-steps/1-data-in-converter/pixi-text-style-converter.d.ts

@@ -1,5 +1,5 @@
 import { Radian, RGBColor } from 'helpers-lib';
-import * as PIXI from 'pixi.js';
+import * as Pixi from 'pixi.js';
 export interface DropShadowOptions {
     readonly blur: number;
     readonly angle: Radian;
@@ -7,9 +7,10 @@ export interface DropShadowOptions {
     readonly color: RGBColor;
     readonly alpha: number;
 }
+export type TextAlignment = 'center' | 'left' | 'right';
 export interface TextOptions {
     readonly color: RGBColor;
-    readonly align: 'left' | 'center' | 'right';
+    readonly align: TextAlignment;
     readonly fontFamily: string;
     readonly fontSize: number;
     readonly fontStyle: 'normal' | 'italic' | 'oblique';
@@ -21,7 +22,7 @@ export interface TextOptions {
 export type PartialTextOptions = Partial<Omit<TextOptions, 'dropShadow'>> & {
     dropShadow?: Partial<DropShadowOptions> | true;
 };
-export interface ExtendedPixiTextStyle extends Partial<PIXI.ITextStyle> {
+export interface ExtendedPixiTextStyle extends Partial<Pixi.ITextStyle> {
     readonly lineThrough: boolean;
 }
 export declare class TextStyleConverter {

package/dist/pixi/display-object/objects/text/helpers/process-steps/1-data-in-converter/rich-text-data-in-converter.d.ts

@@ -10,10 +10,10 @@ export interface TagsWithStyles {
 }
 export declare class RichTextDataInConverter {
     static process(text: string, options: RichTextOptions): ChunkData[][];
-    private static includeStylesToTags;
-    private static getCombinedStyle;
-    private static combineStyles;
-    private static applyNewLines;
-    private static splitIntoChunks;
-    private static splitToChunks;
+    private static _includeStylesToTags;
+    private static _getCombinedStyle;
+    private static _combineStyles;
+    private static _applyNewLines;
+    private static _splitIntoChunks;
+    private static _splitToChunks;
 }