dacha 0.13.0

package/build/engine/math-lib/vector/ops.js

@@ -0,0 +1,76 @@
+import { Vector2 } from './vector2';
+export class VectorOps {
+    static fixCalcError(value) {
+        return Math.abs(value) < Number.EPSILON ? 0 : value;
+    }
+    /*
+     * Calculate vector by angle in radians
+     */
+    static getVectorByAngle(angle) {
+        const x = this.fixCalcError(Math.cos(angle));
+        const y = this.fixCalcError(Math.sin(angle));
+        return new Vector2(x, y);
+    }
+    /*
+     * Calculate normal by line segment
+     */
+    static getNormal(x1, x2, y1, y2) {
+        const normal = new Vector2(y1 - y2, x2 - x1);
+        normal.multiplyNumber(1 / normal.magnitude);
+        return normal;
+    }
+    /*
+     * Calculate dot product of two vectors
+     */
+    static dotProduct(point, vector) {
+        return (point.x * vector.x) + (point.y * vector.y);
+    }
+    /**
+     * Projects a point onto a given edge, returning the closest point
+     *
+     * @param {Point} point - The point to project. Should have properties `x` and `y`.
+     * @param {Edge} edge - The edge to project onto, defined by two endpoints `point1` and `point2`.
+     *                      Each endpoint should have properties `x` and `y`.
+     * @returns {Point} The projected point on the edge, with `x` and `y` coordinates.
+     */
+    static projectPointToEdge(point, edge) {
+        const abVector = new Vector2(edge.point2.x - edge.point1.x, edge.point2.y - edge.point1.y);
+        const apVector = new Vector2(point.x - edge.point1.x, point.y - edge.point1.y);
+        const dotProduct = VectorOps.dotProduct(apVector, abVector);
+        const lengthSquared = abVector.x * abVector.x + abVector.y * abVector.y;
+        const t = dotProduct / lengthSquared;
+        return {
+            x: edge.point1.x + t * abVector.x,
+            y: edge.point1.y + t * abVector.y,
+        };
+    }
+    /**
+     * Determines if a point is inside a polygon.
+     *
+     * @param {Point} point - The point to test. Should have properties `x` and `y`.
+     * @param {Edge[]} polygon - An array of edges representing the polygon.
+     *                           Each edge is defined by two endpoints `point1` and `point2`,
+     *                           where each endpoint has properties `x` and `y`.
+     * @returns {boolean} Returns `true` if the point is inside the polygon, otherwise `false`.
+     *
+     * @note The algorithm may be inaccurate in edge cases,
+     *       such as when the point lies exactly on a polygon corner.
+     */
+    static isPointInPolygon = (point, polygon) => {
+        const { x, y } = point;
+        let isInside = false;
+        for (const edge of polygon) {
+            const x1 = edge.point1.x;
+            const y1 = edge.point1.y;
+            const x2 = edge.point2.x;
+            const y2 = edge.point2.y;
+            // https://en.wikipedia.org/wiki/Linear_equation#Determinant_form
+            const isIntersection = (y1 > y !== y2 > y)
+                && (x < ((x2 - x1) * (y - y1)) / (y2 - y1) + x1);
+            if (isIntersection) {
+                isInside = !isInside;
+            }
+        }
+        return isInside;
+    };
+}

package/build/engine/math-lib/vector/vector2.d.ts

@@ -0,0 +1,10 @@
+export declare class Vector2 {
+    x: number;
+    y: number;
+    constructor(x: number, y: number);
+    get magnitude(): number;
+    add(vector: Vector2): void;
+    multiplyNumber(number: number): void;
+    equals(vector: Vector2): boolean;
+    clone(): Vector2;
+}

package/build/engine/math-lib/vector/vector2.js

@@ -0,0 +1,25 @@
+export class Vector2 {
+    x;
+    y;
+    constructor(x, y) {
+        this.x = x;
+        this.y = y;
+    }
+    get magnitude() {
+        return Math.sqrt(Math.pow(this.x, 2) + Math.pow(this.y, 2));
+    }
+    add(vector) {
+        this.x += vector.x;
+        this.y += vector.y;
+    }
+    multiplyNumber(number) {
+        this.x *= number;
+        this.y *= number;
+    }
+    equals(vector) {
+        return this.x === vector.x && this.y === vector.y;
+    }
+    clone() {
+        return new Vector2(this.x, this.y);
+    }
+}

