dacha 0.13.0

package/build/engine/data-lib/queue.js

@@ -0,0 +1,34 @@
+export class Queue {
+    head;
+    tail;
+    constructor() {
+        this.head = null;
+        this.tail = null;
+    }
+    add(value) {
+        const node = { next: null, value };
+        if (this.tail === null) {
+            this.head = node;
+            this.tail = node;
+            return;
+        }
+        this.tail.next = node;
+        this.tail = node;
+    }
+    poll() {
+        if (this.head === null) {
+            return null;
+        }
+        const node = this.head;
+        if (this.head === this.tail) {
+            this.head = null;
+            this.tail = null;
+            return node.value;
+        }
+        this.head = this.head.next;
+        return node.value;
+    }
+    peek() {
+        return this.head ? this.head.value : null;
+    }
+}

package/build/engine/data-lib/sort/index.d.ts

@@ -0,0 +1 @@
+export { insertionSort } from './insertion-sort';

package/build/engine/data-lib/sort/index.js

@@ -0,0 +1 @@
+export { insertionSort } from './insertion-sort';

package/build/engine/data-lib/sort/insertion-sort.d.ts

@@ -0,0 +1 @@
+export declare const insertionSort: <T>(array: T[], compareFn: (arg1: T, arg2: T) => number) => T[];

package/build/engine/data-lib/sort/insertion-sort.js

@@ -0,0 +1,14 @@
+export const insertionSort = (array, compareFn) => {
+    let i = 1;
+    while (i < array.length) {
+        let j = i;
+        const x = array[j];
+        while (j > 0 && compareFn(x, array[j - 1]) < 0) {
+            array[j] = array[j - 1];
+            j -= 1;
+        }
+        array[j] = x;
+        i += 1;
+    }
+    return array;
+};

package/build/engine/engine.d.ts

@@ -0,0 +1,22 @@
+import type { SystemConstructor } from './system';
+import type { ComponentConstructor } from './component';
+import type { Config } from './types';
+export interface EngineOptions {
+    config: Config;
+    systems: Array<SystemConstructor>;
+    components: Array<ComponentConstructor>;
+    resources?: Record<string, unknown>;
+}
+export declare class Engine {
+    private options;
+    private gameLoop?;
+    private sceneProvider?;
+    constructor(options: EngineOptions);
+    private handleWindowBlur;
+    private handleWindowFocus;
+    private addWindowListeners;
+    private removeWindowListeners;
+    play(): Promise<void>;
+    pause(): void;
+    stop(): void;
+}

package/build/engine/engine.js

@@ -0,0 +1,89 @@
+import { SceneProvider } from './scene/scene-provider';
+import { ActorCreator } from './actor';
+import { TemplateCollection } from './template';
+import { GameLoop } from './game-loop';
+import { SceneController } from './controllers';
+export class Engine {
+    options;
+    gameLoop;
+    sceneProvider;
+    constructor(options) {
+        this.options = options;
+    }
+    handleWindowBlur = () => {
+        this.gameLoop?.stop();
+    };
+    handleWindowFocus = () => {
+        this.gameLoop?.run();
+    };
+    addWindowListeners() {
+        window.addEventListener('blur', this.handleWindowBlur);
+        window.addEventListener('focus', this.handleWindowFocus);
+    }
+    removeWindowListeners() {
+        window.removeEventListener('blur', this.handleWindowBlur);
+        window.removeEventListener('focus', this.handleWindowFocus);
+    }
+    async play() {
+        if (this.sceneProvider !== undefined && this.gameLoop !== undefined) {
+            this.gameLoop.run();
+            this.addWindowListeners();
+            return;
+        }
+        const { config: { templates, scenes, levels, loaders, startSceneId, startLoaderId, globalOptions, }, systems, components, resources = {}, } = this.options;
+        if (!startSceneId) {
+            throw new Error('Can\'t start the engine without starting scene. Please specify start scene id.');
+        }
+        for (let i = 0; i < components.length; i += 1) {
+            if (components[i].componentName === undefined) {
+                throw new Error(`Missing componentName field for ${components[i].name} component.`);
+            }
+        }
+        for (let i = 0; i < systems.length; i += 1) {
+            if (systems[i].systemName === undefined) {
+                throw new Error(`Missing systemName field for ${systems[i].name} system.`);
+            }
+        }
+        const templateCollection = new TemplateCollection(components);
+        for (let i = 0; i < templates.length; i += 1) {
+            templateCollection.register(templates[i]);
+        }
+        const actorCreator = new ActorCreator(components, templateCollection);
+        this.sceneProvider = new SceneProvider({
+            scenes,
+            levels,
+            loaders,
+            systems,
+            resources,
+            globalOptions,
+            actorCreator,
+            templateCollection,
+        });
+        await this.sceneProvider.prepareLoaders();
+        const asyncLoading = this.sceneProvider.loadScene({
+            sceneId: startSceneId,
+            loaderId: startLoaderId,
+            levelId: null,
+        });
+        if (asyncLoading && !startLoaderId) {
+            await asyncLoading;
+            this.sceneProvider.moveToLoaded();
+        }
+        this.gameLoop = new GameLoop(this.sceneProvider, [
+            new SceneController({ sceneProvider: this.sceneProvider }),
+        ]);
+        this.gameLoop.run();
+        this.addWindowListeners();
+    }
+    pause() {
+        this.gameLoop?.stop();
+        this.removeWindowListeners();
+    }
+    stop() {
+        this.gameLoop?.stop();
+        this.sceneProvider?.leaveCurrentScene();
+        this.removeWindowListeners();
+        this.gameLoop = undefined;
+        this.sceneProvider = undefined;
+    }
+}

