bard-legends-framework 0.9.6 → 0.9.7

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

@@ -1,213 +1,229 @@
-"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) {
+var __createBinding =
+  (this && this.__createBinding) ||
+  (Object.create
+    ? (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: () => m[k] };
+        }
+        Object.defineProperty(o, k2, desc);
+      }
+    : (o, m, k, k2) => {
+        if (k2 === undefined) k2 = k;
+        o[k2] = m[k];
+      });
+var __setModuleDefault =
+  (this && this.__setModuleDefault) ||
+  (Object.create
+    ? (o, v) => {
+        Object.defineProperty(o, 'default', { enumerable: true, value: v });
+      }
+    : (o, v) => {
+        o['default'] = v;
+      });
+var __importStar =
+  (this && this.__importStar) ||
+  (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);
+    if (mod != null) for (var k in mod) if (k !== 'default' && Object.hasOwn(mod, k)) __createBinding(result, mod, k);
     __setModuleDefault(result, mod);
     return result;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
+  });
+Object.defineProperty(exports, '__esModule', { value: true });
 exports.Graphics = void 0;
-const helpers_lib_1 = require("helpers-lib");
-const PIXI = __importStar(require("pixi.js"));
-const __1 = require("../..");
-const game_1 = require("../../game");
-const game_assets_1 = require("../../helpers/game-assets");
-const container_attributes_1 = require("../container-attributes");
+const helpers_lib_1 = require('helpers-lib');
+const PIXI = __importStar(require('pixi.js'));
+const __1 = require('../..');
+const game_1 = require('../../game');
+const game_assets_1 = require('../../helpers/game-assets');
+const container_attributes_1 = require('../container-attributes');
 class Graphics extends container_attributes_1.ContainerAttributes {
-    static { this.drawnTextureCache = new Map(); }
-    static createArrow(size, color) {
-        let pixiGraphics = new PIXI.Graphics();
-        let polygon = [
-            [
-                { x: 0, y: -size / 2 },
-                { x: (size * 3) / 8, y: -size / 8 },
-                { x: size / 4, y: 0 },
-                { x: 0, y: -size / 4 },
-                { x: -size / 4, y: 0 },
-                { x: (-size * 3) / 8, y: -size / 8 }
-            ],
-            [
-                { x: 0, y: -size / 4 },
-                { x: size / 8 - size / 30, y: -size / 8 - size / 30 },
-                { x: size / 8 - size / 30, y: (size * 7) / 16 },
-                { x: -size / 8 + size / 30, y: (size * 7) / 16 },
-                { x: -size / 8 + size / 30, y: -size / 8 - size / 30 }
-            ]
-        ];
-        pixiGraphics.beginFill(color);
-        polygon.forEach(vertices => {
-            pixiGraphics.drawPolygon(vertices.map(vertex => new PIXI.Point(vertex.x, vertex.y)));
-        });
-        pixiGraphics.endFill();
-        return new Graphics(pixiGraphics, JSON.stringify({ type: 'arrow', size, color }));
-    }
-    static createDashedLine(from, to, partialOptions) {
-        let options = {
-            width: 2,
-            dashLength: 10,
-            dashGap: 4,
-            lineStartGap: 0,
-            lineEndGap: 0,
-            color: helpers_lib_1.ColorHelper.white,
-            ...partialOptions
-        };
-        let pixiGraphics = new PIXI.Graphics();
-        pixiGraphics.lineStyle(options.width, options.color);
-        let fromTo = helpers_lib_1.Vector.fromTo(from, to);
-        let direction = fromTo.normalize();
-        let totalDistance = fromTo.length;
-        let availableDistance = totalDistance - options.lineStartGap - options.lineEndGap;
-        if (availableDistance > 0) {
-            let dashCycle = options.dashLength + options.dashGap;
-            let dashCount = Math.floor(availableDistance / dashCycle);
-            let penPosition = from.add(direction.normalize(options.lineStartGap));
-            for (let i = 0; i < dashCount; i++) {
-                let drawTo = penPosition.add(direction.normalize(options.dashLength));
-                pixiGraphics.moveTo(penPosition.x, penPosition.y).lineTo(drawTo.x, drawTo.y);
-                penPosition = drawTo.add(direction.normalize(options.dashGap));
-            }
-            let remainingDistance = totalDistance - options.lineEndGap - helpers_lib_1.Vector.fromTo(from, penPosition).length;
-            if (remainingDistance > 0) {
-                let drawTo = penPosition.add(direction.normalize(remainingDistance));
-                pixiGraphics.moveTo(penPosition.x, penPosition.y).lineTo(drawTo.x, drawTo.y);
-            }
-        }
-        return new Graphics(pixiGraphics, JSON.stringify({ type: 'dashedLine', from, to, options }));
-    }
-    static createVector(from, to, color) {
-        let pixiGraphics = new PIXI.Graphics();
-        pixiGraphics.lineStyle(2, color);
-        pixiGraphics.moveTo(from.x, from.y);
-        pixiGraphics.lineTo(to.x, to.y);
-        pixiGraphics.lineStyle(1, color);
-        pixiGraphics.beginFill(helpers_lib_1.ColorHelper.white);
-        pixiGraphics.drawCircle(from.x, from.y, 3);
-        pixiGraphics.endFill();
-        return new Graphics(pixiGraphics, JSON.stringify({ type: 'line', start: from, end: to, color }));
-    }
-    static createRectangleBorders(size, borderSize, color) {
-        let pixiGraphics = new PIXI.Graphics();
-        pixiGraphics.beginFill(color);
-        pixiGraphics.drawRect(0, 0, size.x, borderSize);
-        pixiGraphics.drawRect(0, borderSize, borderSize, size.y - borderSize * 2);
-        pixiGraphics.drawRect(size.x - borderSize, borderSize, borderSize, size.y - borderSize * 2);
-        pixiGraphics.drawRect(0, size.y - borderSize, size.x, borderSize);
-        pixiGraphics.endFill();
-        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();
-        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();
-        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();
-        pixiGraphics.beginFill(color);
-        pixiGraphics.drawEllipse(0, 0, size.x, size.y);
-        pixiGraphics.endFill();
-        return new Graphics(pixiGraphics, JSON.stringify({ type: 'elipse', size, color }));
+  static {
+    Graphics.drawnTextureCache = new Map();
+  }
+  static createArrow(size, color) {
+    const pixiGraphics = new PIXI.Graphics();
+    const polygon = [
+      [
+        { x: 0, y: -size / 2 },
+        { x: (size * 3) / 8, y: -size / 8 },
+        { x: size / 4, y: 0 },
+        { x: 0, y: -size / 4 },
+        { x: -size / 4, y: 0 },
+        { x: (-size * 3) / 8, y: -size / 8 }
+      ],
+      [
+        { x: 0, y: -size / 4 },
+        { x: size / 8 - size / 30, y: -size / 8 - size / 30 },
+        { x: size / 8 - size / 30, y: (size * 7) / 16 },
+        { x: -size / 8 + size / 30, y: (size * 7) / 16 },
+        { x: -size / 8 + size / 30, y: -size / 8 - size / 30 }
+      ]
+    ];
+    pixiGraphics.beginFill(color);
+    polygon.forEach(vertices => {
+      pixiGraphics.drawPolygon(vertices.map(vertex => new PIXI.Point(vertex.x, vertex.y)));
+    });
+    pixiGraphics.endFill();
+    return new Graphics(pixiGraphics, JSON.stringify({ type: 'arrow', size, color }));
+  }
+  static createDashedLine(from, to, partialOptions) {
+    const options = {
+      width: 2,
+      dashLength: 10,
+      dashGap: 4,
+      lineStartGap: 0,
+      lineEndGap: 0,
+      color: helpers_lib_1.ColorHelper.white,
+      ...partialOptions
+    };
+    const pixiGraphics = new PIXI.Graphics();
+    pixiGraphics.lineStyle(options.width, options.color);
+    const fromTo = helpers_lib_1.Vector.fromTo(from, to);
+    const direction = fromTo.normalize();
+    const totalDistance = fromTo.length;
+    const availableDistance = totalDistance - options.lineStartGap - options.lineEndGap;
+    if (availableDistance > 0) {
+      const dashCycle = options.dashLength + options.dashGap;
+      const dashCount = Math.floor(availableDistance / dashCycle);
+      let penPosition = from.add(direction.normalize(options.lineStartGap));
+      for (let i = 0; i < dashCount; i++) {
+        const drawTo = penPosition.add(direction.normalize(options.dashLength));
+        pixiGraphics.moveTo(penPosition.x, penPosition.y).lineTo(drawTo.x, drawTo.y);
+        penPosition = drawTo.add(direction.normalize(options.dashGap));
+      }
+      const remainingDistance = totalDistance - options.lineEndGap - helpers_lib_1.Vector.fromTo(from, penPosition).length;
+      if (remainingDistance > 0) {
+        const drawTo = penPosition.add(direction.normalize(remainingDistance));
+        pixiGraphics.moveTo(penPosition.x, penPosition.y).lineTo(drawTo.x, drawTo.y);
+      }
     }
-    static createPolygon(polygon, color) {
-        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.endFill();
-        return new Graphics(pixiGraphics, cacheName);
-    }
-    static createRegularPolygon(sides, radius, color) {
-        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);
-        for (let i = 1; i <= sides; i++) {
-            let angle = anglePerStep.multiply(i);
-            let angleVector = angle.vector.normalize(radius);
-            let nextX = radius + angleVector.x;
-            let nextY = radius + angleVector.y;
-            polygon.lineTo(nextX, nextY);
-        }
-        polygon.endFill();
-        return new Graphics(polygon, JSON.stringify({ type: 'regular-polygon', sides, radius, color }));
-    }
-    constructor(pixiGraphics, cacheName) {
-        super();
-        this.pixiContainer.addChild(pixiGraphics);
-        this.pixiGraphics = pixiGraphics;
-        this.cacheName = cacheName;
-    }
-    destroySelf() {
-        super.destroySelf();
-        !this.pixiGraphics.destroyed && this.pixiGraphics.destroy();
-    }
-    toSprite(partialOptions) {
-        let options = {
-            cacheName: this.cacheName,
-            keepBounds: true,
-            cache: false,
-            ...partialOptions
-        };
-        let textureConversion = this.getTexture(options.cacheName, options.cache);
-        let spriteDefinition = {
-            id: textureConversion.assetId,
-            scale: 1,
-            size: textureConversion.bounds,
-            anchor: { x: 0, y: 0 },
-            boundingShapes: undefined,
-            destroyAssetOnDestroy: !options.cache
-        };
-        let sprite = new __1.Sprite(spriteDefinition, { texturePosition: textureConversion.bounds, ignoreAnchor: true });
-        this.skipAttachCheck();
-        this.destroy();
-        return sprite;
-    }
-    getTexture(cacheName, cache) {
-        if (cache) {
-            let textureOfGraphics = Graphics.drawnTextureCache.get(cacheName);
-            if (!textureOfGraphics) {
-                textureOfGraphics = this.createTextureFromGraphics();
-                Graphics.drawnTextureCache.set(cacheName, textureOfGraphics);
-            }
-            return textureOfGraphics;
-        }
-        else {
-            return this.createTextureFromGraphics();
-        }
+    return new Graphics(pixiGraphics, JSON.stringify({ type: 'dashedLine', from, to, options }));
+  }
+  static createVector(from, to, color) {
+    const pixiGraphics = new PIXI.Graphics();
+    pixiGraphics.lineStyle(2, color);
+    pixiGraphics.moveTo(from.x, from.y);
+    pixiGraphics.lineTo(to.x, to.y);
+    pixiGraphics.lineStyle(1, color);
+    pixiGraphics.beginFill(helpers_lib_1.ColorHelper.white);
+    pixiGraphics.drawCircle(from.x, from.y, 3);
+    pixiGraphics.endFill();
+    return new Graphics(pixiGraphics, JSON.stringify({ type: 'line', start: from, end: to, color }));
+  }
+  static createRectangleBorders(size, borderSize, color) {
+    const pixiGraphics = new PIXI.Graphics();
+    pixiGraphics.beginFill(color);
+    pixiGraphics.drawRect(0, 0, size.x, borderSize);
+    pixiGraphics.drawRect(0, borderSize, borderSize, size.y - borderSize * 2);
+    pixiGraphics.drawRect(size.x - borderSize, borderSize, borderSize, size.y - borderSize * 2);
+    pixiGraphics.drawRect(0, size.y - borderSize, size.x, borderSize);
+    pixiGraphics.endFill();
+    return new Graphics(pixiGraphics, JSON.stringify({ type: 'rectangle-borders', size, borderSize, color }));
+  }
+  static createRectangle(size, color = helpers_lib_1.ColorHelper.white) {
+    const 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) {
+    const 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) {
+    const 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) {
+    const pixiGraphics = new PIXI.Graphics();
+    const 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.endFill();
+    return new Graphics(pixiGraphics, cacheName);
+  }
+  static createRegularPolygon(sides, radius, color) {
+    const polygon = new PIXI.Graphics();
+    const anglePerStep = new helpers_lib_1.Radian(helpers_lib_1.PI_360 / sides);
+    polygon.beginFill(color);
+    polygon.moveTo(radius, 0);
+    for (let i = 1; i <= sides; i++) {
+      const angle = anglePerStep.multiply(i);
+      const angleVector = angle.vector.normalize(radius);
+      const nextX = radius + angleVector.x;
+      const nextY = radius + angleVector.y;
+      polygon.lineTo(nextX, nextY);
     }
-    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) };
+    polygon.endFill();
+    return new Graphics(polygon, JSON.stringify({ type: 'regular-polygon', sides, radius, color }));
+  }
+  constructor(pixiGraphics, cacheName) {
+    super();
+    this.pixiContainer.addChild(pixiGraphics);
+    this.pixiGraphics = pixiGraphics;
+    this.cacheName = cacheName;
+  }
+  destroySelf() {
+    super.destroySelf();
+    !this.pixiGraphics.destroyed && this.pixiGraphics.destroy();
+  }
+  toSprite(partialOptions) {
+    const options = {
+      cacheName: this.cacheName,
+      keepBounds: true,
+      cache: false,
+      ...partialOptions
+    };
+    const textureConversion = this.getTexture(options.cacheName, options.cache);
+    const spriteDefinition = {
+      id: textureConversion.assetId,
+      scale: 1,
+      size: textureConversion.bounds,
+      anchor: { x: 0, y: 0 },
+      boundingShapes: undefined,
+      destroyAssetOnDestroy: !options.cache
+    };
+    const sprite = new __1.Sprite(spriteDefinition, {
+      texturePosition: textureConversion.bounds,
+      ignoreAnchor: true
+    });
+    this.skipAttachCheck();
+    this.destroy();
+    return sprite;
+  }
+  getTexture(cacheName, cache) {
+    if (cache) {
+      let textureOfGraphics = Graphics.drawnTextureCache.get(cacheName);
+      if (!textureOfGraphics) {
+        textureOfGraphics = this.createTextureFromGraphics();
+        Graphics.drawnTextureCache.set(cacheName, textureOfGraphics);
+      }
+      return textureOfGraphics;
+    } else {
+      return this.createTextureFromGraphics();
     }
+  }
+  createTextureFromGraphics() {
+    const texture = game_1.Game.instance.renderer.generateTexture(this.pixiGraphics);
+    texture.id = game_assets_1.GameAssets.insertAsset(texture);
+    const graphicsBounds = this.pixiGraphics.getBounds();
+    return {
+      assetId: texture.id,
+      bounds: new helpers_lib_1.Vector(graphicsBounds.x, graphicsBounds.y)
+    };
+  }
 }
 exports.Graphics = Graphics;