package/build/engine/resource-loader/index.d.ts

@@ -0,0 +1 @@
+export { ResourceLoader } from './resource-loader';

package/build/engine/resource-loader/index.js

@@ -0,0 +1 @@
+export { ResourceLoader } from './resource-loader';

package/build/engine/resource-loader/loaders/image-loader.d.ts

@@ -0,0 +1,7 @@
+import type { Loader } from './loader';
+export declare class ImageLoader implements Loader {
+    private supportedExtensions;
+    constructor();
+    getSupportedExtensions(): Array<string>;
+    load(resourceUrl: string): Promise<unknown>;
+}

package/build/engine/resource-loader/loaders/image-loader.js

@@ -0,0 +1,21 @@
+export class ImageLoader {
+    supportedExtensions;
+    constructor() {
+        this.supportedExtensions = ['.png'];
+    }
+    getSupportedExtensions() {
+        return this.supportedExtensions;
+    }
+    load(resourceUrl) {
+        return new Promise((resolve, reject) => {
+            const image = new Image();
+            image.src = resourceUrl;
+            image.onload = () => {
+                resolve(image);
+            };
+            image.onerror = () => {
+                reject(new Error('Failed to load image'));
+            };
+        });
+    }
+}

package/build/engine/resource-loader/loaders/index.d.ts

@@ -0,0 +1,4 @@
+import type { Loader } from './loader';
+export declare const loaders: Record<string, {
+    new (): Loader;
+}>;

package/build/engine/resource-loader/loaders/index.js

@@ -0,0 +1,6 @@
+import { ImageLoader } from './image-loader';
+import { JsonLoader } from './json-loader';
+export const loaders = {
+    imageLoader: ImageLoader,
+    jsonLoader: JsonLoader,
+};

package/build/engine/resource-loader/loaders/json-loader.d.ts

@@ -0,0 +1,7 @@
+import { Loader } from './loader';
+export declare class JsonLoader implements Loader {
+    private supportedExtensions;
+    constructor();
+    getSupportedExtensions(): Array<string>;
+    load(resourceUrl: string): Promise<unknown>;
+}

package/build/engine/resource-loader/loaders/json-loader.js

@@ -0,0 +1,14 @@
+export class JsonLoader {
+    supportedExtensions;
+    constructor() {
+        this.supportedExtensions = ['.json'];
+    }
+    getSupportedExtensions() {
+        return this.supportedExtensions;
+    }
+    load(resourceUrl) {
+        return fetch(resourceUrl)
+            .then((response) => response.json())
+            .catch((error) => new Error(`Failed to load json: ${error.message}`));
+    }
+}

package/build/engine/resource-loader/loaders/loader.d.ts

@@ -0,0 +1,4 @@
+export interface Loader {
+    getSupportedExtensions(): Array<string>;
+    load(resourceUrl: string): Promise<unknown>;
+}

package/build/engine/resource-loader/loaders/loader.js

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

package/build/engine/resource-loader/resource-loader-qualifier.d.ts

@@ -0,0 +1,7 @@
+import type { Loader } from './loaders/loader';
+export declare class ResourceLoaderQualifier {
+    private loaders;
+    constructor();
+    private getResourceExt;
+    getLoader(resourceUrl: string): Loader | undefined;
+}

package/build/engine/resource-loader/resource-loader-qualifier.js

@@ -0,0 +1,18 @@
+import { loaders } from './loaders';
+const EXT_SEPARATOR = '.';
+export class ResourceLoaderQualifier {
+    loaders;
+    constructor() {
+        this.loaders = Object.keys(loaders).map((loaderName) => {
+            const Loader = loaders[loaderName];
+            return new Loader();
+        });
+    }
+    getResourceExt(resourceUrl) {
+        return `${EXT_SEPARATOR}${resourceUrl.split(EXT_SEPARATOR).pop()}`;
+    }
+    getLoader(resourceUrl) {
+        const resourceExt = this.getResourceExt(resourceUrl);
+        return this.loaders.find((loader) => loader.getSupportedExtensions().includes(resourceExt));
+    }
+}