package/build/engine/entity/entity.d.ts

@@ -0,0 +1,17 @@
+import { EventTarget } from '../event-target';
+export interface EntityOptions {
+    id: string;
+    name: string;
+}
+export declare class Entity extends EventTarget {
+    readonly id: string;
+    readonly name: string;
+    children: Array<Entity>;
+    parent: Entity | null;
+    constructor({ id, name }: EntityOptions);
+    appendChild(child: Entity): void;
+    removeChild(child: Entity): void;
+    remove(): void;
+    getEntityById(id: string): Entity | undefined;
+    getEntityByName(name: string): Entity | undefined;
+}

package/build/engine/entity/entity.js

@@ -0,0 +1,40 @@
+import { EventTarget } from '../event-target';
+import { AddChildEntity, RemoveChildEntity } from '../events';
+import { findEntity } from './utils';
+export class Entity extends EventTarget {
+    id;
+    name;
+    children;
+    constructor({ id, name }) {
+        super();
+        this.id = id;
+        this.name = name;
+        this.children = [];
+    }
+    appendChild(child) {
+        child.parent = this;
+        this.children.push(child);
+        this.dispatchEventImmediately(AddChildEntity, { child });
+    }
+    removeChild(child) {
+        const index = this.children.findIndex((currentChild) => currentChild === child);
+        if (index === -1) {
+            return;
+        }
+        child.parent = null;
+        this.children.splice(index, 1);
+        this.dispatchEventImmediately(RemoveChildEntity, { child });
+    }
+    remove() {
+        if (this.parent === null) {
+            return;
+        }
+        this.parent.removeChild(this);
+    }
+    getEntityById(id) {
+        return findEntity(this, (entity) => entity.id === id);
+    }
+    getEntityByName(name) {
+        return findEntity(this, (entity) => entity.name === name);
+    }
+}

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

@@ -0,0 +1,3 @@
+export { Entity } from './entity';
+export type { EntityOptions } from './entity';
+export { traverseEntity, findEntity } from './utils';

package/build/engine/entity/index.js

@@ -0,0 +1,2 @@
+export { Entity } from './entity';
+export { traverseEntity, findEntity } from './utils';

package/build/engine/entity/utils.d.ts

@@ -0,0 +1,3 @@
+import type { Entity } from './entity';
+export declare const traverseEntity: <T extends Entity>(entity: T, callback: (entity: T) => void) => void;
+export declare const findEntity: <T extends Entity>(entity: T, predicate: (entity: T) => boolean) => T | undefined;

package/build/engine/entity/utils.js

@@ -0,0 +1,26 @@
+import { Queue } from '../data-lib';
+export const traverseEntity = (entity, callback) => {
+    const queue = new Queue();
+    queue.add(entity);
+    while (queue.peek() !== null) {
+        const currentEntity = queue.poll();
+        callback(currentEntity);
+        currentEntity.children.forEach((child) => {
+            queue.add(child);
+        });
+    }
+};
+export const findEntity = (entity, predicate) => {
+    const queue = new Queue();
+    queue.add(entity);
+    while (queue.peek() !== null) {
+        const currentEntity = queue.poll();
+        if (predicate(currentEntity)) {
+            return currentEntity;
+        }
+        currentEntity.children.forEach((child) => {
+            queue.add(child);
+        });
+    }
+    return undefined;
+};

