bard-legends-framework 0.11.0 → 0.12.0

package/dist/pixi/display-object/objects/text/helpers/process-steps/3-data-out-converter/rich-text-data-out-converter.test.js

@@ -14,7 +14,7 @@ const rich_text_data_out_converter_1 = require("./rich-text-data-out-converter")
                     { chunk: (0, rich_text_to_plane_text_test_1.CreateSampleChunkData)(' world'), position: new helpers_lib_1.Vector(50, 0) }
                 ]
             ];
-            let result = rich_text_data_out_converter_1.RichTextDataOutConverter['mergeSameStyleChunks'](chunks);
+            let result = rich_text_data_out_converter_1.RichTextDataOutConverter['_mergeSameStyleChunks'](chunks);
             (0, vitest_1.expect)(result).toEqual([[{ chunk: (0, rich_text_to_plane_text_test_1.CreateSampleChunkData)('hello world'), position: new helpers_lib_1.Vector(0, 0) }]]);
         });
         (0, vitest_1.test)('does not merge chunks with different styles', () => {
@@ -24,7 +24,7 @@ const rich_text_data_out_converter_1 = require("./rich-text-data-out-converter")
                     { chunk: (0, rich_text_to_plane_text_test_1.CreateSampleChunkData)(' world', { fontSize: 20 }), position: new helpers_lib_1.Vector(50, 0) }
                 ]
             ];
