dacha 0.13.0

package/build/contrib/systems/physics-system/subsystems/collision-detection/intersection-checkers/index.js

@@ -0,0 +1,13 @@
+import { checkBoxAndCircleIntersection } from './check-box-and-circle-intersection';
+import { checkBoxesIntersection } from './check-boxes-intersection';
+import { checkCirclesIntersection } from './check-circles-intersection';
+export const intersectionCheckers = {
+    boxCollider: {
+        boxCollider: checkBoxesIntersection,
+        circleCollider: checkBoxAndCircleIntersection,
+    },
+    circleCollider: {
+        circleCollider: checkCirclesIntersection,
+        boxCollider: checkBoxAndCircleIntersection,
+    },
+};

package/build/contrib/systems/physics-system/subsystems/collision-detection/reorientation-checkers/check-collider.d.ts

@@ -0,0 +1,3 @@
+import type { ColliderContainer } from '../../../../../components';
+import type { OrientationData } from '../types';
+export declare const checkCollider: (colliderContainer: ColliderContainer, colliderOld: OrientationData['collider']) => boolean;

package/build/contrib/systems/physics-system/subsystems/collision-detection/reorientation-checkers/check-collider.js

@@ -0,0 +1,16 @@
+export const checkCollider = (colliderContainer, colliderOld) => {
+    if (colliderContainer.type !== colliderOld.type) {
+        return true;
+    }
+    if (colliderContainer.type === 'boxCollider') {
+        const collider = colliderContainer.collider;
+        return collider.centerX !== colliderOld.centerX
+            || collider.centerY !== colliderOld.centerY
+            || collider.sizeX !== colliderOld.sizeX
+            || collider.sizeY !== colliderOld.sizeY;
+    }
+    const collider = colliderContainer.collider;
+    return collider.centerX !== colliderOld.centerX
+        || collider.centerY !== colliderOld.centerY
+        || collider.radius !== colliderOld.radius;
+};

package/build/contrib/systems/physics-system/subsystems/collision-detection/reorientation-checkers/check-transform.d.ts

@@ -0,0 +1,3 @@
+import type { Transform } from '../../../../../components';
+import type { OrientationData } from '../types';
+export declare const checkTransform: (transform: Transform, transformOld: OrientationData['transform']) => boolean;

package/build/contrib/systems/physics-system/subsystems/collision-detection/reorientation-checkers/check-transform.js

@@ -0,0 +1,5 @@
+export const checkTransform = (transform, transformOld) => transform.offsetX !== transformOld.offsetX
+    || transform.offsetY !== transformOld.offsetY
+    || transform.rotation !== transformOld.rotation
+    || transform.scaleX !== transformOld.scaleX
+    || transform.scaleY !== transformOld.scaleY;

package/build/contrib/systems/physics-system/subsystems/collision-detection/reorientation-checkers/index.d.ts

@@ -0,0 +1,2 @@
+export { checkTransform } from './check-transform';
+export { checkCollider } from './check-collider';

package/build/contrib/systems/physics-system/subsystems/collision-detection/reorientation-checkers/index.js

@@ -0,0 +1,2 @@
+export { checkTransform } from './check-transform';
+export { checkCollider } from './check-collider';

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

@@ -0,0 +1,70 @@
+import type { Vector2 } from '../../../../../engine/math-lib';
+import type { Actor } from '../../../../../engine/actor';
+import type { DispersionCalculator } from './dispersion-calculator';
+export interface Point {
+    x: number;
+    y: number;
+}
+export interface AABB {
+    min: Point;
+    max: Point;
+}
+export interface Edge {
+    point1: Point;
+    point2: Point;
+}
+export interface EdgeWithNormal extends Edge {
+    normal: Vector2;
+}
+export type BoxGeometry = {
+    center: Point;
+    points: Array<Point>;
+    edges: Array<EdgeWithNormal>;
+};
+export type CircleGeometry = {
+    center: Point;
+    radius: number;
+};
+export type Geometry = BoxGeometry | CircleGeometry;
+export interface OrientationData {
+    transform: {
+        offsetX: number;
+        offsetY: number;
+        rotation: number;
+        scaleX: number;
+        scaleY: number;
+    };
+    collider: {
+        type: string;
+        centerX: number;
+        centerY: number;
+        radius?: number;
+        sizeX?: number;
+        sizeY?: number;
+    };
+}
+export interface CollisionEntry {
+    actor: Actor;
+    aabb: AABB;
+    geometry: Geometry;
+    orientationData: OrientationData;
+    edges: Record<Axis, [SortedItem, SortedItem]>;
+}
+export interface SortedItem {
+    entry: CollisionEntry;
+    value: number;
+}
+export interface AxisEntry {
+    sortedList: Array<SortedItem>;
+    dispersionCalculator: DispersionCalculator;
+}
+export type Axis = 'x' | 'y';
+export interface Axes {
+    x: AxisEntry;
+    y: AxisEntry;
+}
+export type CollisionPair = [CollisionEntry, CollisionEntry];
+export type Intersection = {
+    mtv1: Vector2;
+    mtv2: Vector2;
+};

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

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

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

