bard-legends-framework 0.10.3 → 0.10.5

package/dist/game-entities/scene/scene.d.ts

@@ -1,10 +1,11 @@
+import { Variable } from 'actions-lib';
 import { Attachable } from '../base/attachable';
 export type SceneClassType = new (...services: any[]) => Scene<any>;
 export declare function SceneDecorator(): (SceneClass: SceneClassType) => any;
 export declare abstract class Scene<InputType> extends Attachable {
     private static sceneInstance?;
     private static sceneTransitioning;
-    static get activeScene(): Scene<any> | undefined;
+    static activeScene: Variable<Scene<any> | undefined>;
     static getActiveSceneOrFail(): Scene<any>;
     static isActive<T extends Scene<any>>(this: new (...args: any[]) => T): boolean;
     static getInstance<T extends Scene<any>>(this: new (...args: any[]) => T): T | undefined;

package/dist/game-entities/scene/scene.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Scene = exports.SceneDecorator = void 0;
+const actions_lib_1 = require("actions-lib");
 const attachable_1 = require("../base/attachable");
 const service_1 = require("../service/service");
 const update_cycle_1 = require("../update-cycle");
@@ -16,9 +17,7 @@ function SceneDecorator() {
 exports.SceneDecorator = SceneDecorator;
 class Scene extends attachable_1.Attachable {
     static { this.sceneTransitioning = false; }
-    static get activeScene() {
-        return Scene.sceneInstance;
-    }
+    static { this.activeScene = new actions_lib_1.Variable(); }
     static getActiveSceneOrFail() {
         if (!Scene.sceneInstance) {
             throw new Error(`Scene: getActiveSceneOrFail is called when there is no active scene!`);
@@ -47,10 +46,12 @@ class Scene extends attachable_1.Attachable {
                 await Scene.sceneInstance.prepareToClose();
                 Scene.sceneInstance.destroy();
                 Scene.sceneInstance = undefined;
+                Scene.activeScene.set(undefined);
             }
             let resolvedArgs = service_1.Service.resolveParameters([], this.$meta.paramtypes);
             let scene = new this(...resolvedArgs);
             Scene.sceneInstance = scene;
+            Scene.activeScene.set(scene);
             await scene.init(input);
             Scene.sceneTransitioning = false;
         }
@@ -60,6 +61,7 @@ class Scene extends attachable_1.Attachable {
             await Scene.sceneInstance.prepareToClose();
             Scene.sceneInstance.destroy();
             Scene.sceneInstance = undefined;
+            Scene.activeScene.set(undefined);
         }
     }
     constructor() {

package/dist/game-entities/scene/scene.test.js

@@ -53,8 +53,8 @@ decorate_actions_lib_1.ActionsLibDecorator.decorate(ActionsLib);
             (0, scene_1.SceneDecorator)()
         ], SampleScene);
         SampleScene.open(undefined);
-        (0, vitest_1.expect)(scene_1.Scene.activeScene).toBeDefined();
-        (0, vitest_1.expect)(scene_1.Scene.activeScene).toBeInstanceOf(SampleScene);
+        (0, vitest_1.expect)(scene_1.Scene.activeScene.value).toBeDefined();
+        (0, vitest_1.expect)(scene_1.Scene.activeScene.value).toBeInstanceOf(SampleScene);
     });
     (0, vitest_1.test)('arguments in open call should be passed to the init function', () => {
         let SampleScene = class SampleScene extends scene_1.Scene {
@@ -114,7 +114,7 @@ decorate_actions_lib_1.ActionsLibDecorator.decorate(ActionsLib);
         (0, vitest_1.expect)(SampleScene1.destroyCalled).toBeFalsy();
         SampleScene2.open(undefined);
         await update_cycle_1.UpdateCycle.triggerUpdateTick(1); // Update cycle should take place to destroy functions to be called
-        (0, vitest_1.expect)(scene_1.Scene.activeScene).toBeInstanceOf(SampleScene2);
+        (0, vitest_1.expect)(scene_1.Scene.activeScene.value).toBeInstanceOf(SampleScene2);
         (0, vitest_1.expect)(SampleScene1.destroyCalled).toBeTruthy();
     });
     (0, vitest_1.test)('get instance should return the scene with its type', () => {

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

@@ -15,11 +15,15 @@ export interface TextOptions {
     readonly fontStyle: 'normal' | 'italic' | 'oblique';
     readonly lineHeight: number | undefined;
     readonly dropShadow: DropShadowOptions | undefined;
-    readonly wordWrapWidth?: number;
+    readonly wordWrapWidth: number | undefined;
+    readonly lineThrough: boolean;
 }
 export type PartialTextOptions = Partial<Omit<TextOptions, 'dropShadow'>> & {
     dropShadow?: Partial<DropShadowOptions> | true;
 };
-export declare class PixiTextStyleConverter {
-    static getPixiTextStyle(partialOptions?: PartialTextOptions): Partial<PIXI.ITextStyle>;
+export interface ExtendedPixiTextStyle extends Partial<PIXI.ITextStyle> {
+    readonly lineThrough: boolean;
+}
+export declare class TextStyleConverter {
+    static getPixiTextStyle(partialOptions?: PartialTextOptions): ExtendedPixiTextStyle;
 }

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

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PixiTextStyleConverter = void 0;
+exports.TextStyleConverter = void 0;
 const helpers_lib_1 = require("helpers-lib");
-class PixiTextStyleConverter {
+class TextStyleConverter {
     static getPixiTextStyle(partialOptions) {
         let options = {
             color: helpers_lib_1.ColorHelper.white,
@@ -11,6 +11,8 @@ class PixiTextStyleConverter {
             fontStyle: 'normal',
             fontSize: 18,
             lineHeight: undefined,
+            wordWrapWidth: undefined,
+            lineThrough: false,
             ...partialOptions
         };
         let partialDropShadowOptions = partialOptions?.dropShadow === true ? {} : partialOptions?.dropShadow;
@@ -42,9 +44,10 @@ class PixiTextStyleConverter {
             lineHeight: options.lineHeight,
             wordWrapWidth: options.wordWrapWidth,
             wordWrap: options.wordWrapWidth !== undefined,
+            lineThrough: options.lineThrough,
             ...shadowOptions
         };
     }
 }
-exports.PixiTextStyleConverter = PixiTextStyleConverter;
+exports.TextStyleConverter = TextStyleConverter;
 //# sourceMappingURL=pixi-text-style-converter.js.map

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

@@ -1,12 +1,11 @@
-import * as PIXI from 'pixi.js';
 import { RichTextOptions } from '../../../rich-text';
 import { ChunkData } from '../../rich-text-to-plane-text';
-import { PartialTextOptions } from './pixi-text-style-converter';
+import { ExtendedPixiTextStyle, PartialTextOptions } from './pixi-text-style-converter';
 export interface TagsWithStyles {
     readonly text: string;
     readonly cacheKey: string;
     readonly style: PartialTextOptions;
-    readonly pixiStyle: PIXI.TextStyle;
+    readonly pixiStyle: ExtendedPixiTextStyle;
     readonly spaceWidth: number;
 }
 export declare class RichTextDataInConverter {

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

@@ -43,14 +43,14 @@ class RichTextDataInConverter {
             if (pixiStyleCache.has(cacheKey)) {
                 return pixiStyleCache.get(cacheKey);
             }
-            let pixiStyle = new PIXI.TextStyle(pixi_text_style_converter_1.PixiTextStyleConverter.getPixiTextStyle(style));
+            let pixiStyle = pixi_text_style_converter_1.TextStyleConverter.getPixiTextStyle(style);
             pixiStyleCache.set(cacheKey, pixiStyle);
             return pixiStyle;
         };
         let tagsWithStyles = textSegments.map(segment => {
             let { style, cacheKey } = this.getCombinedStyle(segment.tags, options, styleCache);
             let pixiStyle = GetPixiStyle(style, cacheKey);
-            let spaceMeasurement = PIXI.TextMetrics.measureText(' ', pixiStyle, false);
+            let spaceMeasurement = PIXI.TextMetrics.measureText(' ', new PIXI.TextStyle(pixiStyle), false);
             let data = {
                 text: segment.text,
                 cacheKey,
@@ -112,14 +112,15 @@ class RichTextDataInConverter {
             let chunkData = line.flatMap(data => {
                 let chunkStrings = this.splitToChunks(data.text);
                 return chunkStrings.map(chunkString => {
-                    let metrics = PIXI.TextMetrics.measureText(chunkString, data.pixiStyle, false);
+                    let pixiStyle = new PIXI.TextStyle(data.pixiStyle);
+                    let metrics = PIXI.TextMetrics.measureText(chunkString, pixiStyle, false);
                     let chunkDatum = {
                         text: chunkString,
                         whitespace: chunkString.trim() === '',
                         style: {
                             cacheKey: data.cacheKey,
                             style: data.style,
-                            pixiStyle: data.pixiStyle,
+                            pixiStyle,
                             height: metrics.height,
                             ascent: metrics.fontProperties.ascent,
                             descent: metrics.fontProperties.descent,

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

@@ -1,29 +1,5 @@
 "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 });
-const PIXI = __importStar(require("pixi.js"));
 const script_engine_lib_1 = require("script-engine-lib");
 const vitest_1 = require("vitest");
 const rich_text_to_plane_text_test_1 = require("../../rich-text-to-plane-text.test");
@@ -47,11 +23,11 @@ const ExpectedResults = {
     'style1+style2': { fontFamily: 'Arial', color: Style2Color, fontSize: 22, lineHeight: 25 }
 };
 const ExpectedPixiStyles = {
-    empty: new PIXI.TextStyle(pixi_text_style_converter_1.PixiTextStyleConverter.getPixiTextStyle({})),
-    default: new PIXI.TextStyle(pixi_text_style_converter_1.PixiTextStyleConverter.getPixiTextStyle(ExpectedResults.default)),
-    style1: new PIXI.TextStyle(pixi_text_style_converter_1.PixiTextStyleConverter.getPixiTextStyle(ExpectedResults.style1)),
-    style2: new PIXI.TextStyle(pixi_text_style_converter_1.PixiTextStyleConverter.getPixiTextStyle(ExpectedResults.style2)),
-    'style1+style2': new PIXI.TextStyle(pixi_text_style_converter_1.PixiTextStyleConverter.getPixiTextStyle(ExpectedResults['style1+style2']))
+    empty: pixi_text_style_converter_1.TextStyleConverter.getPixiTextStyle({}),
+    default: pixi_text_style_converter_1.TextStyleConverter.getPixiTextStyle(ExpectedResults.default),
+    style1: pixi_text_style_converter_1.TextStyleConverter.getPixiTextStyle(ExpectedResults.style1),
+    style2: pixi_text_style_converter_1.TextStyleConverter.getPixiTextStyle(ExpectedResults.style2),
+    'style1+style2': pixi_text_style_converter_1.TextStyleConverter.getPixiTextStyle(ExpectedResults['style1+style2'])
 };
 (0, vitest_1.describe)('RichTextDataInConverter', () => {
     (0, rich_text_to_plane_text_test_1.MockPixiMeasureText)();
@@ -242,9 +218,9 @@ const ExpectedPixiStyles = {
             b: { fontSize: 14 }
         };
         const PixiStyles = {
-            default: new PIXI.TextStyle(pixi_text_style_converter_1.PixiTextStyleConverter.getPixiTextStyle(mockStyles.default)),
-            red: new PIXI.TextStyle(pixi_text_style_converter_1.PixiTextStyleConverter.getPixiTextStyle(mockStyles.red)),
-            b: new PIXI.TextStyle(pixi_text_style_converter_1.PixiTextStyleConverter.getPixiTextStyle(mockStyles.b))
+            default: pixi_text_style_converter_1.TextStyleConverter.getPixiTextStyle(mockStyles.default),
+            red: pixi_text_style_converter_1.TextStyleConverter.getPixiTextStyle(mockStyles.red),
+            b: pixi_text_style_converter_1.TextStyleConverter.getPixiTextStyle(mockStyles.b)
         };
         const GetTagsWithStyles = (text, style = 'default') => {
             let result = {

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

@@ -34,7 +34,7 @@ const CreateSampleChunkData = (text, options) => ({
     style: {
         cacheKey: JSON.stringify(options) ?? 'empty',
         style: { fontSize: options?.fontSize ?? 16, fontFamily: 'Arial' },
-        pixiStyle: { 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,

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

@@ -2,13 +2,15 @@ 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 style;
+    private strikethroughGraphics?;
+    private pixiTextStyle;
     private text;
     private _textMetrics?;
     private get textMetrics();
     get ascent(): number;
-    constructor(text: string, partialOptions?: PartialTextOptions);
+    constructor(text: string, partialOptions?: PartialTextOptions | undefined);
     protected destroySelf(): void;
     setAnchor(value: Vector): this;
     get anchor(): Vector;
@@ -20,4 +22,5 @@ export declare class Text extends Container {
     setText(text: string): this;
     setColor(color: RGBColor): this;
     private regeneratePixiText;
+    private addStrikethroughToText;
 }

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

@@ -33,7 +33,7 @@ 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.style);
+            let pixiTextStyle = new PIXI.TextStyle(this.pixiTextStyle);
             this._textMetrics = PIXI.TextMetrics.measureText(this.text, pixiTextStyle);
         }
         return this._textMetrics;
@@ -43,7 +43,8 @@ class Text extends container_1.Container {
     }
     constructor(text, partialOptions) {
         super();
-        this.style = pixi_text_style_converter_1.PixiTextStyleConverter.getPixiTextStyle(partialOptions);
+        this.partialOptions = partialOptions;
+        this.pixiTextStyle = pixi_text_style_converter_1.TextStyleConverter.getPixiTextStyle(partialOptions);
         this.setText(text);
     }
     destroySelf() {
@@ -62,7 +63,7 @@ class Text extends container_1.Container {
     }
     setPosition(value, options) {
         if (options?.holdFrom) {
-            let blurDistance = this.style.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);
         }
@@ -78,19 +79,52 @@ class Text extends container_1.Container {
     }
     setColor(color) {
         let colorHex = helpers_lib_1.ColorHelper.rgbToHex(color);
-        if (this.style.fill !== colorHex) {
-            this.style.fill = colorHex;
+        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.style);
+        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);
+        let lineThickness = Math.max(1, Math.round(textMetrics.lineHeight * 0.07));
+        let lineOffset = (lineThickness % 2) * 0.5;
+        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 lineY = Math.round(currentY +
+                (lineMetrics.fontProperties.ascent - lineMetrics.fontProperties.descent) * 0.6 +
+                lineMetrics.fontProperties.descent) + lineOffset;
+            let lineX = 0;
+            if (pixiText.style.align === 'center') {
+                lineX = 0 + (pixiText.width - lineMetrics.width) * 0.5;
+            }
+            else if (pixiText.style.align === 'right') {
+                lineX = 0 + pixiText.width - lineMetrics.width;
+            }
+            lineX = Math.floor(lineX);
+            strikethroughGraphics.moveTo(Math.floor(lineX), lineY);
+            strikethroughGraphics.lineTo(Math.floor(lineX + lineMetrics.width), lineY);
+            currentY += lineMetrics.lineHeight;
+        });
+        strikethroughGraphics.endFill();
+        return strikethroughGraphics;
     }
 }
 exports.Text = Text;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bard-legends-framework",
-  "version": "0.10.3",
+  "version": "0.10.5",
   "description": "Bard Legends Framework",
   "main": "dist/index.js",
   "files": [