dacha 0.13.0

package/build/contrib/systems/sprite-renderer/utils.js

@@ -0,0 +1,41 @@
+import { NearestFilter, RepeatWrapping, ClampToEdgeWrapping, } from 'three/src/Three';
+import { Sprite } from '../../components/sprite';
+import { ResourceLoader } from '../../../engine/resource-loader';
+import { SpriteCropper } from './sprite-cropper';
+const spriteCropper = new SpriteCropper();
+const resourceLoader = new ResourceLoader();
+export const loadImage = (sprite) => resourceLoader.load(sprite.src);
+export const prepareSprite = (image, sprite) => {
+    const textures = spriteCropper.crop(image, sprite);
+    textures.forEach((texture) => {
+        texture.magFilter = NearestFilter;
+        texture.minFilter = NearestFilter;
+        texture.flipY = false;
+    });
+    return textures;
+};
+export const getImagesFromTemplate = (images, template) => {
+    const sprite = template.getComponent(Sprite);
+    if (!sprite || images[sprite.src]) {
+        return;
+    }
+    images[sprite.src] = sprite;
+};
+export const getTextureMapKey = ({ slice, fit, width = 0, height = 0, src, }) => `${slice}_${fit}_${width}_${height}_${src}`;
+export const cloneTexture = (sprite, texture) => {
+    const { fit, width = 0, height = 0 } = sprite;
+    const repeatX = fit === 'repeat' ? width / texture.image.width : 1;
+    const repeatY = fit === 'repeat' ? height / texture.image.height : 1;
+    const newTexture = texture.clone();
+    if (fit === 'repeat') {
+        newTexture.wrapS = RepeatWrapping;
+        newTexture.wrapT = RepeatWrapping;
+    }
+    else {
+        newTexture.wrapS = ClampToEdgeWrapping;
+        newTexture.wrapT = ClampToEdgeWrapping;
+    }
+    newTexture.repeat.set(repeatX, repeatY);
+    newTexture.needsUpdate = true;
+    return newTexture;
+};

package/build/contrib/systems/ui-bridge/index.d.ts

@@ -0,0 +1,40 @@
+import { Scene } from '../../../engine/scene';
+import { System } from '../../../engine/system';
+import type { SystemOptions, UpdateOptions } from '../../../engine/system';
+import type { TemplateCollection } from '../../../engine/template';
+import { Observer } from './observer';
+interface ActionFnOptions {
+    scene: Scene;
+    actorSpawner: unknown;
+    deltaTime: number;
+}
+type ActionFn = (options: ActionFnOptions) => void;
+export interface UiInitFnOptions {
+    scene: Scene;
+    templateCollection: TemplateCollection;
+    gameStateObserver: Observer;
+    pushAction: (action: ActionFn) => void;
+}
+export type UiInitFn = (options: UiInitFnOptions) => void;
+export type UiDestroyFn = () => void;
+export type LoadUiAppFn = () => Promise<{
+    onInit: UiInitFn;
+    onDestroy: UiDestroyFn;
+}>;
+export declare class UiBridge extends System {
+    private actorSpawner;
+    private scene;
+    private loadUiApp;
+    private templateCollection;
+    private gameStateObserver;
+    private actionsQueue;
+    private onUiInit?;
+    private onUiDestroy?;
+    constructor(options: SystemOptions);
+    load(): Promise<void>;
+    mount(): void;
+    unmount(): void;
+    private pushAction;
+    update(options: UpdateOptions): void;
+}
+export {};

package/build/contrib/systems/ui-bridge/index.js