package/build/engine/event-target/event-queue.d.ts

@@ -0,0 +1,9 @@
+type EventExecutor = () => void;
+export declare class EventQueue {
+    private executorQueue;
+    constructor();
+    add(executor: EventExecutor): void;
+    update(): void;
+}
+export declare const eventQueue: EventQueue;
+export {};

package/build/engine/event-target/event-queue.js

@@ -0,0 +1,16 @@
+import { Queue } from '../data-lib';
+export class EventQueue {
+    executorQueue;
+    constructor() {
+        this.executorQueue = new Queue();
+    }
+    add(executor) {
+        this.executorQueue.add(executor);
+    }
+    update() {
+        while (this.executorQueue.peek() !== null) {
+            this.executorQueue.poll()?.();
+        }
+    }
+}
+export const eventQueue = new EventQueue();

package/build/engine/event-target/event-target.d.ts

@@ -0,0 +1,13 @@
+import type { EventType, ListenerFn } from './types';
+export declare class EventTarget {
+    parent: EventTarget | null;
+    private listenersMap;
+    constructor();
+    addEventListener(type: EventType, callback: ListenerFn): void;
+    getEventListeners(type: EventType): Array<ListenerFn> | undefined;
+    removeEventListener(type: EventType, callback: ListenerFn): void;
+    removeAllListeners(): void;
+    private handleEvent;
+    dispatchEvent(type: EventType, payload?: Record<string, unknown>): void;
+    dispatchEventImmediately(type: EventType, payload?: Record<string, unknown>): void;
+}

package/build/engine/event-target/event-target.js

@@ -0,0 +1,59 @@
+import { eventQueue } from './event-queue';
+export class EventTarget {
+    parent;
+    listenersMap;
+    constructor() {
+        this.listenersMap = new Map();
+        this.parent = null;
+    }
+    addEventListener(type, callback) {
+        if (!this.listenersMap.has(type)) {
+            this.listenersMap.set(type, []);
+        }
+        this.listenersMap.get(type)?.push(callback);
+    }
+    getEventListeners(type) {
+        return this.listenersMap.get(type);
+    }
+    removeEventListener(type, callback) {
+        if (!this.listenersMap.has(type)) {
+            return;
+        }
+        const nextListeners = this.listenersMap.get(type).filter((listener) => listener !== callback);
+        if (nextListeners.length === 0) {
+            this.listenersMap.delete(type);
+        }
+        else {
+            this.listenersMap.set(type, nextListeners);
+        }
+    }
+    removeAllListeners() {
+        this.listenersMap.clear();
+    }
+    handleEvent(type, payload) {
+        let isPropagationStopped = false;
+        const stopPropagation = () => {
+            isPropagationStopped = true;
+        };
+        const event = {
+            ...payload,
+            type,
+            target: this,
+            currentTarget: this,
+            stopPropagation,
+        };
+        let target = this;
+        while (target !== null && !isPropagationStopped) {
+            event.currentTarget = target;
+            const listeners = target.getEventListeners(type);
+            listeners?.forEach((listener) => listener(event));
+            target = target.parent;
+        }
+    }
+    dispatchEvent(type, payload) {
+        eventQueue.add(this.handleEvent.bind(this, type, payload));
+    }
+    dispatchEventImmediately(type, payload) {
+        this.handleEvent(type, payload);
+    }
+}

package/build/engine/event-target/index.d.ts

@@ -0,0 +1,4 @@
+export { EventTarget } from './event-target';
+export { eventQueue } from './event-queue';
+export type { EventQueue } from './event-queue';
+export type { Event, EventType, EventPayload, ListenerFn, } from './types';

package/build/engine/event-target/index.js

@@ -0,0 +1,2 @@
+export { EventTarget } from './event-target';
+export { eventQueue } from './event-queue';

package/build/engine/event-target/types.d.ts