@@ -0,0 +1,11 @@
+import type { SystemOptions } from '../../../../../engine/system';
+export declare class CollisionSolver {
+    private scene;
+    private gravitationalAcceleration;
+    constructor(options: SystemOptions);
+    mount(): void;
+    unmount(): void;
+    private handleCollision;
+    private validateCollision;
+    private addReactionForce;
+}

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

@@ -0,0 +1,52 @@
+import { Vector2 } from '../../../../../engine/math-lib';
+import { RigidBody } from '../../../../components/rigid-body';
+import { Collision, AddForce, StopMovement } from '../../../../events';
+import { RIGID_BODY_TYPE } from '../../consts';
+const REACTION_FORCE_VECTOR_X = 0;
+const REACTION_FORCE_VECTOR_Y = -1;
+export class CollisionSolver {
+    scene;
+    gravitationalAcceleration;
+    constructor(options) {
+        const { scene, gravitationalAcceleration } = options;
+        this.scene = scene;
+        this.gravitationalAcceleration = gravitationalAcceleration;
+    }
+    mount() {
+        this.scene.addEventListener(Collision, this.handleCollision);
+    }
+    unmount() {
+        this.scene.removeEventListener(Collision, this.handleCollision);
+    }
+    handleCollision = (event) => {
+        const { actor1, actor2, mtv1 } = event;
+        if (!this.validateCollision(actor1, actor2)) {
+            return;
+        }
+        this.addReactionForce(actor1, mtv1);
+    };
+    validateCollision(actor1, actor2) {
+        const rigidBody1 = actor1.getComponent(RigidBody);
+        const rigidBody2 = actor2.getComponent(RigidBody);
+        if (!rigidBody1 || !rigidBody2) {
+            return false;
+        }
+        if (rigidBody2.type === RIGID_BODY_TYPE.STATIC) {
+            return !rigidBody1.ghost && !rigidBody2.ghost;
+        }
+        return !rigidBody1.ghost && !rigidBody1.isPermeable
+            && !rigidBody2.ghost && !rigidBody2.isPermeable;
+    }
+    addReactionForce(actor, mtv) {
+        const rigidBody = actor.getComponent(RigidBody);
+        const { useGravity, mass } = rigidBody;
+        if (useGravity && mtv.y && Math.sign(mtv.y) === -1 && !mtv.x) {
+            const reactionForce = new Vector2(REACTION_FORCE_VECTOR_X, REACTION_FORCE_VECTOR_Y);
+            reactionForce.multiplyNumber(mass * this.gravitationalAcceleration);
+            actor.dispatchEventImmediately(AddForce, {
+                value: reactionForce,
+            });
+            actor.dispatchEventImmediately(StopMovement);
+        }
+    }
+}

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

@@ -0,0 +1,15 @@
+import type { SystemOptions } from '../../../../../engine/system';
+export declare class ConstraintSolver {
+    private actorCollection;
+    private scene;
+    private processedPairs;
+    private mtvMap;
+    constructor(options: SystemOptions);
+    mount(): void;
+    unmount(): void;
+    private handleCollision;
+    private validateCollision;
+    private setMtv;
+    private resolveCollision;
+    update(): void;
+}

package/build/contrib/systems/physics-system/subsystems/constraint-solver/index.js

