dacha 0.15.0 → 0.15.2

package/build/contrib/components/collider/index.d.ts

@@ -0,0 +1,19 @@
+import { Component } from '../../../engine/component';
+export interface ColliderConfig {
+    type: 'box' | 'circle';
+    centerX: number;
+    centerY: number;
+    sizeX?: number;
+    sizeY?: number;
+    radius?: number;
+}
+export declare class Collider extends Component {
+    type: 'box' | 'circle';
+    centerX: number;
+    centerY: number;
+    sizeX?: number;
+    sizeY?: number;
+    radius?: number;
+    constructor(config: ColliderConfig);
+    clone(): Collider;
+}

package/build/contrib/components/collider/index.js

@@ -0,0 +1,29 @@
+import { Component } from '../../../engine/component';
+export class Collider extends Component {
+    type;
+    centerX;
+    centerY;
+    sizeX;
+    sizeY;
+    radius;
+    constructor(config) {
+        super();
+        this.type = config.type;
+        this.centerX = config.centerX;
+        this.centerY = config.centerY;
+        this.sizeX = config.sizeX;
+        this.sizeY = config.sizeY;
+        this.radius = config.radius;
+    }
+    clone() {
+        return new Collider({
+            type: this.type,
+            centerX: this.centerX,
+            centerY: this.centerY,
+            sizeX: this.sizeX,
+            sizeY: this.sizeY,
+            radius: this.radius,
+        });
+    }
+}
+Collider.componentName = 'Collider';

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

@@ -2,8 +2,8 @@ export { Camera } from './camera';
 export type { CameraConfig } from './camera';
 export { KeyboardControl } from './keyboard-control';
 export type { KeyboardControlConfig } from './keyboard-control';
-export { ColliderContainer } from './collider-container';
-export type { ColliderContainerConfig } from './collider-container';
+export { Collider } from './collider';
+export type { ColliderConfig } from './collider';
 export { RigidBody } from './rigid-body';
 export type { RigidBodyConfig } from './rigid-body';
 export { Animatable } from './animatable';

package/build/contrib/components/index.js

@@ -1,6 +1,6 @@
 export { Camera } from './camera';
 export { KeyboardControl } from './keyboard-control';
-export { ColliderContainer } from './collider-container';
+export { Collider } from './collider';
 export { RigidBody } from './rigid-body';
 export { Animatable } from './animatable';
 export { Sprite } from './sprite';

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

