dacha 0.13.0

package/build/contrib/systems/webgl-render-system/texture-handlers/static-texture-handler.d.ts

@@ -0,0 +1,9 @@
+import { TextureHandler, TextureDescriptor } from './texture-handler';
+export declare class StaticTextureHandler implements TextureHandler {
+    handle(textureDescriptor: TextureDescriptor): {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+}

package/build/contrib/systems/webgl-render-system/texture-handlers/static-texture-handler.js

@@ -0,0 +1,10 @@
+export class StaticTextureHandler {
+    handle(textureDescriptor) {
+        return {
+            x: textureDescriptor.x,
+            y: textureDescriptor.y,
+            width: textureDescriptor.width,
+            height: textureDescriptor.height,
+        };
+    }
+}

package/build/contrib/systems/webgl-render-system/texture-handlers/texture-handler.d.ts

@@ -0,0 +1,10 @@
+import { Renderable } from '../../../components/renderable';
+export interface TextureDescriptor {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export interface TextureHandler {
+    handle(descriptor: TextureDescriptor, renderable: Renderable): TextureDescriptor;
+}

package/build/contrib/systems/webgl-render-system/texture-handlers/texture-handler.js

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

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

@@ -0,0 +1 @@
+export { splitToBatch } from './split-to-batch';

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

@@ -0,0 +1 @@
+export { splitToBatch } from './split-to-batch';

package/build/contrib/systems/webgl-render-system/utils/split-to-batch.d.ts

@@ -0,0 +1,3 @@
+import type { Actor, ActorCollection } from '../../../../engine/actor';
+import type { ShaderProvider } from '../shader-builder';
+export declare const splitToBatch: (actorCollection: ActorCollection, shaderProvider: ShaderProvider) => Array<Array<Actor>>;

package/build/contrib/systems/webgl-render-system/utils/split-to-batch.js

@@ -0,0 +1,19 @@
+export const splitToBatch = (actorCollection, shaderProvider) => {
+    if (!actorCollection.size) {
+        return [];
+    }
+    const batches = [];
+    let prevShadingId;
+    actorCollection.forEach((actor) => {
+        const shadingId = shaderProvider.getShadingId(actor.id);
+        const currentBatch = batches[batches.length - 1];
+        if (shadingId === prevShadingId) {
+            currentBatch.push(actor);
+        }
+        else {
+            batches.push([actor]);
+            prevShadingId = shadingId;
+        }
+    });
+    return batches;
+};

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

@@ -0,0 +1 @@
+export { InputEventAttributes, InputEventAttributeConfig, } from './input-events';

package/build/contrib/types/index.js

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

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

@@ -0,0 +1,21 @@
+export type AttributeValue = string | number | boolean | Array<string>;
+export type InputEventAttributes = Record<string, AttributeValue>;
+export interface InputEventAttributeConfig {
+    name: string;
+    type?: string;
+    value: AttributeValue;
+}
+export interface CustomMouseEvent {
+    eventType: string;
+    button: number;
+    x: number;
+    y: number;
+    screenX: number;
+    screenY: number;
+    nativeEvent: MouseEvent;
+}
+export interface CustomKeyboardEvent {
+    key: string;
+    pressed: boolean;
+    nativeEvent: KeyboardEvent;
+}

package/build/contrib/types/input-events.js

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

package/build/contrib/utils/coordinates-projection.d.ts

@@ -0,0 +1,3 @@
+import type { Actor } from '../../engine/actor';
+export declare const getProjectedX: (inputX: number, camera: Actor) => number;
+export declare const getProjectedY: (inputY: number, camera: Actor) => number;

package/build/contrib/utils/coordinates-projection.js

@@ -0,0 +1,11 @@
+import { Transform, Camera } from '../components';
+export const getProjectedX = (inputX, camera) => {
+    const { windowSizeX, zoom } = camera.getComponent(Camera);
+    const { offsetX: cameraOffsetX } = camera.getComponent(Transform);
+    return ((inputX - (windowSizeX / 2)) / zoom) + cameraOffsetX;
+};
+export const getProjectedY = (inputY, camera) => {
+    const { windowSizeY, zoom } = camera.getComponent(Camera);
+    const { offsetY: cameraOffsetY } = camera.getComponent(Transform);
+    return ((inputY - (windowSizeY / 2)) / zoom) + cameraOffsetY;
+};

package/build/contrib/utils/get-window-node.d.ts

@@ -0,0 +1 @@
+export declare const getWindowNode: (windowNodeId: string) => HTMLElement;

package/build/contrib/utils/get-window-node.js

@@ -0,0 +1,7 @@
+export const getWindowNode = (windowNodeId) => {
+    const windowNode = document.getElementById(windowNodeId);
+    if (windowNode === null) {
+        throw new Error(`Cannot find the node with id: ${windowNodeId}. Please specify windowNodeId for system and make sure the node exists`);
+    }
+    return windowNode;
+};

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

@@ -0,0 +1,31 @@
+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 ActorCollectionListenerFn<T extends EventType> = (event: T extends keyof ActorCollectionEventMap ? ActorCollectionEventMap[T] : Event) => void;
+export interface ActorCollectionFilter {
+    components?: Array<ComponentConstructor | string>;
+}
+export declare class ActorCollection extends EventTarget {
+    private components;
+    private acceptedActors;
+    private acceptedActorsMap;
+    constructor(scene: Scene, filter?: ActorCollectionFilter);
+    addEventListener<T extends EventType>(type: T, callback: ActorCollectionListenerFn<T>): void;
+    removeEventListener<T extends EventType>(type: T, callback: ActorCollectionListenerFn<T>): void;
+    private handleActorUpdate;
+    private test;
+    private add;
+    private remove;
+    get size(): number;
+    getById(id: string): Actor | undefined;
+    forEach(callback: (actor: Actor, index: number) => void): void;
+    map<T>(callback: (actor: Actor, index: number) => T): T[];
+    reduce<T>(callback: (previousValue: T, currentValue: Actor, index: number) => T, initialValue: T): T;
+    find(callback: (actor: Actor, index: number) => boolean): Actor | undefined;
+    filter(callback: (actor: Actor, index: number) => boolean): Actor[];
+    sort(compareFunction: (a: Actor, b: Actor) => number): void;
+}
+export {};

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

@@ -0,0 +1,98 @@
+import { EventTarget } from '../event-target';
+import { AddComponent, RemoveComponent, AddActor, RemoveActor, AddChildEntity, RemoveChildEntity, } from '../events';
+import { traverseEntity } from '../entity';
+import { Actor } from './actor';
+export class ActorCollection extends EventTarget {
+    components;
+    acceptedActors;
+    acceptedActorsMap;
+    constructor(scene, filter = {}) {
+        super();
+        const { components = [], } = filter;
+        this.components = components;
+        this.acceptedActorsMap = {};
+        this.acceptedActors = [];
+        traverseEntity(scene, (entity) => {
+            if (entity instanceof Actor && this.test(entity)) {
+                this.acceptedActorsMap[entity.id] = entity;
+                this.acceptedActors.push(entity);
+            }
+        });
+        scene.addEventListener(AddChildEntity, (event) => {
+            traverseEntity(event.child, (entity) => {
+                if (entity instanceof Actor && this.test(entity)) {
+                    this.add(entity);
+                }
+            });
+        });
+        scene.addEventListener(RemoveChildEntity, (event) => {
+            traverseEntity(event.child, (entity) => this.remove(entity));
+        });
+        scene.addEventListener(AddComponent, this.handleActorUpdate);
+        scene.addEventListener(RemoveComponent, this.handleActorUpdate);
+    }
+    addEventListener(type, callback) {
+        super.addEventListener(type, callback);
+    }
+    removeEventListener(type, callback) {
+        super.removeEventListener(type, callback);
+    }
+    handleActorUpdate = (event) => {
+        const { target } = event;
+        if (this.test(target)) {
+            this.add(target);
+        }
+        else {
+            this.remove(target);
+        }
+    };
+    test(actor) {
+        return this.components.every((component) => {
+            // Dummy check to avoid typescript error
+            if (typeof component === 'string') {
+                return actor.getComponent(component);
+            }
+            return actor.getComponent(component);
+        });
+    }
+    add(actor) {
+        if (this.acceptedActorsMap[actor.id]) {
+            return;
+        }
+        this.acceptedActors.push(actor);
+        this.acceptedActorsMap[actor.id] = actor;
+        this.dispatchEventImmediately(AddActor, { actor });
+    }
+    remove(actor) {
+        if (!this.acceptedActorsMap[actor.id]) {
+            return;
+        }
+        this.acceptedActors = this.acceptedActors.filter((acceptedActor) => actor.id !== acceptedActor.id);
+        delete this.acceptedActorsMap[actor.id];
+        this.dispatchEventImmediately(RemoveActor, { actor });
+    }
+    get size() {
+        return this.acceptedActors.length;
+    }
+    getById(id) {
+        return this.acceptedActorsMap[id];
+    }
+    forEach(callback) {
+        this.acceptedActors.forEach(callback);
+    }
+    map(callback) {
+        return this.acceptedActors.map(callback);
+    }
+    reduce(callback, initialValue) {
+        return this.acceptedActors.reduce(callback, initialValue);
+    }
+    find(callback) {
+        return this.acceptedActors.find(callback);
+    }
+    filter(callback) {
+        return this.acceptedActors.filter(callback);
+    }
+    sort(compareFunction) {
+        this.acceptedActors.sort(compareFunction);
+    }
+}

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

@@ -0,0 +1,21 @@
+import type { ComponentConfig } from '../types';
+import type { ComponentConstructor } from '../component';
+import type { TemplateCollection } from '../template';
+import { Actor } from './actor';
+export interface ActorOptions {
+    id?: string;
+    name?: string;
+    children?: Array<ActorOptions>;
+    components?: Array<ComponentConfig>;
+    templateId?: string;
+    isNew?: boolean;
+}
+export declare class ActorCreator {
+    private components;
+    private templateCollection;
+    constructor(components: Array<ComponentConstructor>, templateCollection: TemplateCollection);
+    private buildFromTemplate;
+    private buildFromScratch;
+    private build;
+    create(options: ActorOptions): Actor;
+}

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

@@ -0,0 +1,82 @@
+import uuid from 'uuid-random';
+import { Actor } from './actor';
+export class ActorCreator {
+    components;
+    templateCollection;
+    constructor(components, templateCollection) {
+        this.components = components.reduce((acc, ComponentClass) => {
+            acc[ComponentClass.componentName] = ComponentClass;
+            return acc;
+        }, {});
+        this.templateCollection = templateCollection;
+    }
+    buildFromTemplate(options) {
+        const { templateId, components = [], children = [], isNew = false, } = options;
+        let { id, name } = options;
+        id = id || uuid();
+        name = name || id;
+        const template = templateId ? this.templateCollection.get(templateId) : undefined;
+        if (!template) {
+            throw new Error(`Can't create actor ${name} from template. `
+                + `The template with id ${String(templateId)} is null.`);
+        }
+        const actor = new Actor({
+            id,
+            name,
+            templateId,
+        });
+        if (isNew) {
+            template.children.forEach((templateChild) => {
+                const childOptions = {
+                    name: templateChild.name,
+                    templateId: templateChild.id,
+                    isNew,
+                };
+                const actorChild = this.build(childOptions);
+                actor.appendChild(actorChild);
+            });
+        }
+        else {
+            children.forEach((childOptions) => {
+                const actorChild = this.build(childOptions);
+                actor.appendChild(actorChild);
+            });
+        }
+        template.getComponents().forEach((component) => {
+            actor.setComponent(component);
+        });
+        components.forEach((componentOptions) => {
+            const Component = this.components[componentOptions.name];
+            actor.setComponent(new Component(componentOptions.config));
+        });
+        return actor;
+    }
+    buildFromScratch(options) {
+        const { name, components = [], children = [], } = options;
+        let { id } = options;
+        id = id || uuid();
+        const actor = new Actor({
+            id,
+            name: name,
+        });
+        children.forEach((child) => {
+            const actorChild = this.build(child);
+            actor.appendChild(actorChild);
+        });
+        components.forEach((componentOptions) => {
+            const Component = this.components[componentOptions.name];
+            actor.setComponent(new Component(componentOptions.config));
+        });
+        return actor;
+    }
+    build(options) {
+        const { templateId } = options;
+        if (templateId) {
+            return this.buildFromTemplate(options);
+        }
+        return this.buildFromScratch(options);
+    }
+    create(options) {
+        return this.build(options);
+    }
+}

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

@@ -0,0 +1,7 @@
+import type { ActorCreator } from './actor-creator';
+import type { Actor } from './actor';
+export declare class ActorSpawner {
+    private actorCreator;
+    constructor(actorCreator: ActorCreator);
+    spawn(templateId: string): Actor;
+}

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

@@ -0,0 +1,12 @@
+export class ActorSpawner {
+    actorCreator;
+    constructor(actorCreator) {
+        this.actorCreator = actorCreator;
+    }
+    spawn(templateId) {
+        return this.actorCreator.create({
+            templateId,
+            isNew: true,
+        });
+    }
+}

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

@@ -0,0 +1,31 @@
+import type { Scene } from '../scene';
+import type { Component, ComponentConstructor } from '../component';
+import type { ActorEventMap } from '../../types/events';
+import { Entity } from '../entity';
+import type { EntityOptions } from '../entity';
+import type { EventType, Event, EventPayload } from '../event-target';
+type ActorListenerFn<T extends EventType> = (event: T extends keyof ActorEventMap ? ActorEventMap[T] : Event) => void;
+export interface ActorOptions extends EntityOptions {
+    templateId?: string;
+}
+export declare class Actor extends Entity {
+    private components;
+    readonly children: Array<Actor>;
+    readonly templateId?: string;
+    parent: Actor | Scene | null;
+    constructor(options: ActorOptions);
+    addEventListener<T extends EventType>(type: T, callback: ActorListenerFn<T>): void;
+    removeEventListener<T extends EventType>(type: T, callback: ActorListenerFn<T>): void;
+    dispatchEvent<T extends EventType>(type: T, ...payload: EventPayload<ActorEventMap, T>): void;
+    dispatchEventImmediately<T extends EventType>(type: T, ...payload: EventPayload<ActorEventMap, T>): void;
+    appendChild(child: Actor): void;
+    removeChild(child: Actor): void;
+    getEntityById(id: string): Actor | undefined;
+    getEntityByName(name: string): Actor | undefined;
+    getComponents(): Array<Component>;
+    getComponent<T extends Component = Component>(componentName: string): T;
+    getComponent<T extends Component>(componentClass: ComponentConstructor<T>): T;
+    setComponent(component: Component): void;
+    removeComponent(componentClass: ComponentConstructor): void;
+}
+export {};

package/build/engine/actor/actor.js

@@ -0,0 +1,60 @@
+import { AddComponent, RemoveComponent } from '../events';
+import { Entity } from '../entity';
+export class Actor extends Entity {
+    components;
+    templateId;
+    constructor(options) {
+        super(options);
+        const { templateId } = options;
+        this.templateId = templateId;
+        this.components = {};
+    }
+    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);
+    }
+    getComponents() {
+        return Object.values(this.components);
+    }
+    getComponent(classOrName) {
+        if (typeof classOrName === 'string') {
+            return this.components[classOrName];
+        }
+        return this.components[classOrName.componentName];
+    }
+    setComponent(component) {
+        const { componentName } = component.constructor;
+        this.components[componentName] = component;
+        component.actor = this;
+        this.dispatchEventImmediately(AddComponent, { componentName });
+    }
+    removeComponent(componentClass) {
+        const { componentName } = componentClass;
+        if (!this.components[componentName]) {
+            return;
+        }
+        this.components[componentName].actor = void 0;
+        delete this.components[componentName];
+        this.dispatchEventImmediately(RemoveComponent, { componentName });
+    }
+}

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

