dacha 0.13.0

package/build/contrib/systems/game-stats-meter/index.js

@@ -0,0 +1,34 @@
+import { System } from '../../../engine/system';
+import { GameStatsUpdate } from '../../events';
+import { ActorCollection } from '../../../engine/actor';
+const MS_IN_SEC = 1000;
+export class GameStatsMeter extends System {
+    scene;
+    actorCollection;
+    frequency;
+    fps;
+    time;
+    constructor(options) {
+        super();
+        const { scene, frequency, } = options;
+        this.scene = scene;
+        this.actorCollection = new ActorCollection(scene);
+        this.frequency = frequency || MS_IN_SEC;
+        this.fps = 0;
+        this.time = 0;
+    }
+    update(options) {
+        const { deltaTime } = options;
+        this.fps += 1;
+        this.time += deltaTime;
+        if (this.time >= this.frequency) {
+            this.scene.dispatchEvent(GameStatsUpdate, {
+                fps: (this.fps * MS_IN_SEC) / this.time,
+                actorsCount: this.actorCollection.size,
+            });
+            this.fps = 0;
+            this.time = 0;
+        }
+    }
+}
+GameStatsMeter.systemName = 'GameStatsMeter';

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

@@ -0,0 +1,13 @@
+export { Animator } from './animator';
+export { CameraSystem, CameraService } from './camera-system';
+export { GameStatsMeter } from './game-stats-meter';
+export { KeyboardInputSystem } from './keyboard-input-system';
+export { KeyboardControlSystem } from './keyboard-control-system';
+export { MouseControlSystem } from './mouse-control-system';
+export { MouseInputSystem } from './mouse-input-system';
+export { PhysicsSystem } from './physics-system';
+export { ScriptSystem, Script } from './script-system';
+export type { ScriptOptions } from './script-system';
+export { SpriteRenderer, SpriteRendererService } from './sprite-renderer';
+export { UiBridge } from './ui-bridge';
+export type { UiInitFnOptions, UiInitFn, UiDestroyFn } from './ui-bridge';

package/build/contrib/systems/index.js

@@ -0,0 +1,11 @@
+export { Animator } from './animator';
+export { CameraSystem, CameraService } from './camera-system';
+export { GameStatsMeter } from './game-stats-meter';
+export { KeyboardInputSystem } from './keyboard-input-system';
+export { KeyboardControlSystem } from './keyboard-control-system';
+export { MouseControlSystem } from './mouse-control-system';
+export { MouseInputSystem } from './mouse-input-system';
+export { PhysicsSystem } from './physics-system';
+export { ScriptSystem, Script } from './script-system';
+export { SpriteRenderer, SpriteRendererService } from './sprite-renderer';
+export { UiBridge } from './ui-bridge';

package/build/contrib/systems/keyboard-control-system/index.d.ts

@@ -0,0 +1,14 @@
+import { System } from '../../../engine/system';
+import type { SystemOptions } from '../../../engine/system';
+export declare class KeyboardControlSystem extends System {
+    private actorCollection;
+    private scene;
+    private pressedKeys;
+    private events;
+    constructor(options: SystemOptions);
+    mount(): void;
+    unmount(): void;
+    private handleKeyboardInput;
+    private sendEvent;
+    update(): void;
+}

package/build/contrib/systems/keyboard-control-system/index.js