@@ -0,0 +1,123 @@
+import { Vector2 } from '../../../../../engine/math-lib';
+import { ActorCollection } from '../../../../../engine/actor';
+import { RigidBody } from '../../../../components/rigid-body';
+import { Transform } from '../../../../components/transform';
+import { Collision } from '../../../../events';
+import { RIGID_BODY_TYPE } from '../../consts';
+export class ConstraintSolver {
+    actorCollection;
+    scene;
+    processedPairs;
+    mtvMap;
+    constructor(options) {
+        this.actorCollection = new ActorCollection(options.scene, {
+            components: [
+                RigidBody,
+                Transform,
+            ],
+        });
+        this.scene = options.scene;
+        this.processedPairs = {};
+        this.mtvMap = {};
+    }
+    mount() {
+        this.scene.addEventListener(Collision, this.handleCollision);
+    }
+    unmount() {
+        this.scene.removeEventListener(Collision, this.handleCollision);
+    }
+    handleCollision = (event) => {
+        const { actor1, actor2, mtv1, mtv2, } = event;
+        const id1 = actor1.id;
+        const id2 = actor2.id;
+        if (this.processedPairs[id2] && this.processedPairs[id2][id1]) {
+            return;
+        }
+        this.processedPairs[id1] ??= {};
+        this.processedPairs[id1][id2] = true;
+        if (!this.validateCollision(actor1, actor2)) {
+            return;
+        }
+        this.resolveCollision(actor1, actor2, mtv1, mtv2);
+    };
+    validateCollision(actor1, actor2) {
+        const rigidBody1 = actor1.getComponent(RigidBody);
+        const rigidBody2 = actor2.getComponent(RigidBody);
+        if (!rigidBody1 || !rigidBody2) {
+            return false;
+        }
+        if (rigidBody1.type === RIGID_BODY_TYPE.STATIC && rigidBody2.type === RIGID_BODY_TYPE.STATIC) {
+            return false;
+        }
+        if (rigidBody1.type === RIGID_BODY_TYPE.STATIC || rigidBody2.type === RIGID_BODY_TYPE.STATIC) {
+            return !rigidBody1.ghost && !rigidBody2.ghost;
+        }
+        return !rigidBody1.ghost && !rigidBody1.isPermeable
+            && !rigidBody2.ghost && !rigidBody2.isPermeable;
+    }
+    setMtv(id, mtvX, mtvY, type) {
+        this.mtvMap[id] = this.mtvMap[id] || {};
+        if (!this.mtvMap[id][type]) {
+            this.mtvMap[id][type] = new Vector2(mtvX, mtvY);
+            return;
+        }
+        const settingStrategy = {
+            static: () => {
+                this.mtvMap[id][type].x = Math.abs(mtvX) > Math.abs(this.mtvMap[id][type].x)
+                    ? mtvX
+                    : this.mtvMap[id][type].x;
+                this.mtvMap[id][type].y = Math.abs(mtvY) > Math.abs(this.mtvMap[id][type].y)
+                    ? mtvY
+                    : this.mtvMap[id][type].y;
+            },
+            dynamic: () => {
+                this.mtvMap[id][type].x += mtvX;
+                this.mtvMap[id][type].y += mtvY;
+            },
+        };
+        settingStrategy[type]();
+    }
+    resolveCollision(actor1, actor2, mtv1, mtv2) {
+        const id1 = actor1.id;
+        const id2 = actor2.id;
+        const rigidBody1 = actor1.getComponent(RigidBody);
+        const rigidBody2 = actor2.getComponent(RigidBody);
+        if (rigidBody1.type === RIGID_BODY_TYPE.STATIC) {
+            this.setMtv(id2, mtv2.x, mtv2.y, rigidBody1.type);
+        }
+        else if (rigidBody2.type === RIGID_BODY_TYPE.STATIC) {
+            this.setMtv(id1, mtv1.x, mtv1.y, rigidBody2.type);
+        }
+        else {
+            this.setMtv(id1, mtv1.x / 2, mtv1.y / 2, rigidBody2.type);
+            this.setMtv(id2, mtv2.x / 2, mtv2.y / 2, rigidBody1.type);
+        }
+    }
+    update() {
+        Object.keys(this.mtvMap).forEach((id) => {
+            const actor = this.actorCollection.getById(id);
+            const transform = actor.getComponent(Transform);
+            const mtvs = Object.keys(this.mtvMap[id]);
+            if (mtvs.length === 1) {
+                transform.offsetX += this.mtvMap[id][mtvs[0]].x;
+                transform.offsetY += this.mtvMap[id][mtvs[0]].y;
+                return;
+            }
+            const { static: staticMtv, dynamic: dynamicMtv } = this.mtvMap[id];
+            /*
+             * TODO:: Enable this part when it will be possible to run
+             * phycics pipeline several times per single game loop iteration
+             */
+            // transform.offsetX += Math.sign(staticMtv.x) === Math.sign(dynamicMtv.x)
+            //   ? staticMtv.x + dynamicMtv.x
+            //   : staticMtv.x || dynamicMtv.x;
+            // transform.offsetY += Math.sign(staticMtv.y) === Math.sign(dynamicMtv.y)
+            //   ? staticMtv.y + dynamicMtv.y
+            //   : staticMtv.y || dynamicMtv.y;
+            transform.offsetX += staticMtv.x + dynamicMtv.x;
+            transform.offsetY += staticMtv.y + dynamicMtv.y;
+        });
+        this.processedPairs = {};
+        this.mtvMap = {};
+    }
+}

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