@@ -0,0 +1,12 @@
+import type { EventTarget } from './event-target';
+export type EventType = string | symbol;
+export interface Event<T = EventTarget> {
+    type: EventType;
+    target: T;
+    currentTarget: EventTarget;
+    stopPropagation: () => void;
+}
+type EventField = 'type' | 'target' | 'currentTarget' | 'stopPropagation';
+export type ListenerFn = (event: Event) => void;
+export type EventPayload<T, K> = K extends keyof T ? Record<string, never> extends Omit<T[K], EventField> ? [Omit<T[K], EventField>?] : [Omit<T[K], EventField>] : [Record<string, unknown>?];
+export {};

package/build/engine/event-target/types.js

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

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

@@ -0,0 +1,51 @@
+import type { SceneLoadOptions, LevelLoadOptions } from '../scene';
+import type { Actor } from '../actor';
+import type { ActorEvent, SceneEvent } from '../../types/events';
+import type { Event } from '../event-target';
+import type { Entity } from '../entity';
+export declare const AddChildEntity = "AddChildEntity";
+export declare const RemoveChildEntity = "RemoveChildEntity";
+export declare const AddActor = "AddActor";
+export declare const RemoveActor = "RemoveActor";
+export declare const LoadScene = "LoadScene";
+export declare const LoadLevel = "LoadLevel";
+export declare const AddComponent = "AddComponent";
+export declare const RemoveComponent = "RemoveComponent";
+export type AddChildEntityEvent = Event<Entity> & {
+    child: Entity;
+};
+export type RemoveChildEntityEvent = Event<Entity> & {
+    child: Entity;
+};
+export type AddComponentEvent = ActorEvent<{
+    componentName: string;
+}>;
+export type RemoveComponentEvent = ActorEvent<{
+    componentName: string;
+}>;
+export type AddActorEvent = SceneEvent<{
+    actor: Actor;
+}>;
+export type RemoveActorEvent = SceneEvent<{
+    actor: Actor;
+}>;
+export type LoadSceneEvent = SceneEvent<SceneLoadOptions>;
+export type LoadLevelEvent = SceneEvent<LevelLoadOptions>;
+export interface ActorCollectionEventMap {
+    [AddActor]: AddActorEvent;
+    [RemoveActor]: RemoveActorEvent;
+}
+export interface EntityEventMap {
+    [AddChildEntity]: AddChildEntityEvent;
+    [RemoveChildEntity]: RemoveChildEntityEvent;
+}
+declare module '../../types/events' {
+    interface SceneEventMap extends EntityEventMap {
+        [LoadScene]: LoadSceneEvent;
+        [LoadLevel]: LoadLevelEvent;
+    }
+    interface ActorEventMap extends EntityEventMap {
+        [AddComponent]: AddComponentEvent;
+        [RemoveComponent]: RemoveComponentEvent;
+    }
+}

package/build/engine/events/index.js

@@ -0,0 +1,8 @@
+export const AddChildEntity = 'AddChildEntity';
+export const RemoveChildEntity = 'RemoveChildEntity';
+export const AddActor = 'AddActor';
+export const RemoveActor = 'RemoveActor';
+export const LoadScene = 'LoadScene';
+export const LoadLevel = 'LoadLevel';
+export const AddComponent = 'AddComponent';
+export const RemoveComponent = 'RemoveComponent';

package/build/engine/game-loop.d.ts

@@ -0,0 +1,14 @@
+import type { SceneProvider } from './scene';
+import type { Controller } from './controllers';
+export declare class GameLoop {
+    private sceneProvider;
+    private controllers;
+    private gameLoopId;
+    private previous;
+    private lag;
+    private bindedTick;
+    constructor(sceneProvider: SceneProvider, controllers: Array<Controller>);
+    private tick;
+    run(): void;
+    stop(): void;
+}

package/build/engine/game-loop.js