@@ -0,0 +1,62 @@
+import { System } from '../../../engine/system';
+import { Observer } from './observer';
+export class UiBridge extends System {
+    actorSpawner;
+    scene;
+    loadUiApp;
+    templateCollection;
+    gameStateObserver;
+    actionsQueue;
+    onUiInit;
+    onUiDestroy;
+    constructor(options) {
+        super();
+        const { actorSpawner, resources, scene, templateCollection, } = options;
+        const loadUiApp = resources?.loadUiApp;
+        if (loadUiApp === undefined) {
+            throw new Error('UiBridge requires a UI loader. Please specify the loader in the resources section.');
+        }
+        this.loadUiApp = loadUiApp;
+        this.scene = scene;
+        this.actorSpawner = actorSpawner;
+        this.templateCollection = templateCollection;
+        this.gameStateObserver = new Observer();
+        this.actionsQueue = [];
+    }
+    async load() {
+        const { onInit, onDestroy } = await this.loadUiApp();
+        this.onUiInit = onInit;
+        this.onUiDestroy = onDestroy;
+    }
+    mount() {
+        if (this.onUiInit) {
+            this.onUiInit({
+                scene: this.scene,
+                templateCollection: this.templateCollection,
+                gameStateObserver: this.gameStateObserver,
+                pushAction: this.pushAction.bind(this),
+            });
+        }
+    }
+    unmount() {
+        if (this.onUiDestroy) {
+            this.onUiDestroy();
+        }
+    }
+    pushAction(action) {
+        this.actionsQueue.push(action);
+    }
+    update(options) {
+        const { deltaTime } = options;
+        this.gameStateObserver.next();
+        this.actionsQueue.forEach((action) => {
+            action({
+                scene: this.scene,
+                deltaTime,
+                actorSpawner: this.actorSpawner,
+            });
+        });
+        this.actionsQueue = [];
+    }
+}
+UiBridge.systemName = 'UiBridge';

package/build/contrib/systems/ui-bridge/observer/index.d.ts

@@ -0,0 +1 @@
+export { Observer } from './observer';

package/build/contrib/systems/ui-bridge/observer/index.js

@@ -0,0 +1 @@
+export { Observer } from './observer';

package/build/contrib/systems/ui-bridge/observer/observer.d.ts

@@ -0,0 +1,8 @@
+export type SubscribeFn = () => void;
+export declare class Observer {
+    private subscribers;
+    constructor();
+    next(): void;
+    subscribe(callback: SubscribeFn): void;
+    unsubscribe(callback: SubscribeFn): void;
+}

package/build/contrib/systems/ui-bridge/observer/observer.js

@@ -0,0 +1,21 @@
+export class Observer {
+    subscribers;
+    constructor() {
+        this.subscribers = [];
+    }
+    next() {
+        this.subscribers.forEach((callback) => callback());
+    }
+    subscribe(callback) {
+        if (!(callback instanceof Function)) {
+            throw new Error('Callback should be a function');
+        }
+        this.subscribers.push(callback);
+    }
+    unsubscribe(callback) {
+        if (!(callback instanceof Function)) {
+            throw new Error('Callback should be a function');
+        }
+        this.subscribers = this.subscribers.filter((subscription) => subscription !== callback);
+    }
+}

package/build/contrib/systems/webgl-render-system/color/color-reader/color-reader.d.ts

@@ -0,0 +1,3 @@
+export interface ColorReader {
+    read(color: string): Record<string, number>;
+}

package/build/contrib/systems/webgl-render-system/color/color-reader/color-reader.js

@@ -0,0 +1 @@
+export {};

package/build/contrib/systems/webgl-render-system/color/color-reader/consts.d.ts

@@ -0,0 +1,3 @@
+export declare const HEX_RADIX = 16;
+export declare const SHARP = "#";
+export declare const COLORS: string[];

package/build/contrib/systems/webgl-render-system/color/color-reader/consts.js

@@ -0,0 +1,10 @@
+export const HEX_RADIX = 16;
+export const SHARP = '#';
+const COLOR_RED_KEY = 'red';
+const COLOR_GREEN_KEY = 'green';
+const COLOR_BLUE_KEY = 'blue';
+export const COLORS = [
+    COLOR_RED_KEY,
+    COLOR_GREEN_KEY,
+    COLOR_BLUE_KEY,
+];

package/build/contrib/systems/webgl-render-system/color/color-reader/hex-color-reader.d.ts

@@ -0,0 +1,4 @@
+import { ColorReader } from './color-reader';
+export declare class HexColorReader implements ColorReader {
+    read(color: string): Record<string, number>;
+}

package/build/contrib/systems/webgl-render-system/color/color-reader/hex-color-reader.js