@@ -0,0 +1,73 @@
+import { System } from '../../../engine/system';
+import { ActorCollection } from '../../../engine/actor';
+import { KeyboardControl } from '../../components/keyboard-control';
+import { KeyboardInput } from '../../events';
+export class KeyboardControlSystem extends System {
+    actorCollection;
+    scene;
+    pressedKeys;
+    events;
+    constructor(options) {
+        super();
+        this.actorCollection = new ActorCollection(options.scene, {
+            components: [
+                KeyboardControl,
+            ],
+        });
+        this.scene = options.scene;
+        this.pressedKeys = new Set();
+        this.events = [];
+    }
+    mount() {
+        this.scene.addEventListener(KeyboardInput, this.handleKeyboardInput);
+    }
+    unmount() {
+        this.scene.removeEventListener(KeyboardInput, this.handleKeyboardInput);
+    }
+    handleKeyboardInput = (event) => {
+        this.events.push(event);
+    };
+    sendEvent(actor, eventBinding, code) {
+        if (!eventBinding.eventType) {
+            throw new Error(`The event type is not specified for input key: ${code}`);
+        }
+        actor.dispatchEvent(eventBinding.eventType, {
+            ...eventBinding.attrs,
+        });
+    }
+    update() {
+        this.events.forEach((event) => {
+            if (!event.pressed) {
+                this.pressedKeys.delete(event.key);
+            }
+        });
+        this.actorCollection.forEach((actor) => {
+            const control = actor.getComponent(KeyboardControl);
+            // Resend control event when key is pressed without actual event if keepEmit is set to true
+            this.pressedKeys.forEach((key) => {
+                const inputBinding = control.inputEventBindings[key]?.pressed;
+                if (inputBinding !== undefined && inputBinding.keepEmit) {
+                    this.sendEvent(actor, inputBinding, key);
+                }
+            });
+            // Send control event on input event excluding repeated browser generated key pressed events
+            this.events.forEach((event) => {
+                const { key, pressed } = event;
+                const inputBinding = control.inputEventBindings[key]?.[pressed ? 'pressed' : 'released'];
+                if (inputBinding !== undefined && !this.pressedKeys.has(key)) {
+                    this.sendEvent(actor, inputBinding, key);
+                }
+            });
+        });
+        this.events.forEach((event) => {
+            if (event.pressed) {
+                this.pressedKeys.add(event.key);
+            }
+            else {
+                this.pressedKeys.delete(event.key);
+            }
+        });
+        this.events = [];
+    }
+}
+KeyboardControlSystem.systemName = 'KeyboardControlSystem';

package/build/contrib/systems/keyboard-input-system/index.d.ts

@@ -0,0 +1,10 @@
+import { System } from '../../../engine/system';
+import type { SystemOptions } from '../../../engine/system';
+export declare class KeyboardInputSystem extends System {
+    private scene;
+    private inputListener;
+    constructor(options: SystemOptions);
+    mount(): void;
+    unmount(): void;
+    update(): void;
+}

package/build/contrib/systems/keyboard-input-system/index.js

@@ -0,0 +1,28 @@
+import { System } from '../../../engine/system';
+import { KeyboardInput } from '../../events';
+import { getWindowNode } from '../../utils/get-window-node';
+import { InputListener } from './input-listener';
+export class KeyboardInputSystem extends System {
+    scene;
+    inputListener;
+    constructor(options) {
+        super();
+        const { scene, windowNodeId, useWindow, } = options;
+        this.scene = scene;
+        const windowNode = useWindow ? window : getWindowNode(windowNodeId);
+        this.inputListener = new InputListener(windowNode);
+    }
+    mount() {
+        this.inputListener.startListen();
+    }
+    unmount() {
+        this.inputListener.stopListen();
+    }
+    update() {
+        this.inputListener.getEvents().forEach((event) => {
+            this.scene.dispatchEvent(KeyboardInput, event);
+        });
+        this.inputListener.clear();
+    }
+}
+KeyboardInputSystem.systemName = 'KeyboardInputSystem';

package/build/contrib/systems/keyboard-input-system/input-listener.d.ts

@@ -0,0 +1,12 @@
+import type { CustomKeyboardEvent } from '../../types/input-events';
+export declare class InputListener {
+    private windowNode;
+    private eventsQuery;
+    constructor(window: Window | HTMLElement);
+    handleKeyDown: (event: Event) => void;
+    handleKeyUp: (event: Event) => void;
+    startListen(): void;
+    stopListen(): void;
+    getEvents(): Array<CustomKeyboardEvent>;
+    clear(): void;
+}

package/build/contrib/systems/keyboard-input-system/input-listener.js