@@ -0,0 +1,5 @@
+export { Actor } from './actor';
+export { ActorCollection } from './actor-collection';
+export { ActorCreator } from './actor-creator';
+export { ActorSpawner } from './actor-spawner';
+export type { ActorCollectionFilter } from './actor-collection';

package/build/engine/actor/index.js

@@ -0,0 +1,4 @@
+export { Actor } from './actor';
+export { ActorCollection } from './actor-collection';
+export { ActorCreator } from './actor-creator';
+export { ActorSpawner } from './actor-spawner';

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

@@ -0,0 +1,13 @@
+import type { Actor } from '../actor';
+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 abstract class Component {
+    static componentName: string;
+    actor?: Actor;
+    constructor();
+    getParentComponent(): Component | void;
+    abstract clone(): Component;
+}

package/build/engine/component/component.js

@@ -0,0 +1,21 @@
+import { Scene } from '../scene';
+export const findParentComponent = (actor, componentClass) => {
+    if (!actor.parent || actor.parent instanceof Scene) {
+        return void 0;
+    }
+    const parentComponent = actor.parent.getComponent(componentClass);
+    return parentComponent || findParentComponent(actor.parent, componentClass);
+};
+export class Component {
+    static componentName;
+    actor;
+    constructor() {
+        this.actor = void 0;
+    }
+    getParentComponent() {
+        if (!this.actor) {
+            return void 0;
+        }
+        return findParentComponent(this.actor, this.constructor);
+    }
+}

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