-            let result = rich_text_data_out_converter_1.RichTextDataOutConverter['mergeSameStyleChunks'](chunks);
+            let result = rich_text_data_out_converter_1.RichTextDataOutConverter['_mergeSameStyleChunks'](chunks);
             (0, vitest_1.expect)(result).toEqual([
                 [
                     { chunk: (0, rich_text_to_plane_text_test_1.CreateSampleChunkData)('hello'), position: new helpers_lib_1.Vector(0, 0) },
@@ -43,7 +43,7 @@ const rich_text_data_out_converter_1 = require("./rich-text-data-out-converter")
                     { chunk: (0, rich_text_to_plane_text_test_1.CreateSampleChunkData)(' bar'), position: new helpers_lib_1.Vector(30, 20) }
                 ]
             ];
-            let result = rich_text_data_out_converter_1.RichTextDataOutConverter['mergeSameStyleChunks'](chunks);
+            let result = rich_text_data_out_converter_1.RichTextDataOutConverter['_mergeSameStyleChunks'](chunks);
             (0, vitest_1.expect)(result).toEqual([
                 [{ chunk: (0, rich_text_to_plane_text_test_1.CreateSampleChunkData)('hello world'), position: new helpers_lib_1.Vector(0, 0) }],
                 [{ chunk: (0, rich_text_to_plane_text_test_1.CreateSampleChunkData)('foo bar'), position: new helpers_lib_1.Vector(0, 20) }]
@@ -58,24 +58,24 @@ const rich_text_data_out_converter_1 = require("./rich-text-data-out-converter")
                     { chunk: (0, rich_text_to_plane_text_test_1.CreateSampleChunkData)('   '), position: new helpers_lib_1.Vector(50, 0) }
                 ]
             ];
-            let result = rich_text_data_out_converter_1.RichTextDataOutConverter['trimEmptySpaces'](chunks);
+            let result = rich_text_data_out_converter_1.RichTextDataOutConverter['_trimEmptySpaces'](chunks);
             (0, vitest_1.expect)(result).toEqual([[{ chunk: (0, rich_text_to_plane_text_test_1.CreateSampleChunkData)('hello'), position: new helpers_lib_1.Vector(0, 0) }]]);
         });
         (0, vitest_1.test)('does not trim non-whitespace', () => {
             let chunks = [[{ chunk: (0, rich_text_to_plane_text_test_1.CreateSampleChunkData)('hello'), position: new helpers_lib_1.Vector(0, 0) }]];
-            let result = rich_text_data_out_converter_1.RichTextDataOutConverter['trimEmptySpaces'](chunks);
+            let result = rich_text_data_out_converter_1.RichTextDataOutConverter['_trimEmptySpaces'](chunks);
             (0, vitest_1.expect)(result).toEqual([[{ chunk: (0, rich_text_to_plane_text_test_1.CreateSampleChunkData)('hello'), position: new helpers_lib_1.Vector(0, 0) }]]);
         });
         (0, vitest_1.test)('handles empty lines', () => {
             let chunks = [];
-            let result = rich_text_data_out_converter_1.RichTextDataOutConverter['trimEmptySpaces'](chunks);
+            let result = rich_text_data_out_converter_1.RichTextDataOutConverter['_trimEmptySpaces'](chunks);
             (0, vitest_1.expect)(result).toEqual([]);
         });
     });
     (0, vitest_1.describe)('chunksToTextData', () => {
         (0, vitest_1.test)('single line with one chunk', () => {
             let chunks = [[{ chunk: (0, rich_text_to_plane_text_test_1.CreateSampleChunkData)('Hello'), position: new helpers_lib_1.Vector(0, 0) }]];
-            let result = rich_text_data_out_converter_1.RichTextDataOutConverter['chunksToTextData'](chunks);
+            let result = rich_text_data_out_converter_1.RichTextDataOutConverter['_chunksToTextData'](chunks);
             (0, vitest_1.expect)(result).toEqual([
                 {
                     text: 'Hello',
@@ -91,7 +91,7 @@ const rich_text_data_out_converter_1 = require("./rich-text-data-out-converter")
                     { chunk: (0, rich_text_to_plane_text_test_1.CreateSampleChunkData)(' World'), position: new helpers_lib_1.Vector(50, 0) }
                 ]
             ];
-            let result = rich_text_data_out_converter_1.RichTextDataOutConverter['chunksToTextData'](chunks);
+            let result = rich_text_data_out_converter_1.RichTextDataOutConverter['_chunksToTextData'](chunks);
             (0, vitest_1.expect)(result).toEqual([
                 {
                     text: 'Hello',
@@ -113,7 +113,7 @@ const rich_text_data_out_converter_1 = require("./rich-text-data-out-converter")
                 ],
                 [{ chunk: (0, rich_text_to_plane_text_test_1.CreateSampleChunkData)('012'), position: new helpers_lib_1.Vector(0, 24) }]
             ];
-            let result = rich_text_data_out_converter_1.RichTextDataOutConverter['chunksToTextData'](chunks);
+            let result = rich_text_data_out_converter_1.RichTextDataOutConverter['_chunksToTextData'](chunks);
             (0, vitest_1.expect)(result).toEqual([
                 {
                     text: '012',
@@ -134,17 +134,17 @@ const rich_text_data_out_converter_1 = require("./rich-text-data-out-converter")
         });
         (0, vitest_1.test)('empty chunks array', () => {
             let chunks = [];
-            let result = rich_text_data_out_converter_1.RichTextDataOutConverter['chunksToTextData'](chunks);
+            let result = rich_text_data_out_converter_1.RichTextDataOutConverter['_chunksToTextData'](chunks);
             (0, vitest_1.expect)(result).toEqual([]);
         });
         (0, vitest_1.test)('empty string array', () => {
             let chunks = [[{ chunk: (0, rich_text_to_plane_text_test_1.CreateSampleChunkData)(''), position: new helpers_lib_1.Vector(0, 0) }]];
-            let result = rich_text_data_out_converter_1.RichTextDataOutConverter['chunksToTextData'](chunks);
+            let result = rich_text_data_out_converter_1.RichTextDataOutConverter['_chunksToTextData'](chunks);
             (0, vitest_1.expect)(result).toEqual([]);
         });
         (0, vitest_1.test)('line with whitespace only chunks', () => {
             let chunks = [[{ chunk: (0, rich_text_to_plane_text_test_1.CreateSampleChunkData)(' '), position: new helpers_lib_1.Vector(0, 0) }]];
-            let result = rich_text_data_out_converter_1.RichTextDataOutConverter['chunksToTextData'](chunks);
+            let result = rich_text_data_out_converter_1.RichTextDataOutConverter['_chunksToTextData'](chunks);
             (0, vitest_1.expect)(result).toEqual([]);
         });
     });

package/dist/pixi/display-object/objects/text/helpers/rich-text-to-plane-text.d.ts

@@ -1,4 +1,4 @@
-import * as PIXI from 'pixi.js';
+import * as Pixi from 'pixi.js';
 import { RichTextOptions } from '../rich-text';
 import { TextData } from '.';
 import { PartialTextOptions } from './process-steps/1-data-in-converter/pixi-text-style-converter';
@@ -10,7 +10,7 @@ export interface ChunkStyle {
     readonly descent: number;
     readonly spaceWidth: number;
     readonly style: PartialTextOptions;
-    readonly pixiStyle: PIXI.TextStyle;
+    readonly pixiStyle: Pixi.TextStyle;
 }
 export interface ChunkData {
     readonly text: string;

package/dist/pixi/display-object/objects/text/helpers/rich-text-to-plane-text.test.js

@@ -25,7 +25,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MockPixiMeasureText = exports.CreateSampleChunkData = void 0;
 const helpers_lib_1 = require("helpers-lib");
-const PIXI = __importStar(require("pixi.js"));
+const Pixi = __importStar(require("pixi.js"));
 const vitest_1 = require("vitest");
 const rich_text_to_plane_text_1 = require("./rich-text-to-plane-text");
 const CreateSampleChunkData = (text, options) => ({
@@ -34,7 +34,7 @@ const CreateSampleChunkData = (text, options) => ({
     style: {
         cacheKey: JSON.stringify(options) ?? 'empty',
         style: { fontSize: options?.fontSize ?? 16, fontFamily: 'Arial' },
-        pixiStyle: new PIXI.TextStyle({ fontSize: options?.fontSize ?? 16, fontFamily: 'Arial' }),
+        pixiStyle: new Pixi.TextStyle({ fontSize: options?.fontSize ?? 16, fontFamily: 'Arial' }),
         height: options?.fontSize ?? 16,
         ascent: options?.fontSize ? options.fontSize - 4 : 12,
         descent: 4,
@@ -44,10 +44,10 @@ const CreateSampleChunkData = (text, options) => ({
 });
 exports.CreateSampleChunkData = CreateSampleChunkData;
 const MockPixiMeasureText = () => {
-    const ORIGINAL_MEASURE_TEXT = PIXI.TextMetrics.measureText;
+    const OriginalMeasureText = Pixi.TextMetrics.measureText;
     (0, vitest_1.beforeEach)(() => {
         // Mock PIXI.TextMetrics.measureText to return predictable widths
-        PIXI.TextMetrics.measureText = vitest_1.vi.fn().mockImplementation((text, style) => ({
+        Pixi.TextMetrics.measureText = vitest_1.vi.fn().mockImplementation((text, style) => ({
             width: text.length * 10,
             height: style.fontSize,
             fontProperties: { ascent: +style.fontSize - 4, descent: 4 }
@@ -55,7 +55,7 @@ const MockPixiMeasureText = () => {
     });
     (0, vitest_1.afterEach)(() => {
         // Restore original implementation
-        PIXI.TextMetrics.measureText = ORIGINAL_MEASURE_TEXT;
+        Pixi.TextMetrics.measureText = OriginalMeasureText;
     });
 };
 exports.MockPixiMeasureText = MockPixiMeasureText;

package/dist/pixi/display-object/objects/text/rich-text.d.ts

@@ -15,6 +15,5 @@ export interface RichTextOptions {
     readonly verticalAlignment?: 'top' | 'center' | 'bottom';
 }
 export declare class RichText extends Container {
-    private readonly text;
     constructor(text: string, options: RichTextOptions);
 }

package/dist/pixi/display-object/objects/text/rich-text.js

@@ -7,7 +7,6 @@ const text_1 = require("./text");
 class RichText extends container_1.Container {
     constructor(text, options) {
         super();
-        this.text = text;
         let textData = helpers_1.RichTextToPlaneText.process(text, options);
         textData.forEach(textDatum => new text_1.Text(textDatum.text, textDatum.style).setPosition(textDatum.position).displayParent(this).attach(this));
     }

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

@@ -2,15 +2,14 @@ import { RGBColor, Vector } from 'helpers-lib';
 import { Container } from '../../container';
 import { PartialTextOptions } from './helpers/process-steps/1-data-in-converter/pixi-text-style-converter';
 export declare class Text extends Container {
-    private readonly partialOptions?;
-    private pixiText;
-    private strikethroughGraphics?;
-    private pixiTextStyle;
-    private text;
-    private _textMetrics?;
-    private get textMetrics();
+    private _pixiText;
+    private _strikethroughGraphics?;
+    private _pixiTextStyle;
+    private _text;
+    private _textMetricsVar?;
+    private get _textMetrics();
     get ascent(): number;
-    constructor(text: string, partialOptions?: PartialTextOptions | undefined);
+    constructor(text: string, partialOptions?: PartialTextOptions);
     destroy(): void;
     setAnchor(value: Vector): this;
     get anchor(): Vector;
@@ -21,6 +20,6 @@ export declare class Text extends Container {
     } | undefined): this;
     setText(text: string): this;
     setColor(color: RGBColor): this;
-    private regeneratePixiText;
-    private addStrikethroughToText;
+    private _regeneratePixiText;
+    private _addStrikethroughToText;
 }

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

@@ -25,32 +25,31 @@ var __importStar = (this && this.__importStar) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Text = void 0;
 const helpers_lib_1 = require("helpers-lib");
-const PIXI = __importStar(require("pixi.js"));
+const Pixi = __importStar(require("pixi.js"));
 const container_1 = require("../../container");
 const pixi_text_style_converter_1 = require("./helpers/process-steps/1-data-in-converter/pixi-text-style-converter");
 const FONT_SIZE_MULTIPLIER = 1;
 const FONT_SIZE_MULTIPLIER_INVERSE = 1 / FONT_SIZE_MULTIPLIER;
 class Text extends container_1.Container {
-    get textMetrics() {
-        if (!this._textMetrics) {
-            let pixiTextStyle = new PIXI.TextStyle(this.pixiTextStyle);
-            this._textMetrics = PIXI.TextMetrics.measureText(this.text, pixiTextStyle);
+    get _textMetrics() {
+        if (!this._textMetricsVar) {
+            let pixiTextStyle = new Pixi.TextStyle(this._pixiTextStyle);
+            this._textMetricsVar = Pixi.TextMetrics.measureText(this._text, pixiTextStyle);
         }
-        return this._textMetrics;
+        return this._textMetricsVar;
     }
     get ascent() {
-        return this.textMetrics.fontProperties.ascent;
+        return this._textMetrics.fontProperties.ascent;
     }
     constructor(text, partialOptions) {
         super();
-        this.partialOptions = partialOptions;
-        this.pixiTextStyle = pixi_text_style_converter_1.TextStyleConverter.getPixiTextStyle(partialOptions);
+        this._pixiTextStyle = pixi_text_style_converter_1.TextStyleConverter.getPixiTextStyle(partialOptions);
         this.setText(text);
     }
     destroy() {
         if (!this.destroyed) {
-            !this.pixiText.destroyed && this.pixiText.destroy();
             super.destroy();
+            !this._pixiText.destroyed && this._pixiText.destroy();
         }
     }
     setAnchor(value) {
@@ -58,14 +57,14 @@ class Text extends container_1.Container {
         return this;
     }
     get anchor() {
-        return new helpers_lib_1.Vector(this.pixiText.anchor.x, this.pixiText.anchor.y);
+        return new helpers_lib_1.Vector(this._pixiText.anchor.x, this._pixiText.anchor.y);
     }
     set anchor(value) {
-        this.pixiText.anchor.set(value.x, value.y);
+        this._pixiText.anchor.set(value.x, value.y);
     }
     setPosition(value, options) {
         if (options?.holdFrom) {
-            let blurDistance = this.pixiTextStyle.dropShadowDistance ?? 0;
+            let blurDistance = this._pixiTextStyle.dropShadowDistance ?? 0;
             let shadowOffset = new helpers_lib_1.Vector(options.holdFrom.x * blurDistance, options.holdFrom.y * blurDistance);
             value = value.add(shadowOffset);
         }
@@ -73,43 +72,43 @@ class Text extends container_1.Container {
         return this;
     }
     setText(text) {
-        if (this.text !== text) {
-            this.text = text;
-            this.regeneratePixiText();
+        if (this._text !== text) {
+            this._text = text;
+            this._regeneratePixiText();
         }
         return this;
     }
     setColor(color) {
         let colorHex = helpers_lib_1.ColorHelper.rgbToHex(color);
-        if (this.pixiTextStyle.fill !== colorHex) {
-            this.pixiTextStyle.fill = colorHex;
-            this.regeneratePixiText();
+        if (this._pixiTextStyle.fill !== colorHex) {
+            this._pixiTextStyle.fill = colorHex;
+            this._regeneratePixiText();
         }
         return this;
     }
-    regeneratePixiText() {
-        this.pixiText?.destroy();
-        this.strikethroughGraphics?.destroy();
-        this.strikethroughGraphics = undefined;
-        this._textMetrics = undefined;
-        let pixiTextStyle = new PIXI.TextStyle(this.pixiTextStyle);
-        this.pixiText = new PIXI.Text(this.text, pixiTextStyle);
-        this.pixiText.scale.set(FONT_SIZE_MULTIPLIER_INVERSE, FONT_SIZE_MULTIPLIER_INVERSE);
-        this.pixiContainer.addChild(this.pixiText);
-        if (this.pixiTextStyle.lineThrough) {
-            this.strikethroughGraphics = this.addStrikethroughToText(this.pixiText, this.pixiTextStyle.fill);
-            this.pixiContainer.addChild(this.strikethroughGraphics);
+    _regeneratePixiText() {
+        this._pixiText?.destroy();
+        this._strikethroughGraphics?.destroy();
+        this._strikethroughGraphics = undefined;
+        this._textMetricsVar = undefined;
+        let pixiTextStyle = new Pixi.TextStyle(this._pixiTextStyle);
+        this._pixiText = new Pixi.Text(this._text, pixiTextStyle);
+        this._pixiText.scale.set(FONT_SIZE_MULTIPLIER_INVERSE, FONT_SIZE_MULTIPLIER_INVERSE);
+        this.pixiContainer.addChild(this._pixiText);
+        if (this._pixiTextStyle.lineThrough) {
+            this._strikethroughGraphics = this._addStrikethroughToText(this._pixiText, this._pixiTextStyle.fill);
+            this.pixiContainer.addChild(this._strikethroughGraphics);
         }
     }
-    addStrikethroughToText(pixiText, lineColor) {
-        let textMetrics = PIXI.TextMetrics.measureText(pixiText.text, pixiText.style);
+    _addStrikethroughToText(pixiText, lineColor) {
+        let textMetrics = Pixi.TextMetrics.measureText(pixiText.text, pixiText.style);
         let lineThickness = Math.max(1, Math.round(textMetrics.lineHeight * 0.07));
         let lineOffset = (lineThickness % 2) * 0.5;
-        let strikethroughGraphics = new PIXI.Graphics();
+        let strikethroughGraphics = new Pixi.Graphics();
         strikethroughGraphics.lineStyle(lineThickness, lineColor);
         let currentY = 0;
         textMetrics.lines.forEach((line, index) => {
-            let lineMetrics = PIXI.TextMetrics.measureText(line, pixiText.style);
+            let lineMetrics = Pixi.TextMetrics.measureText(line, pixiText.style);
             let lineY = Math.round(currentY +
                 (lineMetrics.fontProperties.ascent - lineMetrics.fontProperties.descent) * 0.6 +
                 lineMetrics.fontProperties.descent) + lineOffset;

package/dist/pixi/game.d.ts

@@ -1,16 +1,20 @@
 import { Reducer, Variable } from 'actions-lib';
 import { RGBColor, Vector } from 'helpers-lib';
-import * as PIXI from 'pixi.js';
-import { AssetDefinition, Container } from '.';
+import * as Pixi from 'pixi.js';
+import { Container } from './display-object/container';
 import { Camera } from './modules/CAMERA/camera';
-export declare const DEFAULT_RESOLUTION = 2;
+import { AssetDefinition, SpriteDefinition } from './pixi-definitions';
 export interface GameConfiguration {
-    screenResolution?: {
-        width: number;
-        height: number;
+    readonly screenResolution?: {
+        readonly width: number;
+        readonly height: number;
     };
-    devMode?: boolean;
-    backgroundColor?: RGBColor;
+    readonly devMode: boolean;
+    readonly backgroundColor: RGBColor;
+}
+export interface GameSetupOptions {
+    readonly assetDefinitions: readonly AssetDefinition<string>[];
+    readonly spriteDefinitions: Readonly<Record<string, SpriteDefinition>>;
 }
 export declare class Game {
     private static _instance;
@@ -19,8 +23,9 @@ export declare class Game {
     private static _camera;
     static get camera(): Camera;
     static get time(): number;
+    private static _setupOptions;
     readonly stage: Container;
-    readonly renderer: PIXI.Renderer;
+    readonly renderer: Pixi.Renderer;
     readonly _screenSize: Variable<Vector>;
     readonly screenSize: import("actions-lib").Notifier<Vector>;
     getScreenSize(): Vector;
@@ -28,15 +33,15 @@ export declare class Game {
     readonly screenSizeCenter: import("actions-lib").Notifier<Vector>;
     getScreenSizeCenter(): Vector;
     readonly devMode: boolean;
-    private readonly pixiApp;
-    private readonly configuration;
-    private screenPositionToStagePositionConverter;
+    private readonly _pixiApp;
+    private readonly _configuration;
+    private _screenPositionToStagePositionConverter;
     constructor(partialConfiguration?: Partial<GameConfiguration>);
-    setup(assetDefinitions: readonly AssetDefinition<string>[]): Promise<void>;
+    setup(setupOptions: GameSetupOptions): Promise<void>;
     setResolution(resolution: number): void;
     screenPositonToStagePosition(screenPosition: Vector): Vector;
     setScreenPositionToStagePositionFunction(converterFunction: (screenPosition: Vector) => Vector): void;
     resetScreenPositionToStagePositionFunction(): void;
-    destroyAsset(assetId: string): void;
-    private setScreenSize;
+    destroyAsset(assetID: string): void;
+    private _setScreenSize;
 }

package/dist/pixi/game.js

@@ -23,16 +23,16 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Game = exports.DEFAULT_RESOLUTION = void 0;
+exports.Game = void 0;
 const actions_lib_1 = require("actions-lib");
 const helpers_lib_1 = require("helpers-lib");
-const PIXI = __importStar(require("pixi.js"));
+const Pixi = __importStar(require("pixi.js"));
 const update_cycle_1 = require("../game-entities/update-cycle");
-const _1 = require(".");
+const container_1 = require("./display-object/container");
 const game_assets_1 = require("./helpers/game-assets");
 const position_conversion_helper_1 = require("./helpers/position-conversion.helper");
 const camera_1 = require("./modules/CAMERA/camera");
-exports.DEFAULT_RESOLUTION = 2;
+const pixi_definitions_1 = require("./pixi-definitions");
 class Game {
     static get instance() {
         return this._instance;
@@ -42,7 +42,11 @@ class Game {
         return this._camera;
     }
     static get time() {
-        return update_cycle_1.UpdateCycle['time'];
+        return update_cycle_1.UpdateCycle._time;
+    }
+    /** @internal */
+    static get setupOptions() {
+        return this._setupOptions;
     }
     getScreenSize() {
         return this._screenSize.value;
@@ -61,69 +65,70 @@ class Game {
             throw new Error('There can be only one Game instance!');
         }
         else {
-            this.configuration = {
+            this._configuration = {
                 screenResolution: undefined,
                 devMode: false,
                 backgroundColor: helpers_lib_1.ColorHelper.black,
                 ...partialConfiguration
             };
-            this.devMode = this.configuration.devMode || false;
-            this.pixiApp = new PIXI.Application({
-                backgroundColor: this.configuration.backgroundColor,
+            this.devMode = this._configuration.devMode || false;
+            this._pixiApp = new Pixi.Application({
+                backgroundColor: this._configuration.backgroundColor,
                 autoStart: false,
-                antialias: exports.DEFAULT_RESOLUTION < 1.5,
-                resolution: exports.DEFAULT_RESOLUTION,
-                width: this.configuration.screenResolution?.width,
-                height: this.configuration.screenResolution?.height,
-                resizeTo: this.configuration.screenResolution === undefined ? window : undefined
+                antialias: pixi_definitions_1.DEFAULT_RESOLUTION < 1.5,
+                resolution: pixi_definitions_1.DEFAULT_RESOLUTION,
+                width: this._configuration.screenResolution?.width,
+                height: this._configuration.screenResolution?.height,
+                resizeTo: this._configuration.screenResolution === undefined ? window : undefined
             });
         }
     }
-    async setup(assetDefinitions) {
-        document.body.appendChild(this.pixiApp.view);
-        await Promise.all([game_assets_1.GameAssets.loadGameAssets(assetDefinitions)]);
+    async setup(setupOptions) {
+        Game._setupOptions = setupOptions;
+        document.body.appendChild(this._pixiApp.view);
+        await Promise.all([game_assets_1.GameAssets.loadGameAssets(setupOptions.assetDefinitions)]);
         Game._instance = this;
         // @ts-ignore
-        this.stage = new _1.Container().attachToRoot();
+        this.stage = new container_1.Container().attachToRoot();
         // @ts-ignore
-        this.stage.pixiContainer = this.pixiApp.stage;
+        this.stage.pixiContainer = this._pixiApp.stage;
         // @ts-ignore
-        this.renderer = this.pixiApp.renderer;
-        this.setScreenSize();
+        this.renderer = this._pixiApp.renderer;
+        this._setScreenSize();
         this.stage.sortableChildren = true;
         // pixi devtools configuration
         // @ts-ignore
-        globalThis.__PIXI_APP__ = this.pixiApp;
+        globalThis.__PIXI_APP__ = this._pixiApp;
         window.addEventListener('resize', _ => {
             // Wait until pixijs adjusts the screen size
-            setTimeout(() => this.setScreenSize());
+            setTimeout(() => this._setScreenSize());
         });
         Game._camera = new camera_1.Camera();
         // Reminder: If the game should be paused or destroyed, all promises has to be resolved, that relies on update cycle
-        this.pixiApp.start();
-        this.pixiApp.ticker.add(() => {
-            update_cycle_1.UpdateCycle.triggerUpdateTick(this.pixiApp.ticker.deltaMS);
+        this._pixiApp.start();
+        this._pixiApp.ticker.add(() => {
+            update_cycle_1.UpdateCycle.triggerUpdateTick(this._pixiApp.ticker.deltaMS);
         });
     }
     setResolution(resolution) {
-        this.pixiApp.renderer.resolution = resolution;
-        this.pixiApp.renderer.resize(this.pixiApp.screen.width, this.pixiApp.screen.height);
+        this._pixiApp.renderer.resolution = resolution;
+        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.getScreenSizeCenter());
-        return this.screenPositionToStagePositionConverter(adjustedScreenPositionWithScale);
+        return this._screenPositionToStagePositionConverter(adjustedScreenPositionWithScale);
     }
     setScreenPositionToStagePositionFunction(converterFunction) {
-        this.screenPositionToStagePositionConverter = converterFunction;
+        this._screenPositionToStagePositionConverter = converterFunction;
     }
     resetScreenPositionToStagePositionFunction() {
-        this.screenPositionToStagePositionConverter = (screenPosition) => screenPosition;
+        this._screenPositionToStagePositionConverter = (screenPosition) => screenPosition;
     }
-    destroyAsset(assetId) {
-        game_assets_1.GameAssets.destroyAsset(assetId);
+    destroyAsset(assetID) {
+        game_assets_1.GameAssets.destroyAsset(assetID);
     }
-    setScreenSize() {
-        let screenSize = new helpers_lib_1.Vector(this.pixiApp.screen.width, this.pixiApp.screen.height);
+    _setScreenSize() {
+        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();
     }

package/dist/pixi/helpers/game-assets.d.ts

@@ -1,15 +1,15 @@
-import * as PIXI from 'pixi.js';
-import { AssetDefinition } from '..';
+import * as Pixi from 'pixi.js';
+import { AssetDefinition } from '../pixi-definitions';
 declare module 'pixi.js' {
     interface Texture {
         id: string;
     }
 }
 export declare class GameAssets {
-    private static resources;
-    private static anonymouseAssetNameCounter;
+    private static _resources;
+    private static _anonymouseAssetNameCounter;
     static getAsset<T>(name: string): T;
-    static insertAsset(asset: PIXI.Texture, name?: string): string;
+    static insertAsset(asset: Pixi.Texture, name?: string): string;
     static destroyAsset(name: string): void;
     static loadGameAssets(assetDefinitions: readonly AssetDefinition[]): Promise<void>;
 }

package/dist/pixi/helpers/game-assets.js

@@ -25,12 +25,12 @@ var __importStar = (this && this.__importStar) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GameAssets = void 0;
 const helpers_lib_1 = require("helpers-lib");
-const PIXI = __importStar(require("pixi.js"));
+const Pixi = __importStar(require("pixi.js"));
 class GameAssets {
-    static { this.resources = new Map(); }
-    static { this.anonymouseAssetNameCounter = 0; }
+    static { this._resources = new Map(); }
+    static { this._anonymouseAssetNameCounter = 0; }
     static getAsset(name) {
-        let resource = this.resources.get(name);
+        let resource = this._resources.get(name);
         if (resource) {
             return resource;
         }
@@ -40,14 +40,17 @@ class GameAssets {
     }
     static insertAsset(asset, name) {
         if (!name) {
-            name = `anonymous-${this.anonymouseAssetNameCounter++}`;
+            name = `a-${this._anonymouseAssetNameCounter++}`;
         }
-        this.resources.set(name, asset);
+        this._resources.set(name, asset);
         return name;
     }
     static destroyAsset(name) {
-        this.resources.get(name)?.destroy();
-        this.resources.delete(name);
+        let resource = this._resources.get(name);
+        if (resource) {
+            resource.destroy(true);
+            this._resources.delete(name);
+        }
     }
     static async loadGameAssets(assetDefinitions) {
         let urlToNameGroup = new Map();
@@ -65,13 +68,13 @@ class GameAssets {
                 assetsToLoad.push({
                     url: definition.url,
                     callback: (asset) => {
-                        if (asset instanceof PIXI.Texture) {
+                        if (asset instanceof Pixi.Texture) {
                             asset.id = definition.id;
                         }
                         nameGroup = urlToNameGroup.get(definition.url);
                         if (nameGroup) {
                             nameGroup.forEach(name => {
-                                this.resources.set(name, asset);
+                                this._resources.set(name, asset);
                             });
                         }
                         else {
@@ -82,7 +85,7 @@ class GameAssets {
             }
         });
         let timeStart = performance.now();
-        return Promise.all(assetsToLoad.map(asset => PIXI.Assets.load(asset.url)))
+        return Promise.all(assetsToLoad.map(asset => Pixi.Assets.load(asset.url)))
             .then(resources => {
             let timeEnd = performance.now();
             console.info('Asset load completed in: ', Math.round(timeEnd - timeStart) / 1000, ' seconds');

package/dist/pixi/helpers/position-conversion.helper.d.ts

@@ -1,12 +1,12 @@
 import { Vector } from 'helpers-lib';
-import * as PIXI from 'pixi.js';
-import { PolygonDefinition } from '..';
+import * as Pixi from 'pixi.js';
+import { PolygonDefinition } from '../pixi-definitions';
 export declare class PositionConversionHelper {
     static includeScaleInScreenPosition(screenPosition: Vector, gameInstanceScale: number, screenSizeCenter: Vector): Vector;
     static normalizePolygonByAnchor(polygon: PolygonDefinition, frameSize: Vector, frameAnchor: Vector): PolygonDefinition;
 }
-export declare class CompositeHitArea implements PIXI.IHitArea {
-    private shapes;
+export declare class CompositeHitArea implements Pixi.IHitArea {
+    private _shapes;
     constructor(polygonDefinition: PolygonDefinition, size: Vector, anchor: Vector);
     contains(x: number, y: number): boolean;
 }