@@ -0,0 +1,36 @@
+export class InputListener {
+    windowNode;
+    eventsQuery;
+    constructor(window) {
+        this.windowNode = window;
+        this.eventsQuery = [];
+    }
+    handleKeyDown = (event) => {
+        this.eventsQuery.push({
+            key: event.code,
+            pressed: true,
+            nativeEvent: event,
+        });
+    };
+    handleKeyUp = (event) => {
+        this.eventsQuery.push({
+            key: event.code,
+            pressed: false,
+            nativeEvent: event,
+        });
+    };
+    startListen() {
+        this.windowNode.addEventListener('keydown', this.handleKeyDown);
+        this.windowNode.addEventListener('keyup', this.handleKeyUp);
+    }
+    stopListen() {
+        this.windowNode.removeEventListener('keydown', this.handleKeyDown);
+        this.windowNode.removeEventListener('keyup', this.handleKeyUp);
+    }
+    getEvents() {
+        return this.eventsQuery;
+    }
+    clear() {
+        this.eventsQuery = [];
+    }
+}

package/build/contrib/systems/mouse-control-system/index.d.ts

@@ -0,0 +1,10 @@
+import { System } from '../../../engine/system';
+import type { SystemOptions } from '../../../engine/system';
+export declare class MouseControlSystem extends System {
+    private actorCollection;
+    private scene;
+    constructor(options: SystemOptions);
+    mount(): void;
+    unmount(): void;
+    private handleMouseInput;
+}

package/build/contrib/systems/mouse-control-system/index.js

@@ -0,0 +1,43 @@
+import { System } from '../../../engine/system';
+import { ActorCollection } from '../../../engine/actor';
+import { MouseControl } from '../../components/mouse-control';
+import { MouseInput } from '../../events';
+export class MouseControlSystem extends System {
+    actorCollection;
+    scene;
+    constructor(options) {
+        super();
+        this.actorCollection = new ActorCollection(options.scene, {
+            components: [
+                MouseControl,
+            ],
+        });
+        this.scene = options.scene;
+    }
+    mount() {
+        this.scene.addEventListener(MouseInput, this.handleMouseInput);
+    }
+    unmount() {
+        this.scene.removeEventListener(MouseInput, this.handleMouseInput);
+    }
+    handleMouseInput = (event) => {
+        this.actorCollection.forEach((actor) => {
+            const control = actor.getComponent(MouseControl);
+            const eventBinding = control.inputEventBindings[event.eventType]?.[event.button];
+            if (eventBinding) {
+                if (!eventBinding.eventType) {
+                    throw new Error(`The event type is not specified for input event: ${event.eventType}`);
+                }
+                actor.dispatchEvent(eventBinding.eventType, {
+                    ...eventBinding.attrs,
+                    x: event.x,
+                    y: event.y,
+                    screenX: event.screenX,
+                    screenY: event.screenY,
+                    nativeEvent: event.nativeEvent,
+                });
+            }
+        });
+    };
+}
+MouseControlSystem.systemName = 'MouseControlSystem';

package/build/contrib/systems/mouse-input-system/index.d.ts

@@ -0,0 +1,10 @@
+import { System } from '../../../engine/system';
+import type { SystemOptions } from '../../../engine/system';
+export declare class MouseInputSystem extends System {
+    private inputSubsystem;
+    private coordinatesProjector;
+    constructor(options: SystemOptions);
+    mount(): void;
+    unmount(): void;
+    update(): void;
+}

package/build/contrib/systems/mouse-input-system/index.js

@@ -0,0 +1,23 @@
+import { System } from '../../../engine/system';
+import { InputSubsystem, CoordinatesProjector, } from './subsystems';
+export class MouseInputSystem extends System {
+    inputSubsystem;
+    coordinatesProjector;
+    constructor(options) {
+        super();
+        this.inputSubsystem = new InputSubsystem(options);
+        this.coordinatesProjector = new CoordinatesProjector(options);
+    }
+    mount() {
+        this.inputSubsystem.mount();
+        this.coordinatesProjector.mount();
+    }
+    unmount() {
+        this.inputSubsystem.unmount();
+        this.coordinatesProjector.unmount();
+    }
+    update() {
+        this.inputSubsystem.update();
+    }
+}
+MouseInputSystem.systemName = 'MouseInputSystem';

package/build/contrib/systems/mouse-input-system/subsystems/coordinates-projector/index.d.ts