@@ -0,0 +1,2 @@
+export { Component } from './component';
+export type { ComponentConstructor } from './component';

package/build/engine/component/index.js

@@ -0,0 +1 @@
+export { Component } from './component';

package/build/engine/controllers/controller.d.ts

@@ -0,0 +1,7 @@
+import type { SceneProvider } from '../scene';
+export interface Controller {
+    update(): void;
+}
+export interface ControllerOptions {
+    sceneProvider: SceneProvider;
+}

package/build/engine/controllers/controller.js

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

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

@@ -0,0 +1,2 @@
+export type { Controller } from './controller';
+export { SceneController } from './scene-controller';

package/build/engine/controllers/index.js

@@ -0,0 +1 @@
+export { SceneController } from './scene-controller';

package/build/engine/controllers/scene-controller.d.ts

@@ -0,0 +1,11 @@
+import type { Controller, ControllerOptions } from './controller';
+export declare class SceneController implements Controller {
+    private sceneProvider;
+    private currentScene?;
+    private nextSceneEvent?;
+    private nextLevelEvent?;
+    constructor({ sceneProvider }: ControllerOptions);
+    private handleLoadScene;
+    private handleLoadLevel;
+    update(): void;
+}

package/build/engine/controllers/scene-controller.js

@@ -0,0 +1,50 @@
+import { LoadLevel, LoadScene } from '../events';
+export class SceneController {
+    sceneProvider;
+    currentScene;
+    nextSceneEvent;
+    nextLevelEvent;
+    constructor({ sceneProvider }) {
+        this.sceneProvider = sceneProvider;
+    }
+    handleLoadScene = (event) => {
+        this.nextSceneEvent = event;
+    };
+    handleLoadLevel = (event) => {
+        this.nextLevelEvent = event;
+    };
+    update() {
+        const currentScene = this.sceneProvider.getCurrentScene();
+        if (this.currentScene !== currentScene) {
+            this.currentScene?.removeEventListener(LoadScene, this.handleLoadScene);
+            this.currentScene?.removeEventListener(LoadLevel, this.handleLoadLevel);
+            if (currentScene !== undefined) {
+                currentScene?.addEventListener(LoadScene, this.handleLoadScene);
+                currentScene?.addEventListener(LoadLevel, this.handleLoadLevel);
+            }
+            this.currentScene = currentScene;
+        }
+        if (this.nextSceneEvent !== undefined) {
+            const { sceneId, loaderId, levelId, clean, unloadCurrent, } = this.nextSceneEvent;
+            void this.sceneProvider.loadScene({
+                sceneId,
+                loaderId,
+                levelId,
+                clean,
+                unloadCurrent,
+            });
+            this.nextSceneEvent = undefined;
+        }
+        if (this.nextLevelEvent !== undefined) {
+            const { levelId, loaderId, } = this.nextLevelEvent;
+            void this.sceneProvider.loadLevel({
+                levelId,
+                loaderId,
+            });
+            this.nextLevelEvent = undefined;
+        }
+        if (this.sceneProvider.isLoaded()) {
+            this.sceneProvider.moveToLoaded();
+        }
+    }
+}

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

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

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

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

package/build/engine/data-lib/queue.d.ts

@@ -0,0 +1,8 @@
+export declare class Queue<T> {
+    private head;
+    private tail;
+    constructor();
+    add(value: T): void;
+    poll(): T | null;
+    peek(): T | null;
+}