@@ -0,0 +1,14 @@
+import { HEX_RADIX, SHARP, COLORS, } from './consts';
+const BYTE_SHIFT = 8;
+const MAX_COLOR_NUMBER = 255;
+export class HexColorReader {
+    read(color) {
+        const value = parseInt(color.replace(SHARP, ''), HEX_RADIX);
+        return COLORS.reduce((colorInfo, name, index, array) => {
+            // More optimized way to read color
+            // eslint-disable-next-line no-bitwise
+            colorInfo[name] = (value >> (BYTE_SHIFT * (array.length - index - 1))) & MAX_COLOR_NUMBER;
+            return colorInfo;
+        }, {});
+    }
+}

package/build/contrib/systems/webgl-render-system/color/color-reader/index.d.ts

@@ -0,0 +1,6 @@
+import { HexColorReader } from './hex-color-reader';
+import { ShortHexColorReader } from './short-hex-color-reader';
+export declare const colorReaders: {
+    hexColorReader: typeof HexColorReader;
+    shortHeColorReader: typeof ShortHexColorReader;
+};

package/build/contrib/systems/webgl-render-system/color/color-reader/index.js

@@ -0,0 +1,6 @@
+import { HexColorReader } from './hex-color-reader';
+import { ShortHexColorReader } from './short-hex-color-reader';
+export const colorReaders = {
+    hexColorReader: HexColorReader,
+    shortHeColorReader: ShortHexColorReader,
+};

package/build/contrib/systems/webgl-render-system/color/color-reader/short-hex-color-reader.d.ts

@@ -0,0 +1,4 @@
+import { ColorReader } from './color-reader';
+export declare class ShortHexColorReader implements ColorReader {
+    read(color: string): Record<string, number>;
+}

package/build/contrib/systems/webgl-render-system/color/color-reader/short-hex-color-reader.js

@@ -0,0 +1,11 @@
+import { HEX_RADIX, SHARP, COLORS, } from './consts';
+const REPEAT_COUNT = 2;
+export class ShortHexColorReader {
+    read(color) {
+        const value = color.replace(SHARP, '');
+        return COLORS.reduce((colorInfo, name, index) => {
+            colorInfo[name] = parseInt(value[index].repeat(REPEAT_COUNT), HEX_RADIX);
+            return colorInfo;
+        }, {});
+    }
+}

package/build/contrib/systems/webgl-render-system/color/index.d.ts

@@ -0,0 +1,7 @@
+export declare class Color {
+    private _color;
+    constructor(color: string);
+    red(): number;
+    green(): number;
+    blue(): number;
+}

package/build/contrib/systems/webgl-render-system/color/index.js

@@ -0,0 +1,41 @@
+import { colorReaders } from './color-reader';
+const HEX_COLOR_REGEXP = /#[0-9a-zA-Z]{6}/;
+const SHORT_HEX_COLOR_REGEXP = /#[0-9a-zA-Z]{3}/;
+const COLOR_RED_KEY = 'red';
+const COLOR_GREEN_KEY = 'green';
+const COLOR_BLUE_KEY = 'blue';
+export class Color {
+    _color;
+    constructor(color) {
+        const colorTypes = [
+            {
+                regexp: HEX_COLOR_REGEXP,
+                reader: colorReaders.hexColorReader,
+            },
+            {
+                regexp: SHORT_HEX_COLOR_REGEXP,
+                reader: colorReaders.shortHeColorReader,
+            },
+        ];
+        this._color = void 0;
+        for (let i = 0; i < colorTypes.length; i += 1) {
+            if (color.match(colorTypes[i].regexp)) {
+                const Reader = colorTypes[i].reader;
+                this._color = new Reader().read(color);
+                break;
+            }
+        }
+        if (!this._color) {
+            throw new Error('Error while color initialization: unknown type of color presentation');
+        }
+    }
+    red() {
+        return this._color[COLOR_RED_KEY];
+    }
+    green() {
+        return this._color[COLOR_GREEN_KEY];
+    }
+    blue() {
+        return this._color[COLOR_BLUE_KEY];
+    }
+}

package/build/contrib/systems/webgl-render-system/consts.d.ts

@@ -0,0 +1,9 @@
+export declare const MAX_COLOR_NUMBER = 255;
+export declare const DRAW_OFFSET = 0;
+export declare const DRAW_COUNT = 6;
+export declare const STD_SCREEN_SIZE = 1080;
+export declare const VECTOR_2_SIZE = 2;
+export declare const BYTES_PER_VECTOR_2: number;
+export declare const VERTEX_STRIDE: number;
+export declare const VERTEX_DATA_STRIDE: number;
+export declare const BUFFER_SIZE: number;