package/build/engine/resource-loader/resource-loader.d.ts

@@ -0,0 +1,5 @@
+export declare class ResourceLoader {
+    private resourceLoaderQualifier;
+    constructor();
+    load(resourceUrl: string): Promise<unknown>;
+}

package/build/engine/resource-loader/resource-loader.js

@@ -0,0 +1,17 @@
+import { ResourceLoaderQualifier } from './resource-loader-qualifier';
+export class ResourceLoader {
+    resourceLoaderQualifier;
+    constructor() {
+        this.resourceLoaderQualifier = new ResourceLoaderQualifier();
+    }
+    load(resourceUrl) {
+        if (!resourceUrl) {
+            return Promise.reject();
+        }
+        const loader = this.resourceLoaderQualifier.getLoader(resourceUrl);
+        if (!loader) {
+            return Promise.reject();
+        }
+        return loader.load(resourceUrl);
+    }
+}

package/build/engine/scene/index.d.ts

@@ -0,0 +1,3 @@
+export { Scene } from './scene';
+export { SceneProvider } from './scene-provider';
+export type { SceneLoadOptions, LevelLoadOptions } from './scene-provider';

package/build/engine/scene/index.js

@@ -0,0 +1,2 @@
+export { Scene } from './scene';
+export { SceneProvider } from './scene-provider';

package/build/engine/scene/scene-provider.d.ts

@@ -0,0 +1,50 @@
+import type { SceneConfig, LevelConfig, GlobalOption } from '../types';
+import type { ActorCreator } from '../actor';
+import type { SystemConstructor } from '../system';
+import type { TemplateCollection } from '../template';
+import { Scene } from './scene';
+interface SceneProviderOptions {
+    scenes: Array<SceneConfig>;
+    loaders: Array<SceneConfig>;
+    levels: Array<LevelConfig>;
+    systems: Array<SystemConstructor>;
+    resources: Record<string, unknown>;
+    globalOptions: Array<GlobalOption>;
+    actorCreator: ActorCreator;
+    templateCollection: TemplateCollection;
+}
+export interface SceneLoadOptions {
+    sceneId: string;
+    loaderId: string | null;
+    levelId: string | null;
+    clean?: boolean;
+    unloadCurrent?: boolean;
+}
+export interface LevelLoadOptions {
+    levelId: string;
+    loaderId: string | null;
+}
+export declare class SceneProvider {
+    private availableScenes;
+    private availableLoaders;
+    private availableLevels;
+    private systems;
+    private resources;
+    private globalOptions;
+    private sceneContainer;
+    private currentSceneId?;
+    private loadedScene?;
+    private actorCreator;
+    private templateCollection;
+    constructor({ scenes, levels, systems, loaders, resources, globalOptions, actorCreator, templateCollection, }: SceneProviderOptions);
+    prepareLoaders(): Promise<Array<Array<void>>>;
+    getCurrentScene(): Scene | undefined;
+    loadScene({ sceneId, loaderId, levelId, clean, unloadCurrent, }: SceneLoadOptions): Promise<void> | undefined;
+    loadLevel({ levelId, loaderId }: LevelLoadOptions): Promise<void> | undefined;
+    isLoaded(): boolean;
+    moveToLoaded(): void;
+    leaveCurrentScene(): void;
+    private setCurrentScene;
+    private removeScene;
+}
+export {};

package/build/engine/scene/scene-provider.js