@@ -0,0 +1,9 @@
+import type { SystemOptions } from '../../../../../engine/system';
+export declare class CoordinatesProjector {
+    private scene;
+    private cameraService;
+    constructor(options: SystemOptions);
+    mount(): void;
+    unmount(): void;
+    private handleMouseInput;
+}

package/build/contrib/systems/mouse-input-system/subsystems/coordinates-projector/index.js

@@ -0,0 +1,23 @@
+import { MouseInput } from '../../../../events';
+import { CameraService } from '../../../camera-system';
+import { getProjectedX, getProjectedY } from '../../../../utils/coordinates-projection';
+export class CoordinatesProjector {
+    scene;
+    cameraService;
+    constructor(options) {
+        const { scene } = options;
+        this.scene = scene;
+        this.cameraService = scene.getService(CameraService);
+    }
+    mount() {
+        this.scene.addEventListener(MouseInput, this.handleMouseInput);
+    }
+    unmount() {
+        this.scene.removeEventListener(MouseInput, this.handleMouseInput);
+    }
+    handleMouseInput = (event) => {
+        const currentCamera = this.cameraService.getCurrentCamera();
+        event.x = currentCamera ? getProjectedX(event.x, currentCamera) : event.x;
+        event.y = currentCamera ? getProjectedY(event.y, currentCamera) : event.y;
+    };
+}

package/build/contrib/systems/mouse-input-system/subsystems/index.d.ts

@@ -0,0 +1,2 @@
+export { InputSubsystem } from './input-subsystem';
+export { CoordinatesProjector } from './coordinates-projector';

package/build/contrib/systems/mouse-input-system/subsystems/index.js

@@ -0,0 +1,2 @@
+export { InputSubsystem } from './input-subsystem';
+export { CoordinatesProjector } from './coordinates-projector';

package/build/contrib/systems/mouse-input-system/subsystems/input-subsystem/index.d.ts

@@ -0,0 +1,9 @@
+import type { SystemOptions } from '../../../../../engine/system';
+export declare class InputSubsystem {
+    private scene;
+    private inputListener;
+    constructor(options: SystemOptions);
+    mount(): void;
+    unmount(): void;
+    update(): void;
+}

package/build/contrib/systems/mouse-input-system/subsystems/input-subsystem/index.js

@@ -0,0 +1,25 @@
+import { MouseInput } from '../../../../events';
+import { getWindowNode } from '../../../../utils/get-window-node';
+import { MouseInputListener } from './mouse-input-listener';
+export class InputSubsystem {
+    scene;
+    inputListener;
+    constructor(options) {
+        const { scene, windowNodeId, useWindow, } = options;
+        this.scene = scene;
+        const windowNode = useWindow ? window : getWindowNode(windowNodeId);
+        this.inputListener = new MouseInputListener(windowNode);
+    }
+    mount() {
+        this.inputListener.startListen();
+    }
+    unmount() {
+        this.inputListener.stopListen();
+    }
+    update() {
+        this.inputListener.getFiredEvents().forEach((inputEvent) => {
+            this.scene.dispatchEvent(MouseInput, inputEvent);
+        });
+        this.inputListener.clearFiredEvents();
+    }
+}

package/build/contrib/systems/mouse-input-system/subsystems/input-subsystem/mouse-input-listener.d.ts

@@ -0,0 +1,11 @@
+import type { CustomMouseEvent } from '../../../../types/input-events';
+export declare class MouseInputListener {
+    private window;
+    private firedEvents;
+    constructor(window: Window | HTMLElement);
+    handleMouseEvent: (event: Event) => void;
+    startListen(): void;
+    stopListen(): void;
+    getFiredEvents(): Array<CustomMouseEvent>;
+    clearFiredEvents(): void;
+}

package/build/contrib/systems/mouse-input-system/subsystems/input-subsystem/mouse-input-listener.js

