bard-legends-framework 0.9.5 → 0.9.7

package/dist/pixi/display-object/filters/base-filters/expand-with-color-gradient.js

@@ -1,122 +1,133 @@
-"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.ExpandWithColorGradientFilter = void 0;
-const PIXI = __importStar(require("pixi.js"));
-const helpers_lib_1 = require("helpers-lib");
+const PIXI = __importStar(require('pixi.js'));
+const helpers_lib_1 = require('helpers-lib');
 class ExpandWithColorGradientFilter extends PIXI.Filter {
-    static toVec4String(color) {
-        return `vec4(${this.toFloatString(color.red)}, ${this.toFloatString(color.green)}, ${this.toFloatString(color.blue)}, 1.0)`;
+  static toVec4String(color) {
+    return `vec4(${ExpandWithColorGradientFilter.toFloatString(color.red)}, ${ExpandWithColorGradientFilter.toFloatString(color.green)}, ${ExpandWithColorGradientFilter.toFloatString(color.blue)}, 1.0)`;
+  }
+  static toFloatString(value) {
+    if (Number.isInteger(value)) {
+      return value.toFixed(1);
+    } else {
+      return value.toFixed(6);
     }
-    static toFloatString(value) {
-        if (Number.isInteger(value)) {
-            return value.toFixed(1);
+  }
+  static getVertexShader() {
+    return `
+      attribute vec2 aVertexPosition;
+      attribute vec2 aTextureCoord;
+
+      uniform mat3 projectionMatrix;
+
+      varying vec2 vTextureCoord;
+
+      void main(void) {
+        gl_Position = vec4((projectionMatrix * vec3(aVertexPosition, 1.0)).xy, 0.0, 1.0);
+        vTextureCoord = aTextureCoord;
+      }
+    `;
+  }
+  static getFragmentShader(colorGradient) {
+    const alphaDiminishPerPixel = 1 / colorGradient.length;
+    // prettier-ignore
+    const shader = `
+      uniform sampler2D uSampler;
+      uniform vec2 pixelSize;
+
+      varying vec2 vTextureCoord;
+
+      void main(void) {
+        float highestAlpha = 0.0;
+        float colorCount = ${ExpandWithColorGradientFilter.toFloatString(colorGradient.length)};
+
+        for (float x = -${ExpandWithColorGradientFilter.toFloatString(colorGradient.length)}; x <= ${ExpandWithColorGradientFilter.toFloatString(colorGradient.length)}; x++) {
+          for (float y = -${ExpandWithColorGradientFilter.toFloatString(colorGradient.length)}; y <= ${ExpandWithColorGradientFilter.toFloatString(colorGradient.length)}; y++) {
+            vec4 color = texture2D(uSampler, vTextureCoord + vec2(x * pixelSize.x, y * pixelSize.y));
+            float distance = sqrt(x * x + y * y);
+            float alpha = max(0.0, color.a - ${ExpandWithColorGradientFilter.toFloatString(alphaDiminishPerPixel)} * distance);
+            highestAlpha = max(highestAlpha, alpha);
+          }
         }
-        else {
-            return value.toFixed(6);
+
+        highestAlpha = clamp(highestAlpha, 0.0, 1.0);
+
+        if (highestAlpha >= 1.0) {
+          gl_FragColor = texture2D(uSampler, vTextureCoord);
+        } else if (highestAlpha > ${ExpandWithColorGradientFilter.toFloatString(1 - alphaDiminishPerPixel)}) {
+          gl_FragColor = mix(${ExpandWithColorGradientFilter.toVec4String(colorGradient[0])}, texture2D(uSampler, vTextureCoord), highestAlpha);
+        } else if (highestAlpha > ${ExpandWithColorGradientFilter.toFloatString(1 - alphaDiminishPerPixel * 2)}) {
+          gl_FragColor = mix(${ExpandWithColorGradientFilter.toVec4String(colorGradient[1])}, ${ExpandWithColorGradientFilter.toVec4String(colorGradient[0])}, highestAlpha);
+        } else if (highestAlpha > ${ExpandWithColorGradientFilter.toFloatString(1 - alphaDiminishPerPixel * 3)}) {
+          gl_FragColor = mix(${ExpandWithColorGradientFilter.toVec4String(colorGradient[2])}, ${ExpandWithColorGradientFilter.toVec4String(colorGradient[1])}, highestAlpha);
+        } else if (highestAlpha > ${ExpandWithColorGradientFilter.toFloatString(1 - alphaDiminishPerPixel * 4)}) {
+          gl_FragColor = mix(${ExpandWithColorGradientFilter.toVec4String(colorGradient[3])}, ${ExpandWithColorGradientFilter.toVec4String(colorGradient[2])}, highestAlpha);
+        } else if (highestAlpha > ${ExpandWithColorGradientFilter.toFloatString(1 - alphaDiminishPerPixel * 5)}) {
+          gl_FragColor = mix(${ExpandWithColorGradientFilter.toVec4String(colorGradient[4])}, ${ExpandWithColorGradientFilter.toVec4String(colorGradient[3])}, highestAlpha);
+        } else if (highestAlpha > ${ExpandWithColorGradientFilter.toFloatString(1 - alphaDiminishPerPixel * 6)}) {
+          gl_FragColor = mix(${ExpandWithColorGradientFilter.toVec4String(colorGradient[5])}, ${ExpandWithColorGradientFilter.toVec4String(colorGradient[4])}, highestAlpha);
+        } else if (highestAlpha > ${ExpandWithColorGradientFilter.toFloatString(1 - alphaDiminishPerPixel * 7)}) {
+          gl_FragColor = mix(${ExpandWithColorGradientFilter.toVec4String(colorGradient[6])}, ${ExpandWithColorGradientFilter.toVec4String(colorGradient[5])}, highestAlpha);
+        } else if (highestAlpha > ${ExpandWithColorGradientFilter.toFloatString(1 - alphaDiminishPerPixel * 8)}) {
+          gl_FragColor = mix(${ExpandWithColorGradientFilter.toVec4String(colorGradient[7])}, ${ExpandWithColorGradientFilter.toVec4String(colorGradient[6])}, highestAlpha);
+        } else if (highestAlpha > 0.0) {
+          gl_FragColor = mix(${ExpandWithColorGradientFilter.toVec4String(colorGradient[8])}, ${ExpandWithColorGradientFilter.toVec4String(colorGradient[7])}, highestAlpha);
         }
-    }
-    static getVertexShader() {
-        return `
-      attribute vec2 aVertexPosition;
-      attribute vec2 aTextureCoord;
-
-      uniform mat3 projectionMatrix;
-
-      varying vec2 vTextureCoord;
-
-      void main(void) {
-        gl_Position = vec4((projectionMatrix * vec3(aVertexPosition, 1.0)).xy, 0.0, 1.0);
-        vTextureCoord = aTextureCoord;
-      }
-    `;
-    }
-    static getFragmentShader(colorGradient) {
-        let alphaDiminishPerPixel = 1 / colorGradient.length;
-        // prettier-ignore
-        let shader = `
-      uniform sampler2D uSampler;
-      uniform vec2 pixelSize;
-
-      varying vec2 vTextureCoord;
-
-      void main(void) {
-        float highestAlpha = 0.0;
-        float colorCount = ${this.toFloatString(colorGradient.length)};
-
-        for (float x = -${this.toFloatString(colorGradient.length)}; x <= ${this.toFloatString(colorGradient.length)}; x++) {
-          for (float y = -${this.toFloatString(colorGradient.length)}; y <= ${this.toFloatString(colorGradient.length)}; y++) {
-            vec4 color = texture2D(uSampler, vTextureCoord + vec2(x * pixelSize.x, y * pixelSize.y));
-            float distance = sqrt(x * x + y * y);
-            float alpha = max(0.0, color.a - ${this.toFloatString(alphaDiminishPerPixel)} * distance);
-            highestAlpha = max(highestAlpha, alpha);
-          }
-        }
-
-        highestAlpha = clamp(highestAlpha, 0.0, 1.0);
-
-        if (highestAlpha >= 1.0) {
-          gl_FragColor = texture2D(uSampler, vTextureCoord);
-        } else if (highestAlpha > ${this.toFloatString(1 - alphaDiminishPerPixel)}) {
-          gl_FragColor = mix(${this.toVec4String(colorGradient[0])}, texture2D(uSampler, vTextureCoord), highestAlpha);
-        } else if (highestAlpha > ${this.toFloatString(1 - alphaDiminishPerPixel * 2)}) {
-          gl_FragColor = mix(${this.toVec4String(colorGradient[1])}, ${this.toVec4String(colorGradient[0])}, highestAlpha);
-        } else if (highestAlpha > ${this.toFloatString(1 - alphaDiminishPerPixel * 3)}) {
-          gl_FragColor = mix(${this.toVec4String(colorGradient[2])}, ${this.toVec4String(colorGradient[1])}, highestAlpha);
-        } else if (highestAlpha > ${this.toFloatString(1 - alphaDiminishPerPixel * 4)}) {
-          gl_FragColor = mix(${this.toVec4String(colorGradient[3])}, ${this.toVec4String(colorGradient[2])}, highestAlpha);
-        } else if (highestAlpha > ${this.toFloatString(1 - alphaDiminishPerPixel * 5)}) {
-          gl_FragColor = mix(${this.toVec4String(colorGradient[4])}, ${this.toVec4String(colorGradient[3])}, highestAlpha);
-        } else if (highestAlpha > ${this.toFloatString(1 - alphaDiminishPerPixel * 6)}) {
-          gl_FragColor = mix(${this.toVec4String(colorGradient[5])}, ${this.toVec4String(colorGradient[4])}, highestAlpha);
-        } else if (highestAlpha > ${this.toFloatString(1 - alphaDiminishPerPixel * 7)}) {
-          gl_FragColor = mix(${this.toVec4String(colorGradient[6])}, ${this.toVec4String(colorGradient[5])}, highestAlpha);
-        } else if (highestAlpha > ${this.toFloatString(1 - alphaDiminishPerPixel * 8)}) {
-          gl_FragColor = mix(${this.toVec4String(colorGradient[7])}, ${this.toVec4String(colorGradient[6])}, highestAlpha);
-        } else if (highestAlpha > 0.0) {
-          gl_FragColor = mix(${this.toVec4String(colorGradient[8])}, ${this.toVec4String(colorGradient[7])}, highestAlpha);
-        }
-
-        gl_FragColor *= highestAlpha;
+
+        gl_FragColor *= highestAlpha;
       }`;
-        console.log(shader);
-        return shader;
-    }
-    constructor(colorGradient) {
-        super(ExpandWithColorGradientFilter.getVertexShader(), ExpandWithColorGradientFilter.getFragmentShader(colorGradient.map(color => helpers_lib_1.ColorHelper.normalize(color))));
-        this.colorGradient = colorGradient;
-        if (colorGradient.length > 10) {
-            throw new Error('ExpandWithColorGradientFilter: Gradient count be higher than 10');
-        }
-        this.padding = colorGradient.length;
-        let colors = this.colorGradient.map(color => new Int8Array([color.r, color.g, color.b, 1])).flat();
-    }
-    apply(filterManager, input, output, clearMode) {
-        this.uniforms.pixelSize = new Float32Array([1 / input.width, 1 / input.height]);
-        filterManager.applyFilter(this, input, output, clearMode);
+    console.log(shader);
+    return shader;
+  }
+  constructor(colorGradient) {
+    super(
+      ExpandWithColorGradientFilter.getVertexShader(),
+      ExpandWithColorGradientFilter.getFragmentShader(colorGradient.map(color => helpers_lib_1.ColorHelper.normalize(color)))
+    );
+    this.colorGradient = colorGradient;
+    if (colorGradient.length > 10) {
+      throw new Error('ExpandWithColorGradientFilter: Gradient count be higher than 10');
     }
+    this.padding = colorGradient.length;
+    const colors = this.colorGradient.flatMap(color => new Int8Array([color.r, color.g, color.b, 1]));
+  }
+  apply(filterManager, input, output, clearMode) {
+    this.uniforms.pixelSize = new Float32Array([1 / input.width, 1 / input.height]);
+    filterManager.applyFilter(this, input, output, clearMode);
+  }
 }
 exports.ExpandWithColorGradientFilter = ExpandWithColorGradientFilter;
-//# sourceMappingURL=expand-with-color-gradient.js.map
+//# sourceMappingURL=expand-with-color-gradient.js.map

package/dist/pixi/display-object/filters/base-filters/expand-with-color.d.ts

@@ -1,9 +1,14 @@
 import * as PIXI from 'pixi.js';
 import { RGBColor } from 'helpers-lib';
 export declare class ExpandWithColorFilter extends PIXI.Filter {
-    private expand;
-    private static getVertexShader;
-    private static getFragmentShader;
-    constructor(expand: number, color: RGBColor);
-    apply(filterManager: PIXI.FilterSystem, input: PIXI.RenderTexture, output: PIXI.RenderTexture, clearMode: PIXI.CLEAR_MODES): void;
+  private expand;
+  private static getVertexShader;
+  private static getFragmentShader;
+  constructor(expand: number, color: RGBColor);
+  apply(
+    filterManager: PIXI.FilterSystem,
+    input: PIXI.RenderTexture,
+    output: PIXI.RenderTexture,
+    clearMode: PIXI.CLEAR_MODES
+  ): void;
 }

package/dist/pixi/display-object/filters/base-filters/expand-with-color.filter.js

@@ -29,49 +29,49 @@ const PIXI = __importStar(require("pixi.js"));
 const game_1 = require("../../../game");
 class ExpandWithColorFilter extends PIXI.Filter {
     static getVertexShader() {
-        return `
-      attribute vec2 aVertexPosition;
-      attribute vec2 aTextureCoord;
-
-      uniform mat3 projectionMatrix;
-
-      varying vec2 vTextureCoord;
-
-      void main(void) {
-        gl_Position = vec4((projectionMatrix * vec3(aVertexPosition, 1.0)).xy, 0.0, 1.0);
-        vTextureCoord = aTextureCoord;
-      }
+        return `
+      attribute vec2 aVertexPosition;
+      attribute vec2 aTextureCoord;
+
+      uniform mat3 projectionMatrix;
+
+      varying vec2 vTextureCoord;
+
+      void main(void) {
+        gl_Position = vec4((projectionMatrix * vec3(aVertexPosition, 1.0)).xy, 0.0, 1.0);
+        vTextureCoord = aTextureCoord;
+      }
     `;
     }
     static getFragmentShader(expand) {
-        let shader = `
-      uniform sampler2D uSampler;
-      uniform vec2 pixelSize;
-      uniform float expandSquared;
-      uniform vec3 color;
-
-      varying vec2 vTextureCoord;
-
-      void main(void) {
+        let shader = `
+      uniform sampler2D uSampler;
+      uniform vec2 pixelSize;
+      uniform float expandSquared;
+      uniform vec3 color;
+
+      varying vec2 vTextureCoord;
+
+      void main(void) {
         float highestAlpha = 0.0;`;
         if (expand > 0) {
-            shader += `\n
-        for (float x = -${helpers_lib_1.NumberHelper.toFloatString(expand)}; x <= ${helpers_lib_1.NumberHelper.toFloatString(expand)}; x++) {
-          for (float y = -${helpers_lib_1.NumberHelper.toFloatString(expand)}; y <= ${helpers_lib_1.NumberHelper.toFloatString(expand)}; y++) {
-            vec4 neighborColor = texture2D(uSampler, vTextureCoord + vec2(x * pixelSize.x, y * pixelSize.y));
-            float distance = x * x + y * y;
-            highestAlpha = max(highestAlpha, neighborColor.a * step(distance, expandSquared));
-          }
+            shader += `\n
+        for (float x = -${helpers_lib_1.NumberHelper.toFloatString(expand)}; x <= ${helpers_lib_1.NumberHelper.toFloatString(expand)}; x++) {
+          for (float y = -${helpers_lib_1.NumberHelper.toFloatString(expand)}; y <= ${helpers_lib_1.NumberHelper.toFloatString(expand)}; y++) {
+            vec4 neighborColor = texture2D(uSampler, vTextureCoord + vec2(x * pixelSize.x, y * pixelSize.y));
+            float distance = x * x + y * y;
+            highestAlpha = max(highestAlpha, neighborColor.a * step(distance, expandSquared));
+          }
         }`;
         }
         else {
-            shader += `\n
-        vec4 centerColor = texture2D(uSampler, vTextureCoord);
+            shader += `\n
+        vec4 centerColor = texture2D(uSampler, vTextureCoord);
         highestAlpha = centerColor.a;`;
         }
         // prettier-ignore
-        shader += `\n
-        gl_FragColor = vec4(color, 1.0) * highestAlpha;
+        shader += `\n
+        gl_FragColor = vec4(color, 1.0) * highestAlpha;
       }`;
         return shader;
     }

package/dist/pixi/display-object/filters/base-filters/expand-with-color.js

@@ -1,100 +1,107 @@
-"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.ExpandWithColorFilter = void 0;
-const PIXI = __importStar(require("pixi.js"));
-const helpers_lib_1 = require("helpers-lib");
+const PIXI = __importStar(require('pixi.js'));
+const helpers_lib_1 = require('helpers-lib');
 class ExpandWithColorFilter extends PIXI.Filter {
-    static getVertexShader() {
-        return `
-      attribute vec2 aVertexPosition;
-      attribute vec2 aTextureCoord;
-
-      uniform mat3 projectionMatrix;
-
-      varying vec2 vTextureCoord;
-
-      void main(void) {
-        gl_Position = vec4((projectionMatrix * vec3(aVertexPosition, 1.0)).xy, 0.0, 1.0);
-        vTextureCoord = aTextureCoord;
-      }
+  static getVertexShader() {
+    return `
+      attribute vec2 aVertexPosition;
+      attribute vec2 aTextureCoord;
+
+      uniform mat3 projectionMatrix;
+
+      varying vec2 vTextureCoord;
+
+      void main(void) {
+        gl_Position = vec4((projectionMatrix * vec3(aVertexPosition, 1.0)).xy, 0.0, 1.0);
+        vTextureCoord = aTextureCoord;
+      }
     `;
-    }
-    static getFragmentShader(expand) {
-        let shader = `
-      uniform sampler2D uSampler;
-      uniform vec2 pixelSize;
-      uniform float expandSquared;
-      uniform vec3 color;
-
-      varying vec2 vTextureCoord;
-
-      void main(void) {
+  }
+  static getFragmentShader(expand) {
+    let shader = `
+      uniform sampler2D uSampler;
+      uniform vec2 pixelSize;
+      uniform float expandSquared;
+      uniform vec3 color;
+
+      varying vec2 vTextureCoord;
+
+      void main(void) {
         float highestAlpha = 0.0;`;
-        if (expand > 0) {
-            shader += `\n
-        for (float x = -${helpers_lib_1.NumberHelper.toFloatString(expand)}; x <= ${helpers_lib_1.NumberHelper.toFloatString(expand)}; x++) {
-          for (float y = -${helpers_lib_1.NumberHelper.toFloatString(expand)}; y <= ${helpers_lib_1.NumberHelper.toFloatString(expand)}; y++) {
-            vec4 neighborColor = texture2D(uSampler, vTextureCoord + vec2(x * pixelSize.x, y * pixelSize.y));
-            float distance = x * x + y * y;
-            highestAlpha = max(highestAlpha, neighborColor.a * step(distance, expandSquared));
-          }
+    if (expand > 0) {
+      shader += `\n
+        for (float x = -${helpers_lib_1.NumberHelper.toFloatString(expand)}; x <= ${helpers_lib_1.NumberHelper.toFloatString(expand)}; x++) {
+          for (float y = -${helpers_lib_1.NumberHelper.toFloatString(expand)}; y <= ${helpers_lib_1.NumberHelper.toFloatString(expand)}; y++) {
+            vec4 neighborColor = texture2D(uSampler, vTextureCoord + vec2(x * pixelSize.x, y * pixelSize.y));
+            float distance = x * x + y * y;
+            highestAlpha = max(highestAlpha, neighborColor.a * step(distance, expandSquared));
+          }
         }`;
-        }
-        else {
-            shader += `\n
-        vec4 centerColor = texture2D(uSampler, vTextureCoord);
+    } else {
+      shader += `\n
+        vec4 centerColor = texture2D(uSampler, vTextureCoord);
         highestAlpha = centerColor.a;`;
-        }
-        // prettier-ignore
-        shader += `\n
-        gl_FragColor = vec4(color, 1.0) * highestAlpha;
-      }`;
-        return shader;
     }
-    constructor(expand, color) {
-        super(ExpandWithColorFilter.getVertexShader(), ExpandWithColorFilter.getFragmentShader(expand));
-        this.expand = expand;
-        if (expand < 0) {
-            throw new Error('ExpandWithColorFilter: Expand cannot be smaller than 0');
-        }
-        else if (expand > 10) {
-            throw new Error('ExpandWithColorFilter: Expand cannot be higher than 10');
-        }
-        if (!helpers_lib_1.Comparator.isInteger(expand)) {
-            expand = Math.floor(expand);
-        }
-        let normalizedColor = helpers_lib_1.ColorHelper.normalize(color);
-        this.uniforms.color = new Float32Array([normalizedColor.red, normalizedColor.green, normalizedColor.blue]);
-        this.uniforms.expandSquared = this.expand * this.expand;
-        this.padding = expand;
+    // prettier-ignore
+    shader += `\n
+        gl_FragColor = vec4(color, 1.0) * highestAlpha;
+      }`;
+    return shader;
+  }
+  constructor(expand, color) {
+    super(ExpandWithColorFilter.getVertexShader(), ExpandWithColorFilter.getFragmentShader(expand));
+    this.expand = expand;
+    if (expand < 0) {
+      throw new Error('ExpandWithColorFilter: Expand cannot be smaller than 0');
+    } else if (expand > 10) {
+      throw new Error('ExpandWithColorFilter: Expand cannot be higher than 10');
     }
-    apply(filterManager, input, output, clearMode) {
-        this.uniforms.pixelSize = new Float32Array([1 / input.width, 1 / input.height]);
-        filterManager.applyFilter(this, input, output, clearMode);
+    if (!helpers_lib_1.Comparator.isInteger(expand)) {
+      expand = Math.floor(expand);
     }
+    const normalizedColor = helpers_lib_1.ColorHelper.normalize(color);
+    this.uniforms.color = new Float32Array([normalizedColor.red, normalizedColor.green, normalizedColor.blue]);
+    this.uniforms.expandSquared = this.expand * this.expand;
+    this.padding = expand;
+  }
+  apply(filterManager, input, output, clearMode) {
+    this.uniforms.pixelSize = new Float32Array([1 / input.width, 1 / input.height]);
+    filterManager.applyFilter(this, input, output, clearMode);
+  }
 }
 exports.ExpandWithColorFilter = ExpandWithColorFilter;
-//# sourceMappingURL=expand-with-color.js.map
+//# sourceMappingURL=expand-with-color.js.map

package/dist/pixi/display-object/filters/templates/checking-neighbors.template.js

@@ -28,37 +28,37 @@ const PIXI = __importStar(require("pixi.js"));
 const game_1 = require("../../../game");
 class CheckingNeighborsTemplate extends PIXI.Filter {
     static getVertexShader() {
-        return `
-      attribute vec2 aVertexPosition;
-      attribute vec2 aTextureCoord;
-
-      uniform mat3 projectionMatrix;
-
-      varying vec2 vTextureCoord;
-
-      void main(void) {
-        gl_Position = vec4((projectionMatrix * vec3(aVertexPosition, 1.0)).xy, 0.0, 1.0);
-        vTextureCoord = aTextureCoord;
-      }
+        return `
+      attribute vec2 aVertexPosition;
+      attribute vec2 aTextureCoord;
+
+      uniform mat3 projectionMatrix;
+
+      varying vec2 vTextureCoord;
+
+      void main(void) {
+        gl_Position = vec4((projectionMatrix * vec3(aVertexPosition, 1.0)).xy, 0.0, 1.0);
+        vTextureCoord = aTextureCoord;
+      }
     `;
     }
     static getFragmentShader() {
-        return `
-      uniform sampler2D uSampler;
-      uniform vec2 pixelSize;
-
-      varying vec2 vTextureCoord;
-
-      void main(void) {
-        gl_FragColor = texture2D(uSampler, vTextureCoord) * 0.2;
-
-        for (float x = -1.0; x <= 1.0; x++) {
-          for (float y = -1.0; y <= 1.0; y++) {
-            vec4 color = texture2D(uSampler, vTextureCoord + vec2(x * pixelSize.x, y * pixelSize.y));
-            gl_FragColor += color * 0.1;
-          }
-        }
-      }
+        return `
+      uniform sampler2D uSampler;
+      uniform vec2 pixelSize;
+
+      varying vec2 vTextureCoord;
+
+      void main(void) {
+        gl_FragColor = texture2D(uSampler, vTextureCoord) * 0.2;
+
+        for (float x = -1.0; x <= 1.0; x++) {
+          for (float y = -1.0; y <= 1.0; y++) {
+            vec4 color = texture2D(uSampler, vTextureCoord + vec2(x * pixelSize.x, y * pixelSize.y));
+            gl_FragColor += color * 0.1;
+          }
+        }
+      }
     `;
     }
     constructor() {

package/dist/pixi/display-object/filters/templates/plane.template.js

@@ -28,29 +28,29 @@ const PIXI = __importStar(require("pixi.js"));
 const game_1 = require("../../../game");
 class PlaneTemplate extends PIXI.Filter {
     static getVertexShader() {
-        return `
-      attribute vec2 aVertexPosition;
-      attribute vec2 aTextureCoord;
-
-      uniform mat3 projectionMatrix;
-
-      varying vec2 vTextureCoord;
-
-      void main(void) {
-        gl_Position = vec4((projectionMatrix * vec3(aVertexPosition, 1.0)).xy, 0.0, 1.0);
-        vTextureCoord = aTextureCoord;
-      }
+        return `
+      attribute vec2 aVertexPosition;
+      attribute vec2 aTextureCoord;
+
+      uniform mat3 projectionMatrix;
+
+      varying vec2 vTextureCoord;
+
+      void main(void) {
+        gl_Position = vec4((projectionMatrix * vec3(aVertexPosition, 1.0)).xy, 0.0, 1.0);
+        vTextureCoord = aTextureCoord;
+      }
     `;
     }
     static getFragmentShader() {
-        return `
-      uniform sampler2D uSampler;
-
-      varying vec2 vTextureCoord;
-
-      void main(void) {
-        gl_FragColor = texture2D(uSampler, vTextureCoord);
-      }
+        return `
+      uniform sampler2D uSampler;
+
+      varying vec2 vTextureCoord;
+
+      void main(void) {
+        gl_FragColor = texture2D(uSampler, vTextureCoord);
+      }
     `;
     }
     constructor() {