@@ -0,0 +1,51 @@
+import { eventQueue } from './event-target';
+const MS_PER_UPDATE = 1000 / 50;
+export class GameLoop {
+    sceneProvider;
+    controllers;
+    gameLoopId;
+    previous;
+    lag;
+    bindedTick;
+    constructor(sceneProvider, controllers) {
+        this.sceneProvider = sceneProvider;
+        this.controllers = controllers;
+        this.gameLoopId = 0;
+        this.previous = 0;
+        this.lag = 0;
+        this.bindedTick = this.tick.bind(this);
+    }
+    tick() {
+        eventQueue.update();
+        const current = performance.now();
+        const elapsed = current - this.previous;
+        this.lag += elapsed;
+        const currentScene = this.sceneProvider.getCurrentScene();
+        const fixedUpdateOptions = { deltaTime: MS_PER_UPDATE };
+        while (this.lag >= MS_PER_UPDATE) {
+            currentScene?.systems.forEach((system) => {
+                system.fixedUpdate?.(fixedUpdateOptions);
+            });
+            this.lag -= MS_PER_UPDATE;
+        }
+        const options = { deltaTime: elapsed };
+        currentScene?.systems.forEach((system) => {
+            system.update?.(options);
+        });
+        this.controllers.forEach((controller) => {
+            controller.update();
+        });
+        this.previous = current;
+        this.gameLoopId = requestAnimationFrame(this.bindedTick);
+    }
+    run() {
+        this.previous = performance.now();
+        this.lag = 0;
+        this.gameLoopId = requestAnimationFrame(this.bindedTick);
+    }
+    stop() {
+        if (this.gameLoopId) {
+            cancelAnimationFrame(this.gameLoopId);
+        }
+    }
+}

package/build/engine/index.d.ts

@@ -0,0 +1 @@
+export { Engine } from './engine';

package/build/engine/index.js

@@ -0,0 +1 @@
+export { Engine } from './engine';

package/build/engine/math-lib/index.d.ts

@@ -0,0 +1,3 @@
+export * from './vector/vector2';
+export * from './vector/ops';
+export * from './math/ops';

package/build/engine/math-lib/index.js

@@ -0,0 +1,3 @@
+export * from './vector/vector2';
+export * from './vector/ops';
+export * from './math/ops';

package/build/engine/math-lib/math/ops.d.ts

@@ -0,0 +1,14 @@
+interface Point {
+    x: number;
+    y: number;
+}
+export declare class MathOps {
+    static random(min: number, max: number): number;
+    static radToDeg(rad: number): number;
+    static degToRad(deg: number): number;
+    static getAngleBetweenTwoPoints(x1: number, x2: number, y1: number, y2: number): number;
+    static getDistanceBetweenTwoPoints(x1: number, x2: number, y1: number, y2: number): number;
+    static getLinePoint(angle: number, x: number, y: number, length: number): Point;
+    static clamp(value: number, min: number, max: number): number;
+}
+export {};

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

@@ -0,0 +1,52 @@
+export class MathOps {
+    /*
+     * Generate random number in [min, max] range
+     */
+    static random(min, max) {
+        return Math.floor(min + (Math.random() * (max + 1 - min)));
+    }
+    /*
+     * Convert radians to degrees
+     */
+    static radToDeg(rad) {
+        const angleInDegrees = (rad * 180) / Math.PI;
+        return angleInDegrees < 0 ? angleInDegrees + 360 : angleInDegrees;
+    }
+    /*
+     * Convert degrees to radians
+     */
+    static degToRad(deg) {
+        return (deg * Math.PI) / 180;
+    }
+    /*
+     * Calculate angle between two point in radians
+     */
+    static getAngleBetweenTwoPoints(x1, x2, y1, y2) {
+        return Math.atan2(y1 - y2, x1 - x2);
+    }
+    /*
+     * Calculate distance between two point
+     */
+    static getDistanceBetweenTwoPoints(x1, x2, y1, y2) {
+        return Math.sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2);
+    }
+    /*
+     * Calculate point on line
+     */
+    static getLinePoint(angle, x, y, length) {
+        const angleInRad = this.degToRad(angle);
+        return {
+            x: x - (length * Math.cos(angleInRad)),
+            y: y - (length * Math.sin(angleInRad)),
+        };
+    }
+    static clamp(value, min, max) {
+        if (value < min) {
+            return min;
+        }
+        if (value > max) {
+            return max;
+        }
+        return value;
+    }
+}

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

@@ -0,0 +1,38 @@
+import { Vector2 } from './vector2';
+type Point = {
+    x: number;
+    y: number;
+};
+type Edge = {
+    point1: Point;
+    point2: Point;
+};
+export declare class VectorOps {
+    static fixCalcError(value: number): number;
+    static getVectorByAngle(angle: number): Vector2;
+    static getNormal(x1: number, x2: number, y1: number, y2: number): Vector2;
+    static dotProduct(point: Point, vector: Vector2): number;
+    /**
+     * 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: Point, edge: Edge): Point;
+    /**
+     * 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: Point, polygon: Edge[]) => boolean;
+}
+export {};