dacha 0.15.2 → 0.16.0

package/build/contrib/systems/renderer/sort/sort-by-x-axis.js

@@ -0,0 +1,9 @@
+export const sortByXAxis = (direction = 1) => (a, b) => {
+    const aComponent = a.__dacha.viewComponent;
+    const bComponent = b.__dacha.viewComponent;
+    const aX = a.__dacha.bounds.maxX;
+    const bX = b.__dacha.bounds.maxX;
+    const aOffsetX = aX + aComponent.sortCenter[0];
+    const bOffsetX = bX + bComponent.sortCenter[0];
+    return (aOffsetX - bOffsetX) * direction;
+};

package/build/contrib/systems/renderer/sort/sort-by-y-axis.d.ts

@@ -0,0 +1,2 @@
+import type { SortFn } from './types';
+export declare const sortByYAxis: (direction?: number) => SortFn;

package/build/contrib/systems/renderer/sort/sort-by-y-axis.js

@@ -0,0 +1,9 @@
+export const sortByYAxis = (direction = 1) => (a, b) => {
+    const aComponent = a.__dacha.viewComponent;
+    const bComponent = b.__dacha.viewComponent;
+    const aY = a.__dacha.bounds.maxY;
+    const bY = b.__dacha.bounds.maxY;
+    const aOffsetY = aY + aComponent.sortCenter[1];
+    const bOffsetY = bY + bComponent.sortCenter[1];
+    return (aOffsetY - bOffsetY) * direction;
+};

package/build/contrib/systems/renderer/sort/types.d.ts

@@ -0,0 +1,2 @@
+import { type ViewContainer } from 'pixi.js';
+export type SortFn = (a: ViewContainer, b: ViewContainer) => number;

package/build/contrib/systems/{sprite-renderer → renderer}/sort/utils.d.ts

@@ -1,2 +1,2 @@
 import type { SortingLayer } from '../types';
-export declare const parseSortingLayers: (sortingLayers?: SortingLayer[]) => Array<string>;
+export declare const parseSortingLayers: (sortingLayers?: SortingLayer[]) => string[];

package/build/contrib/systems/renderer/types.d.ts

@@ -0,0 +1,26 @@
+export interface SortingLayer {
+    id: string;
+    name: string;
+}
+export type SortingOrder = 'bottomRight' | 'bottomLeft' | 'topLeft' | 'topRight';
+export interface Sorting {
+    layers: SortingLayer[];
+    order: SortingOrder;
+}
+export interface Bounds {
+    minX: number;
+    minY: number;
+    maxX: number;
+    maxY: number;
+    width: number;
+    height: number;
+}
+export interface ViewComponent {
+    renderData?: {
+        view: {
+            __dacha: {
+                bounds: Bounds;
+            };
+        };
+    };
+}

package/build/contrib/systems/renderer/types.js

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

package/build/contrib/systems/renderer/utils.d.ts

@@ -0,0 +1,5 @@
+import type { Actor } from '../../../engine/actor';
+import type { Template } from '../../../engine/template';
+export declare const loadImage: (url?: string) => Promise<HTMLImageElement | undefined>;
+export declare const getAllImageSources: (actors: (Actor | Template)[]) => string[];
+export declare const getAllFontSources: (actors: (Actor | Template)[]) => string[];

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

@@ -0,0 +1,42 @@
+import { Sprite } from '../../components/sprite';
+import { BitmapText } from '../../components/bitmap-text';
+import { ResourceLoader } from '../../../engine/resource-loader';
+import { traverseEntity } from '../../../engine/entity';
+const resourceLoader = new ResourceLoader();
+export const loadImage = async (url) => {
+    if (!url) {
+        return undefined;
+    }
+    try {
+        const image = (await resourceLoader.load(url));
+        return image;
+    }
+    catch (error) {
+        console.warn(`Can't load image by the following url: ${url}`, error);
+        return undefined;
+    }
+};
+export const getAllImageSources = (actors) => {
+    const sources = [];
+    actors.forEach((actor) => {
+        traverseEntity(actor, (entity) => {
+            const sprite = entity.getComponent(Sprite);
+            if (sprite?.src) {
+                sources.push(sprite.src);
+            }
+        });
+    });
+    return sources;
+};
+export const getAllFontSources = (actors) => {
+    const sources = [];
+    actors.forEach((actor) => {
+        traverseEntity(actor, (entity) => {
+            const text = entity.getComponent(BitmapText);
+            if (text?.font) {
+                sources.push(text.font);
+            }
+        });
+    });
+    return sources;
+};