package/build/contrib/systems/webgl-render-system/consts.js

@@ -0,0 +1,9 @@
+export const MAX_COLOR_NUMBER = 255;
+export const DRAW_OFFSET = 0;
+export const DRAW_COUNT = 6;
+export const STD_SCREEN_SIZE = 1080;
+export const VECTOR_2_SIZE = 2;
+export const BYTES_PER_VECTOR_2 = Float32Array.BYTES_PER_ELEMENT * VECTOR_2_SIZE;
+export const VERTEX_STRIDE = VECTOR_2_SIZE * 2;
+export const VERTEX_DATA_STRIDE = VERTEX_STRIDE * DRAW_COUNT;
+export const BUFFER_SIZE = VERTEX_DATA_STRIDE * Float32Array.BYTES_PER_ELEMENT;

package/build/contrib/systems/webgl-render-system/geometry/rectangle.d.ts

@@ -0,0 +1,6 @@
+export declare class Rectangle {
+    private _width;
+    private _height;
+    constructor(width: number, height: number);
+    toArray(): number[];
+}

package/build/contrib/systems/webgl-render-system/geometry/rectangle.js

@@ -0,0 +1,22 @@
+export class Rectangle {
+    _width;
+    _height;
+    constructor(width, height) {
+        this._width = width;
+        this._height = height;
+    }
+    toArray() {
+        const x1 = 0;
+        const y1 = 0;
+        const x2 = x1 + this._width;
+        const y2 = y1 + this._height;
+        return [
+            x1, y1,
+            x2, y1,
+            x1, y2,
+            x1, y2,
+            x2, y1,
+            x2, y2,
+        ];
+    }
+}

package/build/contrib/systems/webgl-render-system/index.d.ts

@@ -0,0 +1,66 @@
+import { System } from '../../../engine/system';
+import type { SystemOptions } from '../../../engine/system';
+import { Renderable } from '../../components/renderable';
+interface WebGLRendererOptions extends SystemOptions {
+    windowNodeId: string;
+    textureAtlas: string;
+    textureAtlasDescriptor: string;
+    backgroundColor: string;
+    sortingLayers: Array<string>;
+    scaleSensitivity: number;
+}
+export { TextureDescriptor } from './texture-handlers';
+export declare class RenderSystem extends System {
+    private textureAtlasSrc;
+    private textureAtlasDescriptorSrc;
+    private textureAtlas?;
+    private textureAtlasSize;
+    private textureAtlasDescriptor;
+    private textureHandlers;
+    private _matrixTransformer;
+    private _backgroundColor;
+    private _view;
+    private _viewWidth;
+    private _viewHeight;
+    private _windowDidResize;
+    private _onWindowResizeBind;
+    private _shaders;
+    private shaderProvider;
+    private _actorCollection;
+    private _scaleSensitivity;
+    private _screenScale;
+    private _vaoExt;
+    private _buffer;
+    private _vao;
+    private _geometry;
+    private _viewMatrixStats;
+    private _vertexData;
+    private gl;
+    private program;
+    private textures;
+    private _variables;
+    private sortFn;
+    private resourceLoader;
+    private cameraService;
+    constructor(options: WebGLRendererOptions);
+    mount(): void;
+    unmount(): void;
+    load(): Promise<void>;
+    private handleActorRemove;
+    _onWindowResize(): void;
+    _initGraphicContext(): WebGL2RenderingContext;
+    _initExtensions(): void;
+    _initScreen(): void;
+    _initShaders(): WebGLProgram;
+    _initProgramInfo(): void;
+    _createVAO(): WebGLVertexArrayObjectOES | null;
+    _setUpGlobalUniforms(): void;
+    _initTextures(): WebGLTexture | null;
+    _getModelViewMatrix(renderable: Renderable, x: number, y: number, rotation: number, scaleX: number, scaleY: number): import("./matrix-transformer").Matrix3x3;
+    private resizeCanvas;
+    private updateViewMatrix;
+    private setUpBuffers;
+    private setUpVertexData;
+    private setUpUniforms;
+    update(): void;
+}