@@ -0,0 +1,46 @@
+const LISTENING_EVENTS = [
+    'mousedown',
+    'mouseup',
+    'mousemove',
+    'click',
+    'contextmenu',
+    'dblclick',
+    'mouseenter',
+    'mouseleave',
+];
+export class MouseInputListener {
+    window;
+    firedEvents;
+    constructor(window) {
+        this.window = window;
+        this.firedEvents = [];
+    }
+    handleMouseEvent = (event) => {
+        const { type, button, offsetX, offsetY, } = event;
+        this.firedEvents.push({
+            eventType: type,
+            button,
+            x: offsetX,
+            y: offsetY,
+            screenX: offsetX,
+            screenY: offsetY,
+            nativeEvent: event,
+        });
+    };
+    startListen() {
+        LISTENING_EVENTS.forEach((eventType) => {
+            this.window.addEventListener(eventType, this.handleMouseEvent);
+        });
+    }
+    stopListen() {
+        LISTENING_EVENTS.forEach((eventType) => {
+            this.window.removeEventListener(eventType, this.handleMouseEvent);
+        });
+    }
+    getFiredEvents() {
+        return this.firedEvents;
+    }
+    clearFiredEvents() {
+        this.firedEvents = [];
+    }
+}

package/build/contrib/systems/physics-system/consts.d.ts

@@ -0,0 +1,4 @@
+export declare const RIGID_BODY_TYPE: {
+    STATIC: string;
+    DYNAMIC: string;
+};

package/build/contrib/systems/physics-system/consts.js

@@ -0,0 +1,4 @@
+export const RIGID_BODY_TYPE = {
+    STATIC: 'static',
+    DYNAMIC: 'dynamic',
+};

package/build/contrib/systems/physics-system/index.d.ts

@@ -0,0 +1,13 @@
+import { System } from '../../../engine/system';
+import type { SystemOptions, UpdateOptions } from '../../../engine/system';
+export declare class PhysicsSystem extends System {
+    private physicsSubsystem;
+    private collisionDetectionSubsystem;
+    private collisionBroadcastSubsystem;
+    private collisionSolver;
+    private constraintSolver;
+    constructor(options: SystemOptions);
+    mount(): void;
+    unmount(): void;
+    fixedUpdate(options: UpdateOptions): void;
+}

package/build/contrib/systems/physics-system/index.js

@@ -0,0 +1,38 @@
+import { System } from '../../../engine/system';
+import { PhysicsSubsystem, CollisionDetectionSubsystem, CollisionBroadcastSubsystem, CollisionSolver, ConstraintSolver, } from './subsystems';
+export class PhysicsSystem extends System {
+    physicsSubsystem;
+    collisionDetectionSubsystem;
+    collisionBroadcastSubsystem;
+    collisionSolver;
+    constraintSolver;
+    constructor(options) {
+        super();
+        this.physicsSubsystem = new PhysicsSubsystem(options);
+        this.collisionDetectionSubsystem = new CollisionDetectionSubsystem(options);
+        this.collisionBroadcastSubsystem = new CollisionBroadcastSubsystem(options);
+        this.collisionSolver = new CollisionSolver(options);
+        this.constraintSolver = new ConstraintSolver(options);
+    }
+    mount() {
+        this.physicsSubsystem.mount();
+        this.collisionDetectionSubsystem.mount();
+        this.collisionSolver.mount();
+        this.constraintSolver.mount();
+        this.collisionBroadcastSubsystem.mount();
+    }
+    unmount() {
+        this.physicsSubsystem.unmount();
+        this.collisionDetectionSubsystem.unmount();
+        this.collisionSolver.unmount();
+        this.constraintSolver.unmount();
+        this.collisionBroadcastSubsystem.unmount();
+    }
+    fixedUpdate(options) {
+        this.physicsSubsystem.update(options);
+        this.collisionDetectionSubsystem.update();
+        this.constraintSolver.update();
+        this.collisionBroadcastSubsystem.update();
+    }
+}
+PhysicsSystem.systemName = 'PhysicsSystem';

package/build/contrib/systems/physics-system/subsystems/collision-broadcast/collision.d.ts

@@ -0,0 +1,15 @@
+import type { Actor } from '../../../../../engine/actor';
+import type { Vector2 } from '../../../../../engine/math-lib';
+export type CollisionState = 'enter' | 'stay' | 'leave';
+export declare class Collision {
+    private lifetime;
+    actor1: Actor;
+    actor2: Actor;
+    mtv1: Vector2;
+    mtv2: Vector2;
+    constructor(actor1: Actor, actor2: Actor, mtv1: Vector2, mtv2: Vector2);
+    isFinished(): boolean;
+    signal(): void;
+    tick(): void;
+    getState(): CollisionState;
+}