@@ -0,0 +1,5 @@
+export { PhysicsSubsystem } from './physics';
+export { CollisionDetectionSubsystem } from './collision-detection';
+export { CollisionBroadcastSubsystem } from './collision-broadcast';
+export { CollisionSolver } from './collision-solver';
+export { ConstraintSolver } from './constraint-solver';

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

@@ -0,0 +1,5 @@
+export { PhysicsSubsystem } from './physics';
+export { CollisionDetectionSubsystem } from './collision-detection';
+export { CollisionBroadcastSubsystem } from './collision-broadcast';
+export { CollisionSolver } from './collision-solver';
+export { ConstraintSolver } from './constraint-solver';

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

@@ -0,0 +1,18 @@
+import type { SystemOptions, UpdateOptions } from '../../../../../engine/system';
+export declare class PhysicsSubsystem {
+    private scene;
+    private actorCollection;
+    private gravitationalAcceleration;
+    private actorVectors;
+    constructor(options: SystemOptions);
+    mount(): void;
+    unmount(): void;
+    private handleActorRemove;
+    private handleStopMovement;
+    private handleAddForce;
+    private handleAddImpulse;
+    private setUpVectors;
+    private applyDragForce;
+    private getGravityForce;
+    update(options: UpdateOptions): void;
+}

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