@@ -0,0 +1,151 @@
+import { Scene } from './scene';
+export class SceneProvider {
+    availableScenes;
+    availableLoaders;
+    availableLevels;
+    systems;
+    resources;
+    globalOptions;
+    sceneContainer;
+    currentSceneId;
+    loadedScene;
+    actorCreator;
+    templateCollection;
+    constructor({ scenes, levels, systems, loaders, resources, globalOptions, actorCreator, templateCollection, }) {
+        this.sceneContainer = {};
+        this.currentSceneId = void '';
+        this.availableScenes = scenes.reduce((acc, scene) => {
+            acc[scene.id] = scene;
+            return acc;
+        }, {});
+        this.availableLoaders = loaders.reduce((acc, scene) => {
+            acc[scene.id] = scene;
+            return acc;
+        }, {});
+        this.availableLevels = levels.reduce((acc, level) => {
+            acc[level.id] = level;
+            return acc;
+        }, {});
+        this.systems = systems;
+        this.resources = resources;
+        this.globalOptions = globalOptions.reduce((acc, option) => {
+            acc[option.name] = option.value;
+            return acc;
+        }, {});
+        this.loadedScene = void 0;
+        this.actorCreator = actorCreator;
+        this.templateCollection = templateCollection;
+    }
+    prepareLoaders() {
+        this.sceneContainer = Object.keys(this.availableLoaders)
+            .reduce((acc, id) => {
+            const loaderConfig = this.availableLoaders[id];
+            acc[id] = new Scene({
+                ...loaderConfig,
+                actors: loaderConfig.levelId
+                    ? this.availableLevels[loaderConfig.levelId].actors
+                    : [],
+                availableSystems: this.systems,
+                resources: this.resources,
+                globalOptions: this.globalOptions,
+                actorCreator: this.actorCreator,
+                templateCollection: this.templateCollection,
+            });
+            return acc;
+        }, this.sceneContainer);
+        return Promise.all(Object.keys(this.availableLoaders)
+            .reduce((acc, id) => {
+            const asyncLoading = this.sceneContainer[id].load();
+            if (asyncLoading) {
+                acc.push(asyncLoading);
+            }
+            return acc;
+        }, []));
+    }
+    getCurrentScene() {
+        if (!this.currentSceneId) {
+            return void 0;
+        }
+        return this.sceneContainer[this.currentSceneId];
+    }
+    loadScene({ sceneId, loaderId, levelId, clean = false, unloadCurrent = false, }) {
+        if (!this.availableScenes[sceneId]) {
+            throw new Error(`Error while loading the scene. Not found scene with same id: ${sceneId}`);
+        }
+        const { currentSceneId } = this;
+        this.leaveCurrentScene();
+        if (unloadCurrent && currentSceneId) {
+            this.removeScene(currentSceneId);
+        }
+        let scene;
+        if (clean || !this.sceneContainer[sceneId]) {
+            const selectedLevelId = levelId || this.availableScenes[sceneId].levelId;
+            scene = new Scene({
+                ...this.availableScenes[sceneId],
+                actors: selectedLevelId ? this.availableLevels[selectedLevelId].actors : [],
+                availableSystems: this.systems,
+                resources: this.resources,
+                globalOptions: this.globalOptions,
+                actorCreator: this.actorCreator,
+                templateCollection: this.templateCollection,
+            });
+            const asyncLoading = scene.load();
+            if (asyncLoading && loaderId) {
+                this.setCurrentScene(loaderId);
+            }
+            if (asyncLoading) {
+                return asyncLoading.then(() => {
+                    this.loadedScene = scene;
+                });
+            }
+            this.sceneContainer[scene.id] = scene;
+        }
+        else {
+            scene = this.sceneContainer[sceneId];
+        }
+        this.setCurrentScene(scene.id);
+        return void 0;
+    }
+    loadLevel({ levelId, loaderId }) {
+        if (!this.currentSceneId) {
+            throw new Error('Can\'t load the level. Current scene is null');
+        }
+        return this.loadScene({
+            sceneId: this.currentSceneId,
+            levelId,
+            loaderId,
+            clean: true,
+            unloadCurrent: true,
+        });
+    }
+    isLoaded() {
+        return Boolean(this.loadedScene);
+    }
+    moveToLoaded() {
+        if (!this.loadedScene) {
+            return;
+        }
+        this.leaveCurrentScene();
+        const { id } = this.loadedScene;
+        this.sceneContainer[id] = this.loadedScene;
+        this.loadedScene = void 0;
+        this.setCurrentScene(id);
+    }
+    leaveCurrentScene() {
+        if (!this.currentSceneId || !this.sceneContainer[this.currentSceneId]) {
+            return;
+        }
+        this.sceneContainer[this.currentSceneId].unmount();
+        this.currentSceneId = void '';
+    }
+    setCurrentScene(id) {
+        if (!this.sceneContainer[id]) {
+            throw new Error(`Error while setting new scene. Not found scene with same id: ${id}`);
+        }
+        this.currentSceneId = id;
+        this.sceneContainer[this.currentSceneId].mount();
+    }
+    removeScene(id) {
+        delete this.sceneContainer[id];
+    }
+}