package/build/contrib/systems/physics-system/subsystems/collision-broadcast/collision.js

@@ -0,0 +1,31 @@
+const STATE = {
+    2: 'enter',
+    1: 'stay',
+    0: 'leave',
+};
+export class Collision {
+    lifetime;
+    actor1;
+    actor2;
+    mtv1;
+    mtv2;
+    constructor(actor1, actor2, mtv1, mtv2) {
+        this.actor1 = actor1;
+        this.actor2 = actor2;
+        this.lifetime = 2;
+        this.mtv1 = mtv1;
+        this.mtv2 = mtv2;
+    }
+    isFinished() {
+        return this.lifetime < 0;
+    }
+    signal() {
+        this.lifetime = 1;
+    }
+    tick() {
+        this.lifetime -= this.lifetime || 1;
+    }
+    getState() {
+        return STATE[this.lifetime];
+    }
+}

package/build/contrib/systems/physics-system/subsystems/collision-broadcast/index.d.ts

@@ -0,0 +1,12 @@
+import type { SystemOptions } from '../../../../../engine/system';
+export declare class CollisionBroadcastSubsystem {
+    private scene;
+    private collisionMap;
+    private activeCollisions;
+    constructor(options: SystemOptions);
+    mount(): void;
+    unmount(): void;
+    private handleCollision;
+    private publishEvent;
+    update(): void;
+}

package/build/contrib/systems/physics-system/subsystems/collision-broadcast/index.js

@@ -0,0 +1,55 @@
+import { Collision as RawCollision, CollisionEnter, CollisionStay, CollisionLeave, } from '../../../../events';
+import { Collision } from './collision';
+const STATE_TO_EVENT = {
+    enter: CollisionEnter,
+    stay: CollisionStay,
+    leave: CollisionLeave,
+};
+export class CollisionBroadcastSubsystem {
+    scene;
+    collisionMap;
+    activeCollisions;
+    constructor(options) {
+        this.scene = options.scene;
+        this.collisionMap = {};
+        this.activeCollisions = [];
+    }
+    mount() {
+        this.scene.addEventListener(RawCollision, this.handleCollision);
+    }
+    unmount() {
+        this.scene.removeEventListener(RawCollision, this.handleCollision);
+    }
+    handleCollision = (event) => {
+        const { actor1, actor2, mtv1, mtv2, } = event;
+        this.collisionMap[actor1.id] = this.collisionMap[actor1.id] || {};
+        if (!this.collisionMap[actor1.id][actor2.id]) {
+            const collision = new Collision(actor1, actor2, mtv1, mtv2);
+            this.collisionMap[actor1.id][actor2.id] = collision;
+            this.activeCollisions.push(collision);
+        }
+        else {
+            this.collisionMap[actor1.id][actor2.id].mtv1 = mtv1;
+            this.collisionMap[actor1.id][actor2.id].mtv2 = mtv2;
+            this.collisionMap[actor1.id][actor2.id].signal();
+        }
+    };
+    publishEvent(collision) {
+        const { actor1, actor2, mtv1, } = collision;
+        actor1.dispatchEvent(STATE_TO_EVENT[collision.getState()], {
+            actor: actor2,
+            mtv: mtv1,
+        });
+    }
+    update() {
+        this.activeCollisions = this.activeCollisions.filter((collision) => {
+            const { actor1, actor2 } = collision;
+            this.publishEvent(collision);
+            collision.tick();
+            if (collision.isFinished()) {
+                delete this.collisionMap[actor1.id][actor2.id];
+            }
+            return !collision.isFinished();
+        });
+    }
+}

package/build/contrib/systems/physics-system/subsystems/collision-detection/aabb-builders/build-box-aabb.d.ts

@@ -0,0 +1,2 @@
+import type { AABB, Geometry } from '../types';
+export declare const buildBoxAABB: (geometry: Geometry) => AABB;