@@ -0,0 +1,131 @@
+import { Vector2 } from '../../../../../engine/math-lib';
+import { ActorCollection } from '../../../../../engine/actor';
+import { RigidBody } from '../../../../components/rigid-body';
+import { Transform } from '../../../../components/transform';
+import { AddForce, AddImpulse, StopMovement, } from '../../../../events';
+import { RemoveActor } from '../../../../../engine/events';
+const DIRECTION_VECTOR = {
+    UP: new Vector2(0, -1),
+    LEFT: new Vector2(-1, 0),
+    RIGHT: new Vector2(1, 0),
+    DOWN: new Vector2(0, 1),
+};
+export class PhysicsSubsystem {
+    scene;
+    actorCollection;
+    gravitationalAcceleration;
+    actorVectors;
+    constructor(options) {
+        const { gravitationalAcceleration, scene, } = options;
+        this.scene = scene;
+        this.actorCollection = new ActorCollection(scene, {
+            components: [
+                RigidBody,
+                Transform,
+            ],
+        });
+        this.gravitationalAcceleration = gravitationalAcceleration;
+        this.actorVectors = {};
+    }
+    mount() {
+        this.actorCollection.addEventListener(RemoveActor, this.handleActorRemove);
+        this.scene.addEventListener(StopMovement, this.handleStopMovement);
+        this.scene.addEventListener(AddForce, this.handleAddForce);
+        this.scene.addEventListener(AddImpulse, this.handleAddImpulse);
+    }
+    unmount() {
+        this.actorCollection.removeEventListener(RemoveActor, this.handleActorRemove);
+        this.scene.removeEventListener(StopMovement, this.handleStopMovement);
+        this.scene.removeEventListener(AddForce, this.handleAddForce);
+        this.scene.removeEventListener(AddImpulse, this.handleAddImpulse);
+    }
+    handleActorRemove = (event) => {
+        const { actor } = event;
+        delete this.actorVectors[actor.id];
+    };
+    handleStopMovement = (event) => {
+        const { target } = event;
+        if (!this.actorVectors[target.id]) {
+            this.setUpVectors(target);
+        }
+        this.actorVectors[target.id].velocity.multiplyNumber(0);
+    };
+    handleAddForce = (event) => {
+        const { target, value } = event;
+        if (!this.actorVectors[target.id]) {
+            this.setUpVectors(target);
+        }
+        this.actorVectors[target.id].force.add(value);
+    };
+    handleAddImpulse = (event) => {
+        const { target, value } = event;
+        if (!this.actorVectors[target.id]) {
+            this.setUpVectors(target);
+        }
+        this.actorVectors[target.id].impulse.add(value);
+    };
+    setUpVectors(actor) {
+        this.actorVectors[actor.id] = {
+            velocity: new Vector2(0, 0),
+            force: new Vector2(0, 0),
+            impulse: new Vector2(0, 0),
+        };
+    }
+    applyDragForce(actor, deltaTime) {
+        const { mass, drag } = actor.getComponent(RigidBody);
+        const velocity = this.actorVectors[actor.id]?.velocity;
+        if (!drag || !velocity || (!velocity.x && !velocity.y)) {
+            return;
+        }
+        const velocitySignX = Math.sign(velocity.x);
+        const velocitySignY = Math.sign(velocity.y);
+        const reactionForceValue = mass * this.gravitationalAcceleration;
+        const dragForceValue = -1 * drag * reactionForceValue;
+        const forceToVelocityMultiplier = deltaTime / mass;
+        const slowdownValue = dragForceValue * forceToVelocityMultiplier;
+        const normalizationMultiplier = 1 / velocity.magnitude;
+        const slowdown = velocity.clone();
+        slowdown.multiplyNumber(slowdownValue * normalizationMultiplier);
+        velocity.add(slowdown);
+        if (Math.sign(velocity.x) !== velocitySignX && Math.sign(velocity.y) !== velocitySignY) {
+            velocity.multiplyNumber(0);
+        }
+    }
+    getGravityForce(rigidBody) {
+        const { mass, useGravity } = rigidBody;
+        const gravityVector = new Vector2(0, 0);
+        if (useGravity) {
+            gravityVector.add(DIRECTION_VECTOR.DOWN);
+            gravityVector.multiplyNumber(mass * this.gravitationalAcceleration);
+        }
+        return gravityVector;
+    }
+    update(options) {
+        const { deltaTime } = options;
+        const deltaTimeInMsec = deltaTime;
+        const deltaTimeInSeconds = deltaTimeInMsec / 1000;
+        this.actorCollection.forEach((actor) => {
+            const rigidBody = actor.getComponent(RigidBody);
+            const transform = actor.getComponent(Transform);
+            const { mass } = rigidBody;
+            if (!this.actorVectors[actor.id]) {
+                this.setUpVectors(actor);
+            }
+            const { velocity, force, impulse } = this.actorVectors[actor.id];
+            force.add(this.getGravityForce(rigidBody));
+            if (force.x || force.y) {
+                force.multiplyNumber(deltaTimeInSeconds / mass);
+                velocity.add(force);
+            }
+            if (impulse.x || impulse.y) {
+                impulse.multiplyNumber(1 / mass);
+                velocity.add(impulse);
+            }
+            this.applyDragForce(actor, deltaTimeInSeconds);
+            transform.offsetX += velocity.x * deltaTimeInSeconds;
+            transform.offsetY += velocity.y * deltaTimeInSeconds;
+            force.multiplyNumber(0);
+            impulse.multiplyNumber(0);
+        });
+    }
+}

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

@@ -0,0 +1,4 @@
+import type { SystemOptions } from '../../../engine/system';
+export interface PhysicsSystemOptions extends SystemOptions {
+    gravitationalAcceleration: number;
+}

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

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

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

@@ -0,0 +1,18 @@
+import { System } from '../../../engine/system';
+import type { SystemOptions, UpdateOptions } from '../../../engine/system';
+import { Script } from './types';
+import type { ScriptOptions, ScriptConstructor } from './types';
+export { Script, ScriptOptions, ScriptConstructor };
+export declare class ScriptSystem extends System {
+    private scriptsCollection;
+    private actorSpawner;
+    private scripts;
+    private scene;
+    private activeScripts;
+    constructor(options: SystemOptions);
+    mount(): void;
+    unmount(): void;
+    private handleActorRemove;
+    private setUpScript;
+    update(options: UpdateOptions): void;
+}

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