package/build/engine/scene/scene.d.ts

@@ -0,0 +1,46 @@
+import type { SceneConfig, ActorConfig } from '../types';
+import type { TemplateCollection } from '../template';
+import type { SystemConstructor } from '../system';
+import { System } from '../system';
+import { Actor, ActorSpawner, ActorCreator } from '../actor';
+import { Entity } from '../entity';
+import type { EntityOptions } from '../entity';
+import type { EventType, Event, EventPayload } from '../event-target';
+import type { SceneEventMap, ActorEventMap } from '../../types/events';
+import type { Constructor } from '../../types/utils';
+type SceneObjectListenerFn<T extends EventType> = (event: T extends keyof SceneEventMap ? SceneEventMap[T] : T extends keyof ActorEventMap ? ActorEventMap[T] : Event) => void;
+interface SceneOptions extends EntityOptions, SceneConfig {
+    actors: Array<ActorConfig>;
+    availableSystems: Array<SystemConstructor>;
+    resources: Record<string, unknown>;
+    globalOptions: Record<string, unknown>;
+    actorCreator: ActorCreator;
+    templateCollection: TemplateCollection;
+}
+export declare class Scene extends Entity {
+    private actorCreator;
+    private availableSystemsMap;
+    private services;
+    readonly children: Array<Actor>;
+    systems: Array<System>;
+    templateCollection: TemplateCollection;
+    actorSpawner: ActorSpawner;
+    data: Record<string, unknown>;
+    parent: null;
+    constructor(options: SceneOptions);
+    addEventListener<T extends EventType>(type: T, callback: SceneObjectListenerFn<T>): void;
+    removeEventListener<T extends EventType>(type: T, callback: SceneObjectListenerFn<T>): void;
+    dispatchEvent<T extends EventType>(type: T, ...payload: EventPayload<SceneEventMap, T>): void;
+    dispatchEventImmediately<T extends EventType>(type: T, ...payload: EventPayload<SceneEventMap, T>): void;
+    appendChild(child: Actor): void;
+    removeChild(child: Actor): void;
+    getEntityById(id: string): Actor | undefined;
+    getEntityByName(name: string): Actor | undefined;
+    load(): Promise<Array<void>> | undefined;
+    mount(): void;
+    unmount(): void;
+    addService(service: object): void;
+    removeService<T>(serviceClass: Constructor<T>): void;
+    getService<T>(serviceClass: Constructor<T>): T;
+}
+export {};

package/build/engine/scene/scene.js