@@ -4,16 +4,15 @@ import type { WorldSystemOptions } from '../../../engine/system';
 export declare class AudioSystem extends WorldSystem {
     private templateCollection;
     private world;
-    private scene?;
     private audioContext;
     private audioGroups;
     private audioStore;
     private audioState;
-    private actorCollections;
+    private actorCollection?;
     constructor(options: WorldSystemOptions);
     onSceneLoad(scene: Scene): Promise<void>;
     onSceneEnter(scene: Scene): void;
-    onSceneExit(scene: Scene): void;
+    onSceneExit(): void;
     onSceneDestroy(scene: Scene): void;
     onWorldDestroy(): void;
     private loadAudio;

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

@@ -4,18 +4,17 @@ import { AddActor, RemoveActor } from '../../../engine/events';
 import { CacheStore } from '../../../engine/data-lib';
 import { AudioSource } from '../../components';
 import { PlayAudio, StopAudio, SetAudioVolume, } from '../../../events';
-import { getAllTemplateSources, loadAudio } from './utils';
+import { getAllSources, loadAudio } from './utils';
 const MASTER_GROUP = 'master';
 const VOLUME_TOLERANCE = 0.001;
 export class AudioSystem extends WorldSystem {
     templateCollection;
     world;
-    scene;
     audioContext;
     audioGroups;
     audioStore;
     audioState;
-    actorCollections;
+    actorCollection;
     constructor(options) {
         super();
         const { world, globalOptions, templateCollection } = options;
@@ -38,7 +37,6 @@ export class AudioSystem extends WorldSystem {
         }, { [MASTER_GROUP]: masterAudioGroup });
         this.audioStore = new CacheStore();
         this.audioState = new Map();
-        this.actorCollections = {};
         this.world.addEventListener(PlayAudio, this.handlePlayAudio);
         this.world.addEventListener(StopAudio, this.handleStopAudio);
         this.world.addEventListener(SetAudioVolume, this.handleSetAudioVolume);
@@ -47,12 +45,9 @@ export class AudioSystem extends WorldSystem {
         window.addEventListener('touchstart', this.resumeIfSuspended, { once: true });
     }
     async onSceneLoad(scene) {
-        this.actorCollections[scene.id] = new ActorCollection(scene, {
-            components: [AudioSource],
-        });
         const allSources = [
-            ...getAllTemplateSources(this.templateCollection),
-            ...this.actorCollections[scene.id].map((actor) => actor.getComponent(AudioSource).src),
+            ...getAllSources(this.templateCollection.getAll()),
+            ...getAllSources(scene.children),
         ];
         const uniqueSources = [...new Set(allSources)];
         const audioBuffers = await Promise.all(uniqueSources.map((src) => {
@@ -66,27 +61,28 @@ export class AudioSystem extends WorldSystem {
         allSources.forEach((src) => this.audioStore.retain(src));
     }
     onSceneEnter(scene) {
-        this.scene = scene;
-        this.actorCollections[scene.id]?.forEach((actor) => this.initAudio(actor));
-        this.actorCollections[scene.id]?.addEventListener(AddActor, this.handleActorAdd);
-        this.actorCollections[scene.id]?.addEventListener(RemoveActor, this.handleActorRemove);
+        this.actorCollection = new ActorCollection(scene, {
+            components: [AudioSource],
+        });
+        this.actorCollection.forEach((actor) => this.initAudio(actor));
+        this.actorCollection.addEventListener(AddActor, this.handleActorAdd);
+        this.actorCollection.addEventListener(RemoveActor, this.handleActorRemove);
     }
-    onSceneExit(scene) {
+    onSceneExit() {
         this.audioState.forEach((audioState) => {
             audioState.sourceNode.stop();
         });
-        this.actorCollections[scene.id]?.removeEventListener(AddActor, this.handleActorAdd);
-        this.actorCollections[scene.id]?.removeEventListener(RemoveActor, this.handleActorRemove);
-        this.scene = undefined;
+        this.actorCollection?.removeEventListener(AddActor, this.handleActorAdd);
+        this.actorCollection?.removeEventListener(RemoveActor, this.handleActorRemove);
+        this.actorCollection = undefined;
     }
     onSceneDestroy(scene) {
         const allSources = [
-            ...getAllTemplateSources(this.templateCollection),
-            ...this.actorCollections[scene.id].map((actor) => actor.getComponent(AudioSource).src),
+            ...getAllSources(this.templateCollection.getAll()),
+            ...getAllSources(scene.children),
         ];
         allSources.forEach((src) => this.audioStore.release(src));
         this.audioStore.cleanReleased();
-        delete this.actorCollections[scene.id];
     }
     onWorldDestroy() {
         void this.audioContext.close();
@@ -215,10 +211,7 @@ export class AudioSystem extends WorldSystem {
         }
     }
     update() {
-        if (!this.scene) {
-            return;
-        }
-        this.actorCollections[this.scene.id]?.forEach((actor) => {
+        this.actorCollection?.forEach((actor) => {
             const audioSource = actor.getComponent(AudioSource);
             const audioState = this.audioState.get(actor.id);
             if (audioSource.playing && audioState) {

package/build/contrib/systems/audio-system/utils.d.ts

@@ -1,3 +1,4 @@
-import type { TemplateCollection } from '../../../engine/template';
-export declare const getAllTemplateSources: (templateCollection: TemplateCollection) => string[];
+import type { Actor } from '../../../engine/actor';
+import type { Template } from '../../../engine/template';
+export declare const getAllSources: (actors: (Actor | Template)[]) => string[];
 export declare const loadAudio: (url: string) => Promise<ArrayBuffer>;

package/build/contrib/systems/audio-system/utils.js

@@ -1,16 +1,16 @@
 import { AudioSource } from '../../components';
 import { traverseEntity } from '../../../engine/entity';
-export const getAllTemplateSources = (templateCollection) => {
-    const templateSources = [];
-    templateCollection.getAll().forEach((template) => {
-        traverseEntity(template, (entity) => {
+export const getAllSources = (actors) => {
+    const sources = [];
+    actors.forEach((actor) => {
+        traverseEntity(actor, (entity) => {
             const audioSource = entity.getComponent(AudioSource);
             if (audioSource?.src) {
-                templateSources.push(audioSource.src);
+                sources.push(audioSource.src);
             }
         });
     });
-    return templateSources;
+    return sources;
 };
 export const loadAudio = async (url) => {
     const response = await fetch(url);

package/build/contrib/systems/physics-system/subsystems/collision-detection/aabb-builders/index.js

@@ -1,6 +1,6 @@
 import { buildBoxAABB } from './build-box-aabb';
 import { buildCircleAABB } from './build-circle-aabb';
 export const aabbBuilders = {
-    boxCollider: buildBoxAABB,
-    circleCollider: buildCircleAABB,
+    box: buildBoxAABB,
+    circle: buildCircleAABB,
 };

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

@@ -1,3 +1,3 @@
-import type { ColliderContainer, Transform } from '../../../../../components';
+import type { Collider, Transform } from '../../../../../components';
 import type { BoxGeometry } from '../types';
-export declare const buildBoxGeometry: (container: ColliderContainer, transform: Transform) => BoxGeometry;
+export declare const buildBoxGeometry: (collider: Collider, transform: Transform) => BoxGeometry;

package/build/contrib/systems/physics-system/subsystems/collision-detection/geometry-builders/build-box-geometry.js

@@ -1,8 +1,8 @@
 import { VectorOps } from '../../../../../../engine/math-lib';
-export const buildBoxGeometry = (container, transform) => {
+export const buildBoxGeometry = (collider, transform) => {
     const { offsetX, offsetY, scaleX, scaleY, rotation, } = transform;
-    let { centerX, centerY } = container.collider;
-    const { sizeX, sizeY } = container.collider;
+    let { centerX, centerY } = collider;
+    const { sizeX, sizeY } = collider;
     const x1 = -(sizeX / 2);
     const x2 = (sizeX / 2);
     const y1 = -(sizeY / 2);

package/build/contrib/systems/physics-system/subsystems/collision-detection/geometry-builders/build-circle-geometry.d.ts

@@ -1,3 +1,3 @@
-import type { ColliderContainer, Transform } from '../../../../../components';
+import type { Collider, Transform } from '../../../../../components';
 import type { CircleGeometry } from '../types';
-export declare const buildCircleGeometry: (container: ColliderContainer, transform: Transform) => CircleGeometry;
+export declare const buildCircleGeometry: (collider: Collider, transform: Transform) => CircleGeometry;

package/build/contrib/systems/physics-system/subsystems/collision-detection/geometry-builders/build-circle-geometry.js

@@ -1,6 +1,6 @@
-export const buildCircleGeometry = (container, transform) => {
+export const buildCircleGeometry = (collider, transform) => {
     const { offsetX, offsetY, scaleX, scaleY, } = transform;
-    const { centerX, centerY, radius } = container.collider;
+    const { centerX, centerY, radius } = collider;
     const center = {
         x: centerX + offsetX,
         y: centerY + offsetY,

package/build/contrib/systems/physics-system/subsystems/collision-detection/geometry-builders/index.d.ts

@@ -1,4 +1,4 @@
-import type { ColliderContainer, Transform } from '../../../../../components';
+import type { Collider, Transform } from '../../../../../components';
 import type { Geometry } from '../types';
-export type BuildGeometryFn = (container: ColliderContainer, transform: Transform) => Geometry;
+export type BuildGeometryFn = (collider: Collider, transform: Transform) => Geometry;
 export declare const geometryBuilders: Record<string, BuildGeometryFn>;

package/build/contrib/systems/physics-system/subsystems/collision-detection/geometry-builders/index.js

@@ -1,6 +1,6 @@
 import { buildBoxGeometry } from './build-box-geometry';
 import { buildCircleGeometry } from './build-circle-geometry';
 export const geometryBuilders = {
-    boxCollider: buildBoxGeometry,
-    circleCollider: buildCircleGeometry,
+    box: buildBoxGeometry,
+    circle: buildCircleGeometry,
 };

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

@@ -1,5 +1,5 @@
 import { ActorCollection } from '../../../../../engine/actor';
-import { Transform, ColliderContainer, RigidBody, } from '../../../../components';
+import { Transform, Collider, RigidBody, } from '../../../../components';
 import { AddActor, RemoveActor } from '../../../../../engine/events';
 import { Collision } from '../../../../events';
 import { insertionSort } from '../../../../../engine/data-lib';
@@ -18,7 +18,7 @@ export class CollisionDetectionSubsystem {
     constructor(options) {
         this.actorCollection = new ActorCollection(options.scene, {
             components: [
-                ColliderContainer,
+                Collider,
                 Transform,
             ],
         });
@@ -56,14 +56,14 @@ export class CollisionDetectionSubsystem {
             return true;
         }
         const transform = actor.getComponent(Transform);
-        const colliderContainer = actor.getComponent(ColliderContainer);
+        const collider = actor.getComponent(Collider);
         const transformOld = entry.orientationData.transform;
         const colliderOld = entry.orientationData.collider;
-        return checkTransform(transform, transformOld) || checkCollider(colliderContainer, colliderOld);
+        return checkTransform(transform, transformOld) || checkCollider(collider, colliderOld);
     }
     getOrientationData(actor) {
         const transform = actor.getComponent(Transform);
-        const colliderContainer = actor.getComponent(ColliderContainer);
+        const collider = actor.getComponent(Collider);
         return {
             transform: {
                 offsetX: transform.offsetX,
@@ -73,20 +73,20 @@ export class CollisionDetectionSubsystem {
                 scaleY: transform.scaleY,
             },
             collider: {
-                type: colliderContainer.type,
-                centerX: colliderContainer.collider.centerX,
-                centerY: colliderContainer.collider.centerY,
-                sizeX: colliderContainer.collider.sizeX,
-                sizeY: colliderContainer.collider.sizeY,
-                radius: colliderContainer.collider.radius,
+                type: collider.type,
+                centerX: collider.centerX,
+                centerY: collider.centerY,
+                sizeX: collider.sizeX,
+                sizeY: collider.sizeY,
+                radius: collider.radius,
             },
         };
     }
     addCollisionEntry(actor) {
         const transform = actor.getComponent(Transform);
-        const colliderContainer = actor.getComponent(ColliderContainer);
-        const geometry = geometryBuilders[colliderContainer.type](colliderContainer, transform);
-        const aabb = aabbBuilders[colliderContainer.type](geometry);
+        const collider = actor.getComponent(Collider);
+        const geometry = geometryBuilders[collider.type](collider, transform);
+        const aabb = aabbBuilders[collider.type](geometry);
         const entry = {
             actor,
             aabb,
@@ -101,9 +101,9 @@ export class CollisionDetectionSubsystem {
     }
     updateCollisionEntry(actor) {
         const transform = actor.getComponent(Transform);
-        const colliderContainer = actor.getComponent(ColliderContainer);
-        const geometry = geometryBuilders[colliderContainer.type](colliderContainer, transform);
-        const aabb = aabbBuilders[colliderContainer.type](geometry);
+        const collider = actor.getComponent(Collider);
+        const geometry = geometryBuilders[collider.type](collider, transform);
+        const aabb = aabbBuilders[collider.type](geometry);
         const entry = this.entriesMap.get(actor.id);
         const prevAABB = entry.aabb;
         entry.aabb = aabb;
@@ -181,8 +181,8 @@ export class CollisionDetectionSubsystem {
     }
     checkOnIntersection(pair) {
         const [arg1, arg2] = pair;
-        const type1 = arg1.actor.getComponent(ColliderContainer).type;
-        const type2 = arg2.actor.getComponent(ColliderContainer).type;
+        const type1 = arg1.actor.getComponent(Collider).type;
+        const type2 = arg2.actor.getComponent(Collider).type;
         return intersectionCheckers[type1][type2](arg1, arg2);
     }
     sendCollisionEvent(actor1, actor2, intersection) {

package/build/contrib/systems/physics-system/subsystems/collision-detection/intersection-checkers/check-box-and-circle-intersection.js

@@ -1,4 +1,4 @@
-import { ColliderContainer } from '../../../../../components';
+import { Collider } from '../../../../../components';
 import { MathOps, Vector2, VectorOps } from '../../../../../../engine/math-lib';
 const getMtvs = (axis, overlap, point1, point2) => {
     axis.multiplyNumber((1 / axis.magnitude) * overlap);
@@ -28,7 +28,7 @@ const getMtvs = (axis, overlap, point1, point2) => {
 export const checkBoxAndCircleIntersection = (arg1, arg2) => {
     let box;
     let circle;
-    if (arg1.actor.getComponent(ColliderContainer).type === 'boxCollider') {
+    if (arg1.actor.getComponent(Collider).type === 'box') {
         box = arg1.geometry;
         circle = arg2.geometry;
     }

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

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

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

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

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

@@ -1,15 +1,13 @@
-export const checkCollider = (colliderContainer, colliderOld) => {
-    if (colliderContainer.type !== colliderOld.type) {
+export const checkCollider = (collider, colliderOld) => {
+    if (collider.type !== colliderOld.type) {
         return true;
     }
-    if (colliderContainer.type === 'boxCollider') {
-        const collider = colliderContainer.collider;
+    if (collider.type === 'box') {
         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-solver/index.d.ts

@@ -1,7 +1,7 @@
 import type { SceneSystemOptions } from '../../../../../engine/system';
 export declare class CollisionSolver {
     private scene;
-    private gravitationalAcceleration;
+    private gravity;
     constructor(options: SceneSystemOptions);
     destroy(): void;
     private handleCollision;

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

@@ -6,11 +6,11 @@ const REACTION_FORCE_VECTOR_X = 0;
 const REACTION_FORCE_VECTOR_Y = -1;
 export class CollisionSolver {
     scene;
-    gravitationalAcceleration;
+    gravity;
     constructor(options) {
-        const { scene, gravitationalAcceleration } = options;
+        const { scene, gravity } = options;
         this.scene = scene;
-        this.gravitationalAcceleration = gravitationalAcceleration;
+        this.gravity = gravity;
         this.scene.addEventListener(Collision, this.handleCollision);
     }
     destroy() {
@@ -40,7 +40,7 @@ export class CollisionSolver {
         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);
+            reactionForce.multiplyNumber(mass * this.gravity);
             actor.dispatchEventImmediately(AddForce, {
                 value: reactionForce,
             });

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

@@ -2,7 +2,7 @@ import type { SceneSystemOptions, UpdateOptions } from '../../../../../engine/sy
 export declare class PhysicsSubsystem {
     private scene;
     private actorCollection;
-    private gravitationalAcceleration;
+    private gravity;
     private actorVectors;
     constructor(options: SceneSystemOptions);
     destroy(): void;

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

@@ -13,10 +13,10 @@ const DIRECTION_VECTOR = {
 export class PhysicsSubsystem {
     scene;
     actorCollection;
-    gravitationalAcceleration;
+    gravity;
     actorVectors;
     constructor(options) {
-        const { gravitationalAcceleration, scene, } = options;
+        const { gravity, scene, } = options;
         this.scene = scene;
         this.actorCollection = new ActorCollection(scene, {
             components: [
@@ -24,7 +24,7 @@ export class PhysicsSubsystem {
                 Transform,
             ],
         });
-        this.gravitationalAcceleration = gravitationalAcceleration;
+        this.gravity = gravity;
         this.actorVectors = {};
         this.actorCollection.addEventListener(RemoveActor, this.handleActorRemove);
         this.scene.addEventListener(StopMovement, this.handleStopMovement);
@@ -77,7 +77,7 @@ export class PhysicsSubsystem {
         }
         const velocitySignX = Math.sign(velocity.x);
         const velocitySignY = Math.sign(velocity.y);
-        const reactionForceValue = mass * this.gravitationalAcceleration;
+        const reactionForceValue = mass * this.gravity;
         const dragForceValue = -1 * drag * reactionForceValue;
         const forceToVelocityMultiplier = deltaTime / mass;
         const slowdownValue = dragForceValue * forceToVelocityMultiplier;
@@ -94,7 +94,7 @@ export class PhysicsSubsystem {
         const gravityVector = new Vector2(0, 0);
         if (useGravity) {
             gravityVector.add(DIRECTION_VECTOR.DOWN);
-            gravityVector.multiplyNumber(mass * this.gravitationalAcceleration);
+            gravityVector.multiplyNumber(mass * this.gravity);
         }
         return gravityVector;
     }

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

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

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

@@ -2,8 +2,7 @@ import { WorldSystem } from '../../../engine/system';
 import type { WorldSystemOptions } from '../../../engine/system';
 import type { Scene } from '../../../engine/scene';
 export declare class SpriteRenderer extends WorldSystem {
-    private scene?;
-    private actorCollections;
+    private actorCollection?;
     private window;
     private renderScene;
     private currentCamera;
@@ -21,7 +20,7 @@ export declare class SpriteRenderer extends WorldSystem {
     constructor(options: WorldSystemOptions);
     onSceneLoad(scene: Scene): Promise<void>;
     onSceneEnter(scene: Scene): void;
-    onSceneExit(scene: Scene): void;
+    onSceneExit(): void;
     onSceneDestroy(scene: Scene): void;
     onWorldDestroy(): void;
     private handleActorAdd;

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

@@ -14,10 +14,9 @@ import { composeSort, createSortByLayer, sortByYAxis, sortByXAxis, sortByZAxis,
 import { parseSortingLayers } from './sort/utils';
 import { LightSubsystem } from './light-subsystem';
 import { createMaterial, updateMaterial } from './material-factory';
-import { loadImage, prepareSprite, getAllTemplateSources, getTextureMapKey, cloneTexture, } from './utils';
+import { loadImage, prepareSprite, getAllSources, getTextureMapKey, cloneTexture, } from './utils';
 export class SpriteRenderer extends WorldSystem {
-    scene;
-    actorCollections;
+    actorCollection;
     window;
     renderScene;
     currentCamera;
@@ -35,7 +34,6 @@ export class SpriteRenderer extends WorldSystem {
     constructor(options) {
         super();
         const { globalOptions, windowNodeId, backgroundColor, backgroundAlpha, templateCollection, world, } = options;
-        this.actorCollections = {};
         this.templateCollection = templateCollection;
         this.window = getWindowNode(windowNodeId);
         this.sortFn = composeSort([
@@ -71,12 +69,9 @@ export class SpriteRenderer extends WorldSystem {
         this.window.appendChild(this.renderer.domElement);
     }
     async onSceneLoad(scene) {
-        this.actorCollections[scene.id] = new ActorCollection(scene, {
-            components: [Sprite, Transform],
-        });
         const allSources = [
-            ...getAllTemplateSources(this.templateCollection),
-            ...this.actorCollections[scene.id].map((actor) => actor.getComponent(Sprite).src),
+            ...getAllSources(this.templateCollection.getAll()),
+            ...getAllSources(scene.children),
         ];
         const uniqueSources = [...new Set(allSources)];
         const images = await Promise.all(uniqueSources.map((src) => {
@@ -90,30 +85,31 @@ export class SpriteRenderer extends WorldSystem {
         allSources.forEach((src) => this.imageStore.retain(src));
     }
     onSceneEnter(scene) {
-        this.scene = scene;
+        this.actorCollection = new ActorCollection(scene, {
+            components: [Sprite, Transform],
+        });
         this.handleWindowResize();
         this.lightSubsystem.onSceneEnter(scene);
-        this.actorCollections[scene.id]?.addEventListener(AddActor, this.handleActorAdd);
-        this.actorCollections[scene.id]?.addEventListener(RemoveActor, this.handleActorRemove);
+        this.actorCollection.addEventListener(AddActor, this.handleActorAdd);
+        this.actorCollection.addEventListener(RemoveActor, this.handleActorRemove);
     }
-    onSceneExit(scene) {
-        this.actorCollections[scene.id]?.removeEventListener(AddActor, this.handleActorAdd);
-        this.actorCollections[scene.id]?.removeEventListener(RemoveActor, this.handleActorRemove);
+    onSceneExit() {
+        this.actorCollection?.removeEventListener(AddActor, this.handleActorAdd);
+        this.actorCollection?.removeEventListener(RemoveActor, this.handleActorRemove);
         this.lightSubsystem.onSceneExit();
         this.actorsMap.clear();
         this.spriteCache.clear();
         this.textureMap.clear();
         this.renderScene.clear();
-        this.scene = undefined;
+        this.actorCollection = undefined;
     }
     onSceneDestroy(scene) {
         const allSources = [
-            ...getAllTemplateSources(this.templateCollection),
-            ...this.actorCollections[scene.id].map((actor) => actor.getComponent(Sprite).src),
+            ...getAllSources(this.templateCollection.getAll()),
+            ...getAllSources(scene.children),
         ];
         allSources.forEach((src) => this.imageStore.release(src));
         this.imageStore.cleanReleased();
-        delete this.actorCollections[scene.id];
     }
     onWorldDestroy() {
         window.removeEventListener('resize', this.handleWindowResize);
@@ -218,7 +214,7 @@ export class SpriteRenderer extends WorldSystem {
         this.currentCamera.updateProjectionMatrix();
     }
     updateActors() {
-        this.actorCollections[this.scene.id].forEach((actor, index) => {
+        this.actorCollection?.forEach((actor, index) => {
             const transform = actor.getComponent(Transform);
             const sprite = actor.getComponent(Sprite);
             if (!this.actorsMap.has(actor.id)) {
@@ -245,10 +241,8 @@ export class SpriteRenderer extends WorldSystem {
     update() {
         this.updateCamera();
         this.lightSubsystem.update();
-        if (this.scene) {
-            this.actorCollections[this.scene.id].sort(this.sortFn);
-            this.updateActors();
-        }
+        this.actorCollection?.sort(this.sortFn);
+        this.updateActors();
         this.renderer.render(this.renderScene, this.currentCamera);
     }
 }

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

@@ -1,8 +1,9 @@
 import { Texture } from 'three/src/Three';
 import { Sprite } from '../../components/sprite';
-import type { TemplateCollection } from '../../../engine/template';
+import type { Actor } from '../../../engine/actor';
+import type { Template } from '../../../engine/template';
 export declare const loadImage: (spriteSourcePath: string) => Promise<HTMLImageElement>;
 export declare const prepareSprite: (image: HTMLImageElement, sprite: Sprite) => Texture[];
-export declare const getAllTemplateSources: (templateCollection: TemplateCollection) => string[];
+export declare const getAllSources: (actors: (Actor | Template)[]) => string[];
 export declare const getTextureMapKey: ({ slice, fit, width, height, src, }: Sprite) => string;
 export declare const cloneTexture: (sprite: Sprite, texture: Texture) => Texture;

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

@@ -15,17 +15,17 @@ export const prepareSprite = (image, sprite) => {
     });
     return textures;
 };
-export const getAllTemplateSources = (templateCollection) => {
-    const templateSources = [];
-    templateCollection.getAll().forEach((template) => {
-        traverseEntity(template, (entity) => {
-            const audioSource = entity.getComponent(Sprite);
-            if (audioSource?.src) {
-                templateSources.push(audioSource.src);
+export const getAllSources = (actors) => {
+    const sources = [];
+    actors.forEach((actor) => {
+        traverseEntity(actor, (entity) => {
+            const sprite = entity.getComponent(Sprite);
+            if (sprite?.src) {
+                sources.push(sprite.src);
             }
         });
     });
-    return templateSources;
+    return sources;
 };
 export const getTextureMapKey = ({ slice, fit, width = 0, height = 0, src, }) => `${slice}_${fit}_${width}_${height}_${src}`;
 export const cloneTexture = (sprite, texture) => {

package/build/engine/scene/scene-manager.d.ts

@@ -23,8 +23,8 @@ export declare class SceneManager {
     private actorCreator;
     private actorSpawner;
     private world;
+    private worldSystems;
     private loadedScenes;
-    private systems;
     private activeSceneId?;
     constructor({ sceneConfigs, systemConfigs, availableSystems, components, templateCollection, globalOptions, resources, }: SceneManagerOptions);
     loadWorld(): Promise<void>;

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

@@ -3,6 +3,7 @@ import { ActorCreator, ActorSpawner } from '../actor';
 import { SceneSystem, WorldSystem } from '../system';
 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;
@@ -14,8 +15,8 @@ export class SceneManager {
     actorCreator;
     actorSpawner;
     world;
+    worldSystems;
     loadedScenes;
-    systems;
     activeSceneId;
     constructor({ sceneConfigs, systemConfigs, availableSystems, components, templateCollection, globalOptions, resources, }) {
         this.availableSystems = availableSystems.reduce((acc, AvailableSystem) => {
@@ -33,12 +34,12 @@ export class SceneManager {
         this.actorCreator = new ActorCreator(components, templateCollection);
         this.actorSpawner = new ActorSpawner(this.actorCreator);
         this.world = new World({ id: uuid(), name: 'world' });
+        this.worldSystems = new Map();
         this.loadedScenes = new Map();
-        this.systems = new Map();
         this.activeSceneId = undefined;
         this.systemConfigs.forEach((config) => {
             const SystemClass = this.availableSystems[config.name];
-            if (Object.getPrototypeOf(SystemClass) === WorldSystem) {
+            if (isSubclassOf(SystemClass, WorldSystem)) {
                 const options = {
                     ...config.options,
                     templateCollection: this.templateCollection,
@@ -47,10 +48,7 @@ export class SceneManager {
                     globalOptions: this.globalOptions,
                     world: this.world,
                 };
-                this.systems.set(config.name, new SystemClass(options));
-            }
-            if (Object.getPrototypeOf(SystemClass) === SceneSystem) {
-                this.systems.set(config.name, new Map());
+                this.worldSystems.set(config.name, new SystemClass(options));
             }
         });
         this.world.addEventListener(LoadScene, this.handleLoadScene);
@@ -65,15 +63,14 @@ export class SceneManager {
     }
     destroyWorld() {
         this.exitActiveScene();
-        this.loadedScenes.forEach((scene) => {
-            this.destroyScene(scene.id);
+        this.loadedScenes.forEach((entry) => {
+            this.destroyScene(entry.scene.id);
         });
         this.getSystems().forEach((system) => {
             if (system instanceof WorldSystem) {
                 system.onWorldDestroy?.(this.world);
             }
         });
-        this.systems.clear();
         this.world.removeEventListener(LoadScene, this.handleLoadScene);
         this.world.removeEventListener(EnterScene, this.handleEnterScene);
         this.world.removeEventListener(ExitScene, this.handleExitScene);
@@ -98,17 +95,15 @@ export class SceneManager {
         if (!this.activeSceneId) {
             return undefined;
         }
-        return this.world.findChildById(this.activeSceneId, false);
+        return this.loadedScenes.get(this.activeSceneId)?.scene;
     }
     getSystems(scene) {
         scene ??= this.getActiveScene();
+        const sceneSystems = scene ? this.loadedScenes.get(scene.id)?.systems : undefined;
         return this.systemConfigs.reduce((acc, config) => {
-            const entry = this.systems.get(config.name);
-            if (entry instanceof WorldSystem) {
-                acc.push(entry);
-            }
-            if (entry instanceof Map && scene && entry.has(scene.id)) {
-                acc.push(entry.get(scene.id));
+            const system = this.worldSystems.get(config.name) ?? sceneSystems?.get(config.name);
+            if (system) {
+                acc.push(system);
             }
             return acc;
         }, []);
@@ -117,14 +112,23 @@ export class SceneManager {
         if (!this.sceneConfigs[id]) {
             throw new Error(`Error while loading scene. Not found scene with id: ${id}`);
         }
+        if (this.loadedScenes.get(id)?.isLoading) {
+            return;
+        }
+        if (this.loadedScenes.has(id) && !this.loadedScenes.get(id)?.isLoading) {
+            if (id === this.activeSceneId) {
+                this.exitActiveScene();
+            }
+            this.destroyScene(id);
+        }
         const scene = new Scene({
             ...this.sceneConfigs[id],
             actorCreator: this.actorCreator,
             templateCollection: this.templateCollection,
         });
-        this.systemConfigs.forEach((config) => {
+        const sceneSystems = this.systemConfigs.reduce((acc, config) => {
             const SystemClass = this.availableSystems[config.name];
-            if (Object.getPrototypeOf(SystemClass) === SceneSystem) {
+            if (isSubclassOf(SystemClass, SceneSystem)) {
                 const options = {
                     ...config.options,
                     templateCollection: this.templateCollection,
@@ -134,23 +138,32 @@ export class SceneManager {
                     scene,
                     world: this.world,
                 };
-                const sceneSystems = this.systems.get(config.name);
-                sceneSystems.set(scene.id, new SystemClass(options));
+                acc.set(config.name, new SystemClass(options));
             }
-        });
+            return acc;
+        }, new Map());
+        const loadEntry = { scene, systems: sceneSystems, isLoading: true };
+        this.loadedScenes.set(scene.id, loadEntry);
         await Promise.all(this.getSystems(scene).map((system) => system.onSceneLoad?.(scene)));
-        this.loadedScenes.set(scene.id, scene);
+        loadEntry.isLoading = false;
         this.world.dispatchEvent(SceneLoaded, { scene });
         if (autoEnter) {
             this.enterScene(id, autoDestroy);
         }
     }
     enterScene(id, autoDestroy) {
-        const scene = this.loadedScenes.get(id);
-        if (!scene) {
+        const entry = this.loadedScenes.get(id);
+        if (!entry) {
             throw new Error(`Error while entering scene. Not found scene with same id: ${id}`);
         }
+        if (entry.isLoading) {
+            throw new Error(`Error while entering scene. Scene with id: ${id} is still loading`);
+        }
+        if (id === this.activeSceneId) {
+            return;
+        }
         this.exitActiveScene(autoDestroy);
+        const { scene } = entry;
         this.world.appendChild(scene);
         this.getSystems(scene).forEach((system) => system.onSceneEnter?.(scene));
         this.activeSceneId = id;
@@ -170,20 +183,15 @@ export class SceneManager {
         }
     }
     destroyScene(id) {
-        const scene = this.loadedScenes.get(id);
-        if (!scene) {
+        const entry = this.loadedScenes.get(id);
+        if (!entry) {
             return;
         }
+        const { scene } = entry;
         if (scene.id === this.activeSceneId) {
             throw new Error('Error while destroying scene. Cannot destroy active scene. You should exit first.');
         }
         this.getSystems(scene).forEach((system) => system.onSceneDestroy?.(scene));
-        this.systemConfigs.forEach((config) => {
-            const entry = this.systems.get(config.name);
-            if (entry instanceof Map && entry.has(scene.id)) {
-                entry.delete(scene.id);
-            }
-        });
         this.loadedScenes.delete(id);
         this.world.dispatchEvent(SceneDestroyed, { scene });
     }

package/build/engine/scene/tests/mocks/scene-config.mock.d.ts

@@ -0,0 +1,2 @@
+import type { SceneConfig } from '../../../types';
+export declare const getSceneConfigMock: (id: string) => SceneConfig;

package/build/engine/scene/tests/mocks/scene-config.mock.js

@@ -0,0 +1,5 @@
+export const getSceneConfigMock = (id) => ({
+    id,
+    name: id,
+    actors: [],
+});

package/build/engine/scene/tests/mocks/system-config.mock.d.ts

@@ -0,0 +1,2 @@
+import type { SystemConfig } from '../../../types';
+export declare const getSystemConfigMock: (name: string) => SystemConfig;

package/build/engine/scene/tests/mocks/system-config.mock.js

@@ -0,0 +1,4 @@
+export const getSystemConfigMock = (name) => ({
+    name,
+    options: {},
+});

package/build/engine/scene/tests/mocks/system.mock.d.ts

@@ -0,0 +1,22 @@
+import { Scene } from '../..';
+import { World } from '../../../world';
+import { WorldSystem, SceneSystem, WorldSystemOptions, SceneSystemOptions } from '../../../system';
+export declare class SceneSystemMock extends SceneSystem {
+    private fns?;
+    constructor(options: SceneSystemOptions);
+    onSceneLoad(scene: Scene): Promise<void>;
+    onSceneEnter(scene: Scene): void;
+    onSceneExit(scene: Scene): void;
+    onSceneDestroy(scene: Scene): void;
+}
+export declare class WorldSystemMock extends WorldSystem {
+    private fns?;
+    constructor(options: WorldSystemOptions);
+    onWorldLoad(world: World): Promise<void>;
+    onWorldReady(world: World): void;
+    onWorldDestroy(world: World): void;
+    onSceneLoad(scene: Scene): Promise<void>;
+    onSceneEnter(scene: Scene): void;
+    onSceneExit(scene: Scene): void;
+    onSceneDestroy(scene: Scene): void;
+}

package/build/engine/scene/tests/mocks/system.mock.js

@@ -0,0 +1,48 @@
+import { WorldSystem, SceneSystem, } from '../../../system';
+export class SceneSystemMock extends SceneSystem {
+    fns;
+    constructor(options) {
+        super();
+        this.fns = options.resources;
+    }
+    async onSceneLoad(scene) {
+        await this.fns?.loadSceneFn(scene);
+    }
+    onSceneEnter(scene) {
+        this.fns?.enterSceneFn(scene);
+    }
+    onSceneExit(scene) {
+        this.fns?.exitSceneFn(scene);
+    }
+    onSceneDestroy(scene) {
+        this.fns?.destroySceneFn(scene);
+    }
+}
+export class WorldSystemMock extends WorldSystem {
+    fns;
+    constructor(options) {
+        super();
+        this.fns = options.resources;
+    }
+    async onWorldLoad(world) {
+        await this.fns?.loadWorldFn(world);
+    }
+    onWorldReady(world) {
+        this.fns?.readyWorldFn(world);
+    }
+    onWorldDestroy(world) {
+        this.fns?.destroyWorldFn(world);
+    }
+    async onSceneLoad(scene) {
+        await this.fns?.loadSceneFn(scene);
+    }
+    onSceneEnter(scene) {
+        this.fns?.enterSceneFn(scene);
+    }
+    onSceneExit(scene) {
+        this.fns?.exitSceneFn(scene);
+    }
+    onSceneDestroy(scene) {
+        this.fns?.destroySceneFn(scene);
+    }
+}

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

@@ -1,2 +1,2 @@
 export { SceneSystem, WorldSystem } from './system';
-export type { SystemConstructor, SceneSystemOptions, WorldSystemOptions, UpdateOptions, } from './system';
+export type { System, SystemConstructor, SceneSystemOptions, WorldSystemOptions, UpdateOptions, } from './system';

package/build/engine/utils/is-subclass-of.d.ts

@@ -0,0 +1 @@
+export declare const isSubclassOf: (subclass: unknown, superclass: unknown) => boolean;

package/build/engine/utils/is-subclass-of.js

@@ -0,0 +1,10 @@
+export const isSubclassOf = (subclass, superclass) => {
+    let proto = Object.getPrototypeOf(subclass);
+    while (proto) {
+        if (proto === superclass) {
+            return true;
+        }
+        proto = Object.getPrototypeOf(proto);
+    }
+    return false;
+};

package/build/index.d.ts

@@ -4,7 +4,7 @@ export { VectorOps, MathOps, Vector2 } from './engine/math-lib';
 export * from './engine/consts';
 export * from './engine/types';
 export { WorldSystem, SceneSystem } from './engine/system';
-export type { WorldSystemOptions, SceneSystemOptions, UpdateOptions, } from './engine/system';
+export type { System, WorldSystemOptions, SceneSystemOptions, UpdateOptions, } from './engine/system';
 export type { ActorCollectionFilter, ActorSpawner, } from './engine/actor';
 export type { EventTarget, Event, EventType, EventPayload, ListenerFn, } from './engine/event-target';
 export type { Scene } from './engine/scene';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dacha",
-  "version": "0.15.0",
+  "version": "0.15.2",
   "main": "./build/index.js",
   "types": "./build/index.d.ts",
   "exports": {

package/build/contrib/components/collider-container/box-collider.d.ts

@@ -1,7 +0,0 @@
-export declare class BoxCollider {
-    sizeX: number;
-    sizeY: number;
-    centerX: number;
-    centerY: number;
-    constructor(config: Record<string, number>);
-}

package/build/contrib/components/collider-container/box-collider.js

@@ -1,12 +0,0 @@
-export class BoxCollider {
-    sizeX;
-    sizeY;
-    centerX;
-    centerY;
-    constructor(config) {
-        this.sizeX = config.sizeX;
-        this.sizeY = config.sizeY;
-        this.centerX = config.centerX;
-        this.centerY = config.centerY;
-    }
-}

package/build/contrib/components/collider-container/circle-collider.d.ts

@@ -1,6 +0,0 @@
-export declare class CircleCollider {
-    radius: number;
-    centerX: number;
-    centerY: number;
-    constructor(config: Record<string, number>);
-}

package/build/contrib/components/collider-container/circle-collider.js

@@ -1,10 +0,0 @@
-export class CircleCollider {
-    radius;
-    centerX;
-    centerY;
-    constructor(config) {
-        this.radius = config.radius;
-        this.centerX = config.centerX;
-        this.centerY = config.centerY;
-    }
-}

package/build/contrib/components/collider-container/index.d.ts

@@ -1,13 +0,0 @@
-import { Component } from '../../../engine/component';
-import { BoxCollider } from './box-collider';
-import { CircleCollider } from './circle-collider';
-export interface ColliderContainerConfig {
-    type: 'boxCollider' | 'circleCollider';
-    collider: Record<string, number>;
-}
-export declare class ColliderContainer extends Component {
-    type: 'boxCollider' | 'circleCollider';
-    collider: BoxCollider | CircleCollider;
-    constructor(config: ColliderContainerConfig);
-    clone(): ColliderContainer;
-}

package/build/contrib/components/collider-container/index.js

@@ -1,28 +0,0 @@
-import { Component } from '../../../engine/component';
-import { BoxCollider } from './box-collider';
-import { CircleCollider } from './circle-collider';
-const COLLIDER_MAP = {
-    boxCollider: BoxCollider,
-    circleCollider: CircleCollider,
-};
-export class ColliderContainer extends Component {
-    type;
-    collider;
-    constructor(config) {
-        super();
-        const colliderContainerConfig = config;
-        this.type = colliderContainerConfig.type;
-        if (!COLLIDER_MAP[this.type]) {
-            throw new Error(`Not found collider with same type: ${this.type}`);
-        }
-        const Collider = COLLIDER_MAP[this.type];
-        this.collider = new Collider(colliderContainerConfig.collider);
-    }
-    clone() {
-        return new ColliderContainer({
-            type: this.type,
-            collider: this.collider,
-        });
-    }
-}
-ColliderContainer.componentName = 'ColliderContainer';