-//# sourceMappingURL=graphics.js.map
+//# sourceMappingURL=graphics.js.map

package/dist/pixi/display-object/objects/helpers/filters.d.ts

@@ -1,29 +1,29 @@
 import { Vector } from 'helpers-lib';
 import * as PIXI from 'pixi.js';
 export declare class Filters {
-    private container;
-    private colorMatrix;
-    private _red;
-    get red(): number;
-    set red(value: number);
-    private _green;
-    get green(): number;
-    set green(value: number);
-    private _blue;
-    get blue(): number;
-    set blue(value: number);
-    private _brightness;
-    get brightness(): number;
-    set brightness(value: number);
-    private _contrast;
-    get contrast(): number;
-    set contrast(value: number);
-    private blurFilter;
-    private _blur;
-    get blur(): Vector | undefined;
-    set blur(value: Vector | number | undefined);
-    constructor(container: PIXI.Container);
-    removeColorFilter(): void;
-    private refreshColorMatrix;
-    private onFilterChange;
+  private container;
+  private colorMatrix;
+  private _red;
+  get red(): number;
+  set red(value: number);
+  private _green;
+  get green(): number;
+  set green(value: number);
+  private _blue;
+  get blue(): number;
+  set blue(value: number);
+  private _brightness;
+  get brightness(): number;
+  set brightness(value: number);
+  private _contrast;
+  get contrast(): number;
+  set contrast(value: number);
+  private blurFilter;
+  private _blur;
+  get blur(): Vector | undefined;
+  set blur(value: Vector | number | undefined);
+  constructor(container: PIXI.Container);
+  removeColorFilter(): void;
+  private refreshColorMatrix;
+  private onFilterChange;
 }