@@ -0,0 +1,98 @@
+import { ActorSpawner, } from '../actor';
+import { Entity } from '../entity';
+export class Scene extends Entity {
+    actorCreator;
+    availableSystemsMap;
+    services;
+    systems;
+    templateCollection;
+    actorSpawner;
+    data;
+    constructor(options) {
+        super(options);
+        const { actors, systems, resources, globalOptions, actorCreator, availableSystems, templateCollection, } = options;
+        this.actorCreator = actorCreator;
+        this.actorSpawner = new ActorSpawner(this.actorCreator);
+        this.templateCollection = templateCollection;
+        this.data = {};
+        this.services = {};
+        actors.forEach((actorOptions) => {
+            this.appendChild(this.actorCreator.create(actorOptions));
+        });
+        this.availableSystemsMap = availableSystems.reduce((acc, AvailableSystem) => {
+            acc[AvailableSystem.systemName] = AvailableSystem;
+            return acc;
+        }, {});
+        this.systems = systems
+            .filter((config) => this.availableSystemsMap[config.name])
+            .map((config) => new this.availableSystemsMap[config.name]({
+            ...config.options,
+            templateCollection: this.templateCollection,
+            actorSpawner: this.actorSpawner,
+            scene: this,
+            resources: resources[config.name],
+            globalOptions,
+        }));
+    }
+    addEventListener(type, callback) {
+        super.addEventListener(type, callback);
+    }
+    removeEventListener(type, callback) {
+        super.removeEventListener(type, callback);
+    }
+    dispatchEvent(type, ...payload) {
+        super.dispatchEvent(type, ...payload);
+    }
+    dispatchEventImmediately(type, ...payload) {
+        super.dispatchEventImmediately(type, ...payload);
+    }
+    appendChild(child) {
+        super.appendChild(child);
+    }
+    removeChild(child) {
+        super.removeChild(child);
+    }
+    getEntityById(id) {
+        return super.getEntityById(id);
+    }
+    getEntityByName(name) {
+        return super.getEntityByName(name);
+    }
+    load() {
+        if (this.systems.every((system) => !system.load)) {
+            return void 0;
+        }
+        return Promise.all(this.systems.map((system) => {
+            if (system.load) {
+                return system.load();
+            }
+            return Promise.resolve();
+        }));
+    }
+    mount() {
+        this.systems.forEach((system) => {
+            if (system.mount) {
+                system.mount();
+            }
+        });
+    }
+    unmount() {
+        this.systems.forEach((system) => {
+            if (system.unmount) {
+                system.unmount();
+            }
+        });
+    }
+    addService(service) {
+        this.services[service.constructor.name] = service;
+    }
+    removeService(serviceClass) {
+        delete this.services[serviceClass.name];
+    }
+    getService(serviceClass) {
+        if (this.services[serviceClass.name] === undefined) {
+            throw new Error(`Can't find service with the following name: ${serviceClass.name}`);
+        }
+        return this.services[serviceClass.name];
+    }
+}

package/build/engine/system/index.d.ts

@@ -0,0 +1,2 @@
+export { System } from './system';
+export type { SystemConstructor, SystemOptions, UpdateOptions, } from './system';

package/build/engine/system/index.js

@@ -0,0 +1 @@
+export { System } from './system';

package/build/engine/system/system.d.ts

@@ -0,0 +1,25 @@
+import type { ActorSpawner } from '../actor';
+import type { TemplateCollection } from '../template';
+import type { Scene } from '../scene';
+import type { Constructor } from '../../types/utils';
+export interface SystemOptions extends Record<string, unknown> {
+    actorSpawner: ActorSpawner;
+    resources?: unknown;
+    globalOptions: Record<string, unknown>;
+    scene: Scene;
+    templateCollection: TemplateCollection;
+}
+export interface UpdateOptions {
+    deltaTime: number;
+}
+export declare abstract class System {
+    static systemName: string;
+    load?(): Promise<void>;
+    mount?(): void;
+    unmount?(): void;
+    update?(options: UpdateOptions): void;
+    fixedUpdate?(options: UpdateOptions): void;
+}
+export type SystemConstructor = Constructor<System> & {
+    systemName: string;
+};

package/build/engine/system/system.js

@@ -0,0 +1,3 @@
+export class System {
+    static systemName;
+}

package/build/engine/template/index.d.ts

@@ -0,0 +1,2 @@
+export { Template } from './template';
+export { TemplateCollection } from './template-collection';

package/build/engine/template/index.js

@@ -0,0 +1,2 @@
+export { Template } from './template';
+export { TemplateCollection } from './template-collection';

package/build/engine/template/template-collection.d.ts

@@ -0,0 +1,13 @@
+import type { ComponentConstructor } from '../component';
+import type { TemplateConfig } from '../types';
+import { Template } from './template';
+export declare class TemplateCollection {
+    private components;
+    private storage;
+    constructor(components: Array<ComponentConstructor>);
+    private buildTemplate;
+    register(options: TemplateConfig): void;
+    get(id: string): Template;
+    getAll(): Array<Template>;
+    delete(id: string): void;
+}