@@ -0,0 +1,68 @@
+import { System } from '../../../engine/system';
+import { ActorCollection } from '../../../engine/actor';
+import { ScriptBundle } from '../../components';
+import { RemoveActor } from '../../../engine/events';
+import { Script } from './types';
+export { Script };
+export class ScriptSystem extends System {
+    scriptsCollection;
+    actorSpawner;
+    scripts;
+    scene;
+    activeScripts;
+    constructor(options) {
+        super();
+        const { actorSpawner, scene, resources = {}, } = options;
+        this.scene = scene;
+        this.scriptsCollection = new ActorCollection(scene, {
+            components: [
+                ScriptBundle,
+            ],
+        });
+        this.actorSpawner = actorSpawner;
+        this.scripts = resources.reduce((acc, script) => {
+            if (script.scriptName === undefined) {
+                throw new Error(`Missing scriptName field for ${script.name} script.`);
+            }
+            acc[script.scriptName] = script;
+            return acc;
+        }, {});
+        this.activeScripts = {};
+    }
+    mount() {
+        this.scriptsCollection.addEventListener(RemoveActor, this.handleActorRemove);
+    }
+    unmount() {
+        this.scriptsCollection.removeEventListener(RemoveActor, this.handleActorRemove);
+        this.scriptsCollection.forEach((actor) => {
+            this.activeScripts[actor.id].forEach((script) => script.destroy?.());
+            delete this.activeScripts[actor.id];
+        });
+    }
+    handleActorRemove = (event) => {
+        const { actor } = event;
+        this.activeScripts[actor.id].forEach((script) => script.destroy?.());
+        delete this.activeScripts[actor.id];
+    };
+    setUpScript(actor) {
+        const { scripts } = actor.getComponent(ScriptBundle);
+        this.activeScripts[actor.id] = scripts.map((script) => {
+            const ScriptClass = this.scripts[script.name];
+            return new ScriptClass({
+                ...script.options,
+                actor,
+                actorSpawner: this.actorSpawner,
+                scene: this.scene,
+            });
+        });
+    }
+    update(options) {
+        this.scriptsCollection.forEach((actor) => {
+            if (!this.activeScripts[actor.id]) {
+                this.setUpScript(actor);
+            }
+            this.activeScripts[actor.id].forEach((script) => script.update?.(options));
+        });
+    }
+}
+ScriptSystem.systemName = 'ScriptSystem';

package/build/contrib/systems/script-system/types.d.ts

@@ -0,0 +1,20 @@
+import type { Actor, ActorSpawner } from '../../../engine/actor';
+import type { Scene } from '../../../engine/scene';
+import type { Constructor } from '../../../types/utils';
+export interface ScriptOptions {
+    scene: Scene;
+    actor: Actor;
+    actorSpawner: ActorSpawner;
+}
+interface UpdateOptions {
+    deltaTime: number;
+}
+export declare abstract class Script {
+    static scriptName: string;
+    destroy?(): void;
+    update?(options: UpdateOptions): void;
+}
+export type ScriptConstructor = Constructor<Script> & {
+    scriptName: string;
+};
+export {};

package/build/contrib/systems/script-system/types.js

@@ -0,0 +1,3 @@
+export class Script {
+    static scriptName;
+}

package/build/contrib/systems/sprite-renderer/index.d.ts

@@ -0,0 +1,2 @@
+export { SpriteRenderer } from './renderer';
+export { SpriteRendererService } from './service';

package/build/contrib/systems/sprite-renderer/index.js

@@ -0,0 +1,2 @@
+export { SpriteRenderer } from './renderer';
+export { SpriteRendererService } from './service';

package/build/contrib/systems/sprite-renderer/light-subsystem/index.d.ts

@@ -0,0 +1,13 @@
+import type { Scene } from 'three/src/Three';
+import type { ActorCollection } from '../../../../engine/actor';
+export declare class LightSubsystem {
+    private renderScene;
+    private lightsCollection;
+    private lightsMap;
+    constructor(renderScene: Scene, lightsCollection: ActorCollection);
+    mount(): void;
+    unmount(): void;
+    private handleLightRemove;
+    private setUpActor;
+    update(): void;
+}