package/build/contrib/types/input-events.d.ts

@@ -1,4 +1,4 @@
-export type AttributeValue = string | number | boolean | Array<string>;
+export type AttributeValue = string | number | boolean | string[];
 export type InputEventAttributes = Record<string, AttributeValue>;
 export interface InputEventAttributeConfig {
     name: string;

package/build/contrib/types/view.d.ts

@@ -0,0 +1 @@
+export type BlendingMode = 'normal' | 'addition' | 'substract' | 'multiply';

package/build/contrib/types/view.js

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

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

@@ -6,8 +6,11 @@ import type { ComponentConstructor } from '../component';
 import { Actor } from './actor';
 type ActorCollectionListenerFn<T extends EventType> = (event: T extends keyof ActorCollectionEventMap ? ActorCollectionEventMap[T] : Event) => void;
 export interface ActorCollectionFilter {
-    components?: Array<ComponentConstructor | string>;
+    components?: (ComponentConstructor | string)[];
 }
+/**
+ * @deprecated Use `ActorQuery` instead.
+ */
 export declare class ActorCollection extends EventTarget {
     private components;
     private acceptedActors;

package/build/engine/actor/actor-collection.js

@@ -2,13 +2,16 @@ import { EventTarget } from '../event-target';
 import { AddComponent, RemoveComponent, AddActor, RemoveActor, AddChildEntity, RemoveChildEntity, } from '../events';
 import { traverseEntity } from '../entity';
 import { Actor } from './actor';
+/**
+ * @deprecated Use `ActorQuery` instead.
+ */
 export class ActorCollection extends EventTarget {
     components;
     acceptedActors;
     acceptedActorsMap;
     constructor(scene, filter = {}) {
         super();
-        const { components = [], } = filter;
+        const { components = [] } = filter;
         this.components = components;
         this.acceptedActorsMap = {};
         this.acceptedActors = [];

package/build/engine/actor/actor-creator.d.ts

@@ -5,15 +5,15 @@ import { Actor } from './actor';
 export interface ActorOptions {
     id?: string;
     name?: string;
-    children?: Array<ActorOptions>;
-    components?: Array<ComponentConfig>;
+    children?: ActorOptions[];
+    components?: ComponentConfig[];
     templateId?: string;
     isNew?: boolean;
 }
 export declare class ActorCreator {
     private components;
     private templateCollection;
-    constructor(components: Array<ComponentConstructor>, templateCollection: TemplateCollection);
+    constructor(components: ComponentConstructor[], templateCollection: TemplateCollection);
     private buildFromTemplate;
     private buildFromScratch;
     private build;

package/build/engine/actor/actor-query.d.ts

@@ -0,0 +1,29 @@
+import { EventTarget } from '../event-target';
+import type { EventType, Event } from '../event-target';
+import type { ActorCollectionEventMap } from '../events';
+import type { Scene } from '../scene';
+import type { ComponentConstructor } from '../component';
+import { Actor } from './actor';
+type ActorQueryListenerFn<T extends EventType> = (event: T extends keyof ActorCollectionEventMap ? ActorCollectionEventMap[T] : Event) => void;
+export type ActorQueryFilter = (ComponentConstructor | string)[] | ((actor: Actor) => boolean);
+export interface ActorQueryOptions {
+    scene: Scene;
+    filter: ActorQueryFilter;
+}
+export declare class ActorQuery extends EventTarget {
+    private scene;
+    private filter;
+    private matchedActors;
+    constructor(options: ActorQueryOptions);
+    destroy(): void;
+    addEventListener<T extends EventType>(type: T, callback: ActorQueryListenerFn<T>): void;
+    removeEventListener<T extends EventType>(type: T, callback: ActorQueryListenerFn<T>): void;
+    private handleAddChildEntity;
+    private handleRemoveChildEntity;
+    private handleActorUpdate;
+    private test;
+    private add;
+    private delete;
+    getActors(): Set<Actor>;
+}
+export {};

package/build/engine/actor/actor-query.js

@@ -0,0 +1,85 @@
+import { EventTarget } from '../event-target';
+import { AddComponent, RemoveComponent, AddActor, RemoveActor, AddChildEntity, RemoveChildEntity, } from '../events';
+import { traverseEntity } from '../entity';
+import { Actor } from './actor';
+export class ActorQuery extends EventTarget {
+    scene;
+    filter;
+    matchedActors;
+    constructor(options) {
+        super();
+        const { scene, filter } = options;
+        this.scene = scene;
+        this.filter = filter;
+        this.matchedActors = new Set();
+        traverseEntity(scene, (entity) => {
+            if (entity instanceof Actor && this.test(entity)) {
+                this.matchedActors.add(entity);
+            }
+        });
+        scene.addEventListener(AddChildEntity, this.handleAddChildEntity);
+        scene.addEventListener(RemoveChildEntity, this.handleRemoveChildEntity);
+        scene.addEventListener(AddComponent, this.handleActorUpdate);
+        scene.addEventListener(RemoveComponent, this.handleActorUpdate);
+    }
+    destroy() {
+        this.scene.removeEventListener(AddChildEntity, this.handleAddChildEntity);
+        this.scene.removeEventListener(RemoveChildEntity, this.handleRemoveChildEntity);
+        this.scene.removeEventListener(AddComponent, this.handleActorUpdate);
+        this.scene.removeEventListener(RemoveComponent, this.handleActorUpdate);
+    }
+    addEventListener(type, callback) {
+        super.addEventListener(type, callback);
+    }
+    removeEventListener(type, callback) {
+        super.removeEventListener(type, callback);
+    }
+    handleAddChildEntity = (event) => {
+        traverseEntity(event.child, (entity) => {
+            if (entity instanceof Actor && this.test(entity)) {
+                this.add(entity);
+            }
+        });
+    };
+    handleRemoveChildEntity = (event) => {
+        traverseEntity(event.child, (entity) => {
+            if (entity instanceof Actor) {
+                this.delete(entity);
+            }
+        });
+    };
+    handleActorUpdate = (event) => {
+        const { target } = event;
+        if (this.test(target)) {
+            this.add(target);
+        }
+        else {
+            this.delete(target);
+        }
+    };
+    test(actor) {
+        if (typeof this.filter === 'function') {
+            return this.filter(actor);
+        }
+        return this.filter.every((component) => {
+            return actor.getComponent(component);
+        });
+    }
+    add(actor) {
+        if (this.matchedActors.has(actor)) {
+            return;
+        }
+        this.matchedActors.add(actor);
+        this.dispatchEventImmediately(AddActor, { actor });
+    }
+    delete(actor) {
+        if (!this.matchedActors.has(actor)) {
+            return;
+        }
+        this.matchedActors.delete(actor);
+        this.dispatchEventImmediately(RemoveActor, { actor });
+    }
+    getActors() {
+        return this.matchedActors;
+    }
+}

package/build/engine/actor/actor.d.ts

@@ -10,7 +10,7 @@ export interface ActorOptions extends EntityOptions {
 }
 export declare class Actor extends Entity {
     private components;
-    readonly children: Array<Actor>;
+    readonly children: Actor[];
     readonly templateId?: string;
     parent: Actor | Scene | null;
     constructor(options: ActorOptions);
@@ -23,9 +23,8 @@ export declare class Actor extends Entity {
     findChild(predicate: (child: Actor) => boolean, recursive?: boolean): Actor | undefined;
     findChildById(id: string, recursive?: boolean): Actor | undefined;
     findChildByName(name: string, recursive?: boolean): Actor | undefined;
-    getComponents(): Array<Component>;
-    getComponent<T extends Component = Component>(componentName: string): T;
-    getComponent<T extends Component>(componentClass: ComponentConstructor<T>): T;
+    getComponents(): Component[];
+    getComponent<T extends Component>(classOrName: ComponentConstructor<T> | string): T;
     setComponent(component: Component): void;
     removeComponent(componentClass: ComponentConstructor): void;
 }

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

@@ -3,3 +3,5 @@ export { ActorCollection } from './actor-collection';
 export { ActorCreator } from './actor-creator';
 export { ActorSpawner } from './actor-spawner';
 export type { ActorCollectionFilter } from './actor-collection';
+export { ActorQuery } from './actor-query';
+export type { ActorQueryFilter } from './actor-query';

package/build/engine/actor/index.js

@@ -2,3 +2,4 @@ export { Actor } from './actor';
 export { ActorCollection } from './actor-collection';
 export { ActorCreator } from './actor-creator';
 export { ActorSpawner } from './actor-spawner';
+export { ActorQuery } from './actor-query';

package/build/engine/component/component.d.ts

@@ -3,11 +3,11 @@ import type { Constructor } from '../../types/utils';
 export type ComponentConstructor<T extends Component = Component> = Constructor<T> & {
     componentName: string;
 };
-export declare const findParentComponent: (actor: Actor, componentClass: ComponentConstructor) => Component | void;
+export declare const findParentComponent: (actor: Actor, componentClass: ComponentConstructor) => Component | undefined;
 export declare abstract class Component {
     static componentName: string;
     actor?: Actor;
     constructor();
-    getParentComponent(): Component | void;
+    getParentComponent(): Component | undefined;
     abstract clone(): Component;
 }

package/build/engine/data-lib/cache-store.d.ts

@@ -4,8 +4,9 @@ export declare class CacheStore<T> {
     add(src: string, data: T): void;
     get(src: string): T | undefined;
     retain(src: string): void;
-    release(src: string): void;
+    release(src: string, clean?: boolean): void;
     has(src: string): boolean;
+    get size(): number;
     cleanReleased(): void;
     clear(): void;
 }

package/build/engine/data-lib/cache-store.js

@@ -16,15 +16,21 @@ export class CacheStore {
             entry.count += 1;
         }
     }
-    release(src) {
+    release(src, clean) {
         const entry = this.cache.get(src);
         if (entry) {
             entry.count -= 1;
+            if (clean && entry.count <= 0) {
+                this.cache.delete(src);
+            }
         }
     }
     has(src) {
         return this.cache.has(src);
     }
+    get size() {
+        return this.cache.size;
+    }
     // TODO: It's hard to find a place in a system's lifecycle to call this method
     // Find another way to keep resources until scene is destroyed
     cleanReleased() {

package/build/engine/engine.d.ts

@@ -3,20 +3,42 @@ import type { ComponentConstructor } from './component';
 import type { Config } from './types';
 export interface EngineOptions {
     config: Config;
-    systems: Array<SystemConstructor>;
-    components: Array<ComponentConstructor>;
+    systems: SystemConstructor[];
+    components: ComponentConstructor[];
     resources?: Record<string, unknown>;
 }
+/**
+ * Main game engine responsible for bootstrapping scenes and systems, managing the
+ * game loop, and controlling lifecycle actions (play, pause, stop).
+ */
 export declare class Engine {
     private options;
     private gameLoop?;
     private sceneManager?;
+    /**
+     * Creates a new engine instance.
+     *
+     * @param options - Configuration, available systems and components, and optional shared resources.
+     */
     constructor(options: EngineOptions);
-    private handleWindowBlur;
-    private handleWindowFocus;
-    private addWindowListeners;
-    private removeWindowListeners;
+    /**
+     * Starts the engine. If the engine was already initialized, this resumes the
+     * game loop and re-attaches window listeners. Otherwise, it bootstraps the
+     * world, loads the start scene, creates the game loop, and begins execution.
+     *
+     * @returns A promise that resolves once the engine is fully started.
+     * @throws Error If `startSceneId` is not provided in the config.
+     * @throws Error If any component is missing `componentName`.
+     * @throws Error If any system is missing `systemName`.
+     */
     play(): Promise<void>;
+    /**
+     * Pauses the engine by stopping the game loop.
+     * The world and scene state remain in memory so it can be resumed with `play`.
+     */
     pause(): void;
+    /**
+     * Stops the engine completely by stopping the game loop and destroying the world.
+     */
     stop(): void;
 }

package/build/engine/engine.js

@@ -1,50 +1,54 @@
 import { SceneManager } from './scene/scene-manager';
 import { TemplateCollection } from './template';
 import { GameLoop } from './game-loop';
+/**
+ * Main game engine responsible for bootstrapping scenes and systems, managing the
+ * game loop, and controlling lifecycle actions (play, pause, stop).
+ */
 export class Engine {
     options;
     gameLoop;
     sceneManager;
+    /**
+     * Creates a new engine instance.
+     *
+     * @param options - Configuration, available systems and components, and optional shared resources.
+     */
     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);
-    }
+    /**
+     * Starts the engine. If the engine was already initialized, this resumes the
+     * game loop and re-attaches window listeners. Otherwise, it bootstraps the
+     * world, loads the start scene, creates the game loop, and begins execution.
+     *
+     * @returns A promise that resolves once the engine is fully started.
+     * @throws Error If `startSceneId` is not provided in the config.
+     * @throws Error If any component is missing `componentName`.
+     * @throws Error If any system is missing `systemName`.
+     */
     async play() {
         if (this.sceneManager !== undefined && this.gameLoop !== undefined) {
             this.gameLoop.run();
-            this.addWindowListeners();
             return;
         }
         const { config: { templates, scenes, systems, startSceneId, globalOptions: rawGlobalOptions, }, systems: availableSystems, components, resources = {}, } = this.options;
         if (!startSceneId) {
-            throw new Error('Can\'t start the engine without starting scene. Please specify start scene id.');
+            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 (const component of components) {
+            if (component.componentName === undefined) {
+                throw new Error(`Missing componentName field for ${component.name} component.`);
             }
         }
-        for (let i = 0; i < availableSystems.length; i += 1) {
-            if (availableSystems[i].systemName === undefined) {
-                throw new Error(`Missing systemName field for ${availableSystems[i].name} system.`);
+        for (const availableSystem of availableSystems) {
+            if (availableSystem.systemName === undefined) {
+                throw new Error(`Missing systemName field for ${availableSystem.name} system.`);
             }
         }
         const templateCollection = new TemplateCollection(components);
-        for (let i = 0; i < templates.length; i += 1) {
-            templateCollection.register(templates[i]);
+        for (const template of templates) {
+            templateCollection.register(template);
         }
         const globalOptions = rawGlobalOptions.reduce((acc, option) => {
             acc[option.name] = option.options;
@@ -63,16 +67,20 @@ export class Engine {
         await this.sceneManager.loadScene(startSceneId, true);
         this.gameLoop = new GameLoop(this.sceneManager, globalOptions.performance);
         this.gameLoop.run();
-        this.addWindowListeners();
     }
+    /**
+     * Pauses the engine by stopping the game loop.
+     * The world and scene state remain in memory so it can be resumed with `play`.
+     */
     pause() {
         this.gameLoop?.stop();
-        this.removeWindowListeners();
     }
+    /**
+     * Stops the engine completely by stopping the game loop and destroying the world.
+     */
     stop() {
         this.gameLoop?.stop();
         this.sceneManager?.destroyWorld();
-        this.removeWindowListeners();
         this.gameLoop = undefined;
         this.sceneManager = undefined;
     }

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

@@ -6,7 +6,7 @@ export interface EntityOptions {
 export declare class Entity extends EventTarget {
     readonly id: string;
     readonly name: string;
-    children: Array<Entity>;
+    children: Entity[];
     parent: Entity | null;
     constructor({ id, name }: EntityOptions);
     appendChild(child: Entity): void;

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

@@ -4,7 +4,7 @@ export declare class EventTarget {
     private listenersMap;
     constructor();
     addEventListener(type: EventType, callback: ListenerFn): void;
-    getEventListeners(type: EventType): Array<ListenerFn> | undefined;
+    getEventListeners(type: EventType): ListenerFn[] | undefined;
     removeEventListener(type: EventType, callback: ListenerFn): void;
     removeAllListeners(): void;
     private handleEvent;

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

@@ -1,12 +1,12 @@
 import { Vector2 } from './vector2';
-type Point = {
+interface Point {
     x: number;
     y: number;
-};
-type Edge = {
+}
+interface Edge {
     point1: Point;
     point2: Point;
-};
+}
 export declare class VectorOps {
     static fixCalcError(value: number): number;
     static getVectorByAngle(angle: number): Vector2;

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

@@ -23,7 +23,7 @@ export class VectorOps {
      * Calculate dot product of two vectors
      */
     static dotProduct(point, vector) {
-        return (point.x * vector.x) + (point.y * vector.y);
+        return point.x * vector.x + point.y * vector.y;
     }
     /**
      * Projects a point onto a given edge, returning the closest point
@@ -65,8 +65,7 @@ export class VectorOps {
             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);
+            const isIntersection = y1 > y !== y2 > y && x < ((x2 - x1) * (y - y1)) / (y2 - y1) + x1;
             if (isIntersection) {
                 isInside = !isInside;
             }

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

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

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

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

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

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

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

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

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

@@ -5,6 +5,7 @@ import { World } from '../world';
 import { LoadScene, EnterScene, ExitScene, DestroyScene, SceneLoaded, SceneEntered, SceneExited, SceneDestroyed, } from '../events';
 import { isSubclassOf } from '../utils/is-subclass-of';
 import { Scene } from './scene';
+;
 export class SceneManager {
     sceneConfigs;
     systemConfigs;
@@ -27,7 +28,12 @@ export class SceneManager {
             acc[scene.id] = scene;
             return acc;
         }, {});
-        this.systemConfigs = systemConfigs.filter((config) => this.availableSystems[config.name]);
+        this.systemConfigs = systemConfigs.filter((config) => {
+            if (!this.availableSystems[config.name]) {
+                console.warn(`System not found: ${config.name}`);
+            }
+            return this.availableSystems[config.name];
+        });
         this.templateCollection = templateCollection;
         this.globalOptions = globalOptions;
